Sum series in c

1 + 2 + 3 + 4 +.................................. + 𝑛 =?
#include<stdio.h>
int main()
{
int n,sum=0;
printf("Enter the number of term:");
scanf("%d",&n);
sum=(n*(n+1))/2;
printf("Summation is: %d",sum);
return 0;
}
Sum of the series
2 2 2 2
1 + 2 + 3 +............................. + 𝑛 =?
#include<stdio.h>
int main()
{
int n,sum=0;
printf("Enter the number of term:");
scanf("%d",&n);
sum=(n*(n+1)*(2*n+1))/6;
//By using loop….from 1 to n;
//sum += i*i;
printf("Summation is: %d",sum);
return 0;
}
Sum of the series
3 3 3 3
1 + 2 + 3 +............................. + 𝑛 =?
#include<stdio.h>
#include<math.h>
int main()
{
int n,sum=0;
printf("Enter the number of term:");
scanf("%d",&n);
sum=pow((n*(n+1))/2,2);
printf("Summation is: %d",sum);
return 0;
}

Arithmetic progression(AP)....
#include<stdio.h>
#include<math.h>
int main()
{
int a, d, n,sum=0;
printf("Enter first term:");
 scanf("%d",&a);
printf("Enter the difference:");
scanf("%d",&d);
printf("Enter the number of term:");
scanf("%d",&n);

sum=(n*(2*a+(n-1)*d))/2;
printf("Summation is: %d",sum);
}
Geometric progression(GP)....

Prime number cheek ….

#include<bits/stdc++.h>
using namespace std;
bool Isprime(int n)
{
if(n==0 || n==1)
return false;
for(int i=2;i<=n/2;i++)
{
if(n%i==0)
return false;
}
return true;
}
int main()
{
int n;
printf("Enter a range:");
 scanf("%d",&n);
for(int i=0;i<=n;i++)
{
if(Isprime(i))
{
printf("%d ",i);
}
}
return 0;
}

Quadratic equation solution in c

#include <math.h>
#include <stdio.h>
int main() {
double a, b, c, discriminant, root1, root2, realPart, imagPart;
printf("Enter coefficients a, b and c: ");
scanf("%lf %lf %lf", &a, &b, &c);

discriminant = b * b - 4 * a * c;

// condition for real and different roots

if (discriminant > 0) {
root1 = (-b + sqrt(discriminant)) / (2 * a);
root2 = (-b - sqrt(discriminant)) / (2 * a);
printf("root1 = %.2lf and root2 = %.2lf", root1, root2);
}

// condition for real and equal roots

else if (discriminant == 0) {
root1 = root2 = -b / (2 * a);
printf("root1 = root2 = %.2lf;", root1);
}

// if roots are not real

else {
realPart = -b / (2 * a);
imagPart = sqrt(-discriminant) / (2 * a);
printf("root1 = %.2lf+%.2lfi and root2 = %.2f-%.2fi", realPart, imagPart, realPart, imagPart);
}

return 0;
}
Dynamic Memory Allocation:
C Dynamic Memory Allocation can be defined as a procedure in which the size of a data structure (like
Array) is changed during the runtime.
C malloc() method
The “malloc” or “memory allocation” method in C is used to dynamically allocate a single large block of
memory with the specified size. It returns a pointer of type void which can be cast into a pointer of any
form. It doesn’t Initialize memory at execution time so that it has initialized each block with the default
garbage value initially.
Syntax of malloc() in C
ptr = (cast-type*) malloc(byte-size)
For Example:
ptr = (int*) malloc(100 * sizeof(int));

C calloc() method
1. “calloc” or “contiguous allocation” method in C is used to dynamically allocate the specified
number of blocks of memory of the specified type. it is very much similar to malloc() but has two
different points and these are:
2. It initializes each block with a default value ‘0’.
3. It has two parameters or arguments as compare to malloc().
Syntax of calloc() in C
ptr = (cast-type*)calloc(n, element-size);

C free() method
“free” method in C is used to dynamically de-allocate the memory. The memory allocated using
functions malloc() and calloc() is not de-allocated on their own. Hence the free() method is used,
whenever the dynamic memory allocation takes place. It helps to reduce wastage of memory by freeing
it.
Syntax of free() in C
free(ptr);

C realloc() method
“realloc” or “re-allocation” method in C is used to dynamically change the memory allocation of a
previously allocated memory. In other words, if the memory previously allocated with the help of malloc
or calloc is insufficient, realloc can be used to dynamically re-allocate memory. re-allocation of memory
maintains the already present value and new blocks will be initialized with the default garbage value.
Syntax of realloc() in C
ptr = realloc(ptr, newSize);

What is a Pointer in C?
A pointer is defined as a derived data type that can store the address of other C variables or a memory
location. We can access and manipulate the data stored in that memory location using pointers.
As the pointers in C store the memory addresses, their size is independent of the type of data they are
pointing to. This size of pointers in C only depends on the system architecture.
Syntax of C Pointers
The syntax of pointers is similar to the variable declaration in C, but we use the ( * ) dereferencing
operator in the pointer declaration.
datatype * ptr;
where
● ptr is the name of the pointer.
● datatype is the type of data it is pointing to.
The above syntax is used to define a pointer to a variable. We can also define pointers to functions,
structures, etc.
Benefits(use) of pointers in c:
​ Pointers provide direct access to memory
​ Pointers provide a way to return more than one value to the functions
​ Reduces the storage space and complexity of the program
​ Reduces the execution time of the program
​ Provides an alternate way to access array elements
​ Pointers can be used to pass information back and forth between the calling function and called
function.
​ Pointers allows us to perform dynamic memory allocation and deallocation.
​ Pointers helps us to build complex data structures like linked list, stack, queues, trees, graphs etc.
​ Pointers allows us to resize the dynamically allocated memory block.
​ Addresses of objects can be extracted using pointers
Difference between the Call by Value and Call by Reference in C++
Call by Value in C++
In the call-by-value method, function arguments are passed by copying the value of the actual
parameter, ensuring the original values remain unchanged. The value is copied to the formal parameter.
One is the original copy and the other is the function copy. Any changes made to the parameters within
the function do not change the original values outside the function.
Call by Reference in C++
In the call-by-reference method, the memory address (reference) of the actual parameter is passed to
the function, allowing direct access and modification of the original values. The actual and the formal
parameters point to the same memory address. Any changes made to the parameters within the
function are directly reflected in the original values outside the function.
Difference between the Call by Value and Call by Reference in C++
The major difference between the two methods of passing the parameters is given below:
Feature Call by Value Call by Reference
Value Passed In this method, the value of the variable is In call by reference memory address of the
passed to the function. variable is passed.
Scope of In this method, the original value remains In this method, the changes made are
Changes unchanged even when we make changes in reflected in the original variable.
the function.
Performance It may require extra memory and time to It is more memory and time efficient as
copy so less efficient. compared to “call by value”.
Memory The memory addresses of the actual and The actual and the formal parameters point at
Location formal parameters are different. the same memory address.
Applications Mainly used to pass values for small data It is used when we want to modify the original
or when we do not want to change original value or save resources.
values.

Function Overloading (achieved at compile time)

Function Overloading provides multiple definitions of the function by changing signature i.e. changing
number of parameters, change datatype of parameters, return type doesn’t play any role.
● It can be done in base as well as derived class
.Example:
void area(int a);
void area(int a, int b);
Function Overriding (achieved at run time)
It is the redefinition of base class function in its derived class with same signature i.e. return type and
parameters.
● It can only be done in derived class.
● Example:
Class a
{
public:
virtual void display(){ cout << "hello"; }
};

Class b:public a
{
public:
void display(){ cout << "bye";}
};
The difference between function overloading and overriding.

Function Overloading Function Overriding

Function Overloading provides multiple definitions Function Overriding is the redefinition of base
of the function by changing signature. class function in its derived class with same
signature.
An example of compile time polymorphism. An example of run time polymorphism.
Function signatures should be different. Function signatures should be the same.
Overloaded functions are in same scope. Overridden functions are in different scopes.
Overloading is used when the same function has to Overriding is needed when derived class
behave differently depending upon parameters function has to do some different job than the
passed to them. base class function.
A function has the ability to load multiple times. A function can be overridden only a single time.
In function overloading, we don’t need inheritance. In function overriding, we need an inheritance
concept.
Operators in C programming:
Library Functions
These functions are the built-in functions i.e., they are predefined in the library of the C. These are used
to perform the most common operations like calculations, updation, etc. Some of the library functions
are printf, scanf, sqrt, etc. To use these functions in the program the user has to use a header file
associated with the corresponding function in the program.
Example
If the user has to use print the data or scan the data using an input stream then we have to use functions
printf() and scanf() in C program and cin and cout in C++ program. To use these functions the user has to
include the e<iostream> preprocessor directive in C++ program.
User-defined Functions
These functions are designed by the user when they are writing any program because for every task we
do not have a library of functions where their definitions are predefined. To perform according to the
requirement of the user, the user has to develop some functions by itself, these functions are called
user-defined functions. For such functions, the users can write their own logic according to the
requirement.
Example
If we want to perform the addition of two numbers then below is the program to illustrate the addition
of two numbers using a user-defined function.
Difference between Local Variable and Global variable
Local variables are declared within a specific block of code, such as a function or method, and have
limited scope and lifetime, existing only within that block. Global variables, on the other hand, are
declared outside of any function and can be accessed from any part of the program, persisting
throughout its execution.
Local Variables:
● Local variables are declared within a specific block of code, such as within a function or a loop.
● They are only accessible within the block in which they are declared.
● Once the block of code in which they are declared exits, the memory allocated to these variables
is released, and they are no longer accessible.
● Local variables can have the same name as variables in other blocks without conflict because
their scope is limited to the block in which they are declared.
● They are typically used for temporary storage or only relevant data within a specific context.
Global Variables:
● Global variables are declared outside of any function or block of code, usually at the top of a
program or in a separate file.
● They are accessible from any part of the program, including within functions, loops, or other
blocks of code.
● Global variables retain their value throughout the lifetime of the program unless explicitly
modified or reset.
● Due to their accessibility from anywhere in the program, global variables can introduce
unintended side effects and make it harder to understand and debug code, especially in larger
programs.
● They are typically used for values that need to be accessed and modified by multiple parts of the
program.

Threads: A thread is a basic unit of execution of any process. A program comprises many processes and
all the processes comprise much simpler units known as threads. So, the thread can be referred to as the
basic unit of a process or it is the simpler unit that tother makes the CPU utilization
 static keyword
static keyword has different meanings when used with different types. We can use static keywords with:
1. Static Variables: Variables in a function, Variables in a class
2. Static Members of Class: Class objects and Functions in a class Let us now look at each one of
these uses of static in detail.
Static Variables
Static variables in a Function: When a variable is declared as static, space for it gets allocated for the
lifetime of the program. Even if the function is called multiple times, space for the static variable is
allocated only once and the value of the variable in the previous call gets carried through the next
function call. This is useful for implementing coroutines in C/C++ or any other application where the
previous state of function needs to be stored.
Static Members of Class
Class objects as static: Just like variables, objects also when declared as static have a scope till the
lifetime of the program. Consider the below program where the object is non-static.
Examples of using the Static Keyword in C Programs
The static keyword in c is used to define variables and functions that have a limited scope and a static
lifetime. Here are some examples of how the static keyword can be used in C programs:
Static variables:
C
void myFunction() {
static int count = 0;
count++;
printf(“The function has been called %d times.n”, count);
}
In the above example, the count variable is declared as a static variable inside the myFunction function.
Since static variables retain their values between function calls, the count variable will be incremented
each time the function is called, and the value will be retained across function calls.
Static functions:
C
static int myHelperFunction(int a, int b) {
return a + b;
}
int myFunction(int a, int b) {
return myHelperFunction(a, b);
}
In this example, the myHelperFunction function is declared as a static function. Since static functions
have a limited scope, they can only be called within the same file where they are defined. The
myFunction function calls the myHelperFunction function, which can be considered as a utility function
that is used only within the same file.
Static variables with external linkage:
C
static int x = 0;
void incrementX() {
x++;
}
int getX() {
return x;
}
In this example, the x variable is declared as a static variable with external linkage. This means that the
variable is only visible within the same file, but it can be accessed from other functions within the same
file. The incrementX function increments the x variable, and the getX function returns the value of x.
Overall, the static keyword in c provides a way to define variables and functions with a limited scope and
a static lifetime, which can be useful for managing memory more efficiently, improving performance, and
reducing potential problems such as naming conflicts and poor encapsulation.
What is Structure?
Structure is a user-defined data type in C programming language that combines logically related data
items of different data types together.
All the structure elements are stored at contiguous memory locations. Structure type variable can store
more than one data item of varying data types under one name.

Syntax of Declaring Structure

struct [name of the structure]
{
type member1;
type member2;
type member3;
};
Structure is declared using the “struct” keyword and name of structure. Number 1, number 2, number 3
are individual members of structure. The body part is terminated with a semicolon (;).
What is Union
Union is a user-defined data type, just like a structure. Union combines objects of different types and
sizes together. The union variable allocates the memory space equal to the space to hold the largest
variable of union. It allows varying types of objects to share the same location.

Syntax of Declaring Union

union [name of union]
{
type member1;
type member2;
type member3;
};
Union is declared using the “union” keyword and name of union. Number 1, number 2, number 3 are
individual members of union. The body part is terminated with a semicolon (;).

Enumeration (enums)
Enum is short for “Enumeration”. It allows the user to create custom data types with a set of named
integer constants. The “enum” keyword is used to declare an enumeration. Enum simplifies and makes
the program more readable.
Syntax
enum enum_name {const1, const2, ..., constN};
Typedef
typedef is used to redefine the existing data type names. Basically, it is used to provide new names to the
existing data types. The “typedef” keyword is used for this purpose;
Syntax
typedef existing_name alias_name;
Differences between Structure and Union
Differences between Structure and Union are as shown below in tabular format as shown below as
follows:

C – Loops
Loops in programming are used to repeat a block of code until the specified condition is met. A loop
statement allows programmers to execute a statement or group of statements multiple times without
repetition of code.
There are mainly two types of loops in C Programming:
1. Entry Controlled loops: In Entry controlled loops the test condition is checked before entering
the main body of the loop. For Loop and While Loop is Entry-controlled loops.
2. Exit Controlled loops: In Exit controlled loops the test condition is evaluated at the end of the
loop body. The loop body will execute at least once, irrespective of whether the condition is true
or false. do-while Loop is Exit Controlled loop.
for Loop
for loop in C programming is a repetition control structure that allows programmers to write a loop that
will be executed a specific number of times. for loop enables programmers to perform n number of steps
together in a single line.
Syntax:
for (initialize expression; test expression; update expression)
{
//
// body of for loop
//
}
While Loop
While loop does not depend upon the number of iterations. In for loop the number of iterations was
previously known to us but in the While loop, the execution is terminated on the basis of the test
condition. If the test condition will become false then it will break from the while loop else body will be
executed.
Syntax:
initialization_expression;
while (test_expression)
{
// body of the while loop
 update_expression;
}
do-while Loop
The do-while loop is similar to a while loop but the only difference lies in the do-while loop test
condition which is tested at the end of the body. In the do-while loop, the loop body will execute at least
once irrespective of the test condition.
Syntax:
initialization_expression;
do
{
// body of do-while loop

update_expression;

} while (test_expression);

Escape Sequence in C
The escape sequence in C is the characters or the sequence of characters that can be used inside the
string literal. The purpose of the escape sequence is to represent the characters that cannot be used
normally using the keyboard. Some escape sequence characters are the part of ASCII charset but some
are not.
Different escape sequences represent different characters but the output is dependent on the compiler
you are using.
Escape Sequence List
Escape Name Description
Sequence
\a Alarm or Beep It is used to generate a bell sound in the C program.
\b Backspace It is used to move the cursor one place backward.
\f Form Feed It is used to move the cursor to the start of the next logical
page.
\n New Line It moves the cursor to the start of the next line.
\r Carriage Return It moves the cursor to the start of the current line.
\t Horizontal Tab It inserts some whitespace to the left of the cursor and moves
the cursor accordingly.
\v Vertical Tab It is used to insert vertical space.
\\ Backlash Use to insert backslash character.
\’ Single Quote It is used to display a single quotation mark.
\” Double Quote It is used to display double quotation marks.
\? Question Mark It is used to display a question mark.
\ooo Octal Number It is used to represent an octal number.
\xhh Hexadecimal Number It represents the hexadecimal number.

\0 NULL It represents the NULL character.

 \e Escape sequence It represents the ASCII escape character.
\s Space Character It represents the ASCII space character.
\d Delete Character It represents the ASCII DEL character.

Tokens in C
A token in C can be defined as the smallest individual element of the C programming language that is
meaningful to the compiler. It is the basic component of a C program.
Types of Tokens in C
The tokens of C language can be classified into six types based on the functions they are used to
perform. The types of C tokens are as follows:

1. Keywords
2. Identifiers
3. Constants
4. Strings
5. Special Symbols
6. Operators
1. C Token – Keywords
The keywords are pre-defined or reserved words in a programming language. Each keyword is meant to
perform a specific function in a program. Since keywords are referred names for a compiler, they can’t be
used as variable names because by doing so, we are trying to assign a new meaning to the keyword
which is not allowed. You cannot redefine keywords. However, you can specify the text to be substituted
for keywords before compilation by using C preprocessor directives. C language supports 32 keywords
which are given below:
auto double int struct
break else long switch
case enum register typedef
char extern return union
const float short unsigned
continue for signed void
default goto sizeof volatile
do if static while
Note: The number of keywords may change depending on the version of C you are using. For example,
keywords present in ANSI C are 32 while in C11, it was increased to 44. Moreover, in the latest c23, it is
increased to around 54.
2. C Token – Identifiers
Identifiers are used as the general terminology for the naming of variables, functions, and arrays. These
are user-defined names consisting of an arbitrarily long sequence of letters and digits with either a letter
or the underscore(_) as a first character. Identifier names must differ in spelling and case from any
keywords. You cannot use keywords as identifiers; they are reserved for special use. Once declared, you
can use the identifier in later program statements to refer to the associated value. A special identifier
called a statement label can be used in goto statements.
Rules for Naming Identifiers
Certain rules should be followed while naming c identifiers which are as follows:
● They must begin with a letter or underscore(_).
● They must consist of only letters, digits, or underscore. No other special character is allowed.
● It should not be a keyword.
● It must not contain white space.
● It should be up to 31 characters long as only the first 31 characters are significant.
Note: Identifiers are case-sensitive so names like variable and Variable will be treated as different.
For example,
● main: method name.
● a: variable name.
3. C Token – Constants
The constants refer to the variables with fixed values. They are like normal variables but with the
difference that their values can not be modified in the program once they are defined.
Constants may belong to any of the data types.
Examples of Constants in C
const int c_var = 20;
const int* const ptr = &c_var;
4. C Token – Strings
Strings are nothing but an array of characters ended with a null character (‘\0’). This null character
indicates the end of the string. Strings are always enclosed in double quotes. Whereas, a character is
enclosed in single quotes in C and C++.
Examples of String
char string[20] = {‘g’, ’e’, ‘e’, ‘k’, ‘s’, ‘f’, ‘o’, ‘r’, ‘g’, ’e’, ‘e’, ‘k’, ‘s’, ‘\0’};
char string[20] = “geeksforgeeks”;
char string [] = “geeksforgeeks”;
5. C Token – Special Symbols
The following special symbols are used in C having some special meaning and thus, cannot be used for
some other purpose. Some of these are listed below:
● Brackets[]: Opening and closing brackets are used as array element references. These indicate
single and multidimensional subscripts.
● Parentheses(): These special symbols are used to indicate function calls and function
parameters.
● Braces{}: These opening and ending curly braces mark the start and end of a block of code
containing more than one executable statement.
● Comma (, ): It is used to separate more than one statement like for separating parameters in
function calls.
● Colon(:): It is an operator that essentially invokes something called an initialization list.
● Semicolon(;): It is known as a statement terminator. It indicates the end of one logical entity.
That’s why each individual statement must be ended with a semicolon.
● Asterisk (*): It is used to create a pointer variable and for the multiplication of variables.
● Assignment operator(=): It is used to assign values and for logical operation validation.
● Pre-processor (#): The preprocessor is a macro processor that is used automatically by the
compiler to transform your program before actual compilation.
● Period (.): Used to access members of a structure or union.
 ● Tilde(~): Bitwise One’s Complement Operator.
6. C Token – Operators
Operators are symbols that trigger an action when applied to C variables and other objects. The data
items on which operators act are called operands.
Depending on the number of operands that an operator can act upon, operators can be classified as
follows:
● Unary Operators: Those operators that require only a single operand to act upon are known as
unary operators.For Example increment and decrement operators
● Binary Operators: Those operators that require two operands to act upon are called binary
operators. Binary operators can further are classified into:
1. Arithmetic operators
2. Relational Operators
3. Logical Operators
4. Assignment Operators
5. Bitwise Operator
● Ternary Operator: The operator that requires three operands to act upon is called the ternary
operator. Conditional Operator(?) is also called the ternary operator.

switch, case, and default

The switch statement in C is used as an alternate to the if-else ladder statement. For a single variable i.e,
switch variable it allows us to execute multiple operations for different possible values of a single
variable.
switch(Expression)
{
case '1': // operation 1
break;
case:'2': // operation 2
break;
default: // default statement to be executed
}

Topics about C and C++ (OOP)

Class
The building block of C++ that leads to Object-Oriented programming is a Class. It is a user-defined data
type, which holds its own data members and member functions, which can be accessed and used by
creating an instance of that class. A class is like a blueprint for an object.
Object
An Object is an identifiable entity with some characteristics and behavior. An Object is an instance of a
Class. When a class is defined, no memory is allocated but when it is instantiated (i.e. an object is
created) memory is allocated.
#include<bits/stdc++.h>
using namespace std;

class Room {
public:
double length;
double breadth;
double height;
 double calculateArea(){
return length * breadth;
}

double calculateVolume(){
return length * breadth * height;
}

};
int main()
{
room room1,room2;
return 0;
}

Here, we defined a class named Room.

The variables length, breadth, and height declared inside the class are known as data members.
And the functions calculateArea() and calculateVolume() are known as member functions of a class.
Encapsulation
Encapsulation is defined as wrapping up data and information under a single unit. In Object-Oriented
Programming, Encapsulation is defined as binding together the data and the functions that manipulate
them.
Two Important property of Encapsulation
1. Data Protection: Encapsulation protects the internal state of an object by keeping its data
members private. Access to and modification of these data members is restricted to the class’s
public methods, ensuring controlled and secure data manipulation.
2. Information Hiding: Encapsulation hides the internal implementation details of a class from
external code. Only the public interface of the class is accessible, providing abstraction and
simplifying the usage of the class while allowing the internal implementation to be modified
without impacting external code.
Role of Access Specifiers in Encapsulation
● Private: Private access specifier means that the member function or data member can only be
accessed by other member functions of the same class.
● Protected: A protected access specifier means that the member function or data member can be
accessed by other member functions of the same class or by derived classes.
● Public: Public access specifier means that the member function or data member can be accessed
by any code.
Abstraction
Data abstraction is one of the most essential and important features of object-oriented programming in
C++. Abstraction means displaying only essential information and hiding the details. Data abstraction
refers to providing only essential information about the data to the outside world, hiding the background
details or implementation.
● Abstraction using Classes: We can implement Abstraction in C++ using classes. The class helps us
to group data members and member functions using available access specifiers. A Class can
decide which data member will be visible to the outside world and which is not.
 ● Abstraction in Header files: One more type of abstraction in C++ can be header files. For
example, consider the pow() method present in math.h header file. Whenever we need to
calculate the power of a number, we simply call the function pow() present in the math.h header
file and pass the numbers as arguments without knowing the underlying algorithm according to
which the function is actually calculating the power of numbers.

Polymorphism
The word polymorphism means having many forms. In simple words, we can define polymorphism as the
ability of a message to be displayed in more than one form. A person at the same time can have different
characteristics. A man at the same time is a father, a husband, and an employee. So the same person
possesses different behavior in different situations. This is called polymorphism. An operation may
exhibit different behaviors in different instances. The behavior depends upon the types of data used in
the operation. C++ supports operator overloading and function overloading.
● Operator Overloading: The process of making an operator exhibit different behaviors in different
instances is known as operator overloading.
● Function Overloading: Function overloading is using a single function name to perform different
types of tasks. Polymorphism is extensively used in implementing inheritance.
Inheritance
The capability of a class to derive properties and characteristics from another class is called Inheritance.
Inheritance is one of the most important features of Object-Oriented Programming.
● Sub Class: The class that inherits properties from another class is called Sub class or Derived
Class.
● Super Class: The class whose properties are inherited by a sub-class is called Base Class or
Superclass.
● Reusability: Inheritance supports the concept of “reusability”, i.e. when we want to create a new
class and there is already a class that includes some of the code that we want, we can derive our
new class from the existing class. By doing this, we are reusing the fields and methods of the
existing class.
Dynamic Binding
In dynamic binding, the code to be executed in response to the function call is decided at runtime. C++
has virtual functions to support this. Because dynamic binding is flexible, it avoids the drawbacks of static
binding, which connected the function call and definition at build time.
Message Passing
Objects communicate with one another by sending and receiving information. A message for an object is
a request for the execution of a procedure and therefore will invoke a function in the receiving object
that generates the desired results. Message passing involves specifying the name of the object, the
name of the function, and the information to be sent.

Friend Class and Function in C++

A friend class can access private and protected members of other classes in which it is declared as a
friend. It is sometimes useful to allow a particular class to access private and protected members of
other classes. For example, a LinkedList class may be allowed to access private members of Node.
Friend Function
A friend function can access the private and protected data of a class. We declare a friend function using
the friend keyword inside the body of the class.
Like a friend class, a friend function can be granted special access to private and protected members of a
class in C++. They are the non-member functions that can access and manipulate the private and
protected members of the class for they are declared as friends.
A friend function can be:
1. A global function
2. A member function of another class

Advantages of Friend Functions

● A friend function is able to access members without the need of inheriting the class.
● The friend function acts as a bridge between two classes by accessing their private data.
● It can be used to increase the versatility of overloaded operators.
● It can be declared either in the public or private or protected part of the class.
Disadvantages of Friend Functions
● Friend functions have access to private members of a class from outside the class which violates
the law of data hiding.
● Friend functions cannot do any run-time polymorphism in their members.

Constructor:
A constructor is a member function of a class that has the same name as the class name.It is a special
type of member function that is used to initialize the data members for an object of a class automatically
when an object of the same class is created. It can either accept the arguments or not. It is used to
allocate memory to an object of the class. It is called whenever an instance of the class is created. It can
be defined manually with arguments or without arguments. There can be many constructors in a class. It
can be overloaded, but it can not be inherited or virtual. It has no return type, not even a void.
Syntax:
ClassName()
{
//Constructor's Body
}
Default Constructors
The default constructor is the most basic type of constructor. We can define the default constructor as
the constructor that does not take any argument. The default constructor is also known as the
no-parameter constructor
Parameterized Constructors
Parameterized constructor is a type of constructor in which we provide the parameters.
So, we can define the parameterized constructor as the constructor which can take the arguments that
help in object initialization.
The parameterized constructor is used to initialize all the class elements at the time of object creation
with the values present in the argument.
Copy Constructors
As the name suggests, a copy constructor is a constructor that initializes an object using another object
of the same class. We usually use the copy constructor to copy data from one object to another.
Destructor:
Like a constructor, Destructor is also a member function of a class that has the same name as the class
name preceded by a tilde(~) operator. It helps to deallocate the memory of an object. It is called while
the object of the class is freed or deleted. In a class, there is always a single destructor without any
parameters so it can’t be overloaded. It is always called in the reverse order of the constructor. if a class
is inherited by another class and both the classes have a destructor then the destructor of the child class
is called first, followed by the destructor of the parent or base class.
Syntax:
~ClassName()
{
//Destructor's Body
}

public, private, and protected

● public elements can be accessed by all other classes and functions.
● private elements cannot be accessed outside the class in which they are declared, except by
friend classes and functions.
● protected elements are just like the private, except they can be accessed by derived classes.
Recursion
Recursion is a programming concept where a function calls itself to solve a problem by breaking it down
into smaller, simpler versions of the same problem. It involves defining a base case to stop the recursive
calls and a recursive step that reduces the problem size until the base case is reached. This approach
allows elegant and concise solutions for certain problems, like traversing tree structures or calculating
factorials. However, it requires careful handling to prevent infinite loops and efficient use of system
resources.
Base case: Recursion involves a base case that stops the recursive calls to prevent infinite loops, ensuring
program termination.
Recursive call: The recursive call is the code executed repeatedly inside the recursive function while
making recursive calls.

Sum of Natural Numbers Using Recursion

#include<bits/stdc++.h>
using namespace std;
 int sum(int n)
{
if(n!=0)
return n+sum(n-1);
else
return n;
}
int main()
{
int n;
printf("Enter a range value:");
scanf("%d",&n);
printf("%d",sum(n));
return 0;
}

Factorial of a Number Using Recursion

#include<bits/stdc++.h>
using namespace std;
Int fac(int n)
{
if(n>=1)
return n*fac(n-1);
else
return 1;
}
int main()
{
int n;
printf("Enter a number:");
scanf("%d",&n);
printf("%d",fac(n));
return 0;
}
Find the fibonacci series with recursion.
#include<bits/stdc++.h>
using namespace std;
int fibo(int n)
{
if(n==0)
return 0;
else if (n==1)
return 1;
else
return fibo(n-1)+fibo(n-2);
}
int main()
{
 int n,i;
printf("Enter a number:");
scanf("%d",&n);
for(i=0;i<=n;i++)
{
printf("%d ",fibo(i));
}
return 0;
}

Prime number using recursion c++

/ CPP Program to find whether a Number
// is Prime or Not using Recursion
#include <bits/stdc++.h>
using namespace std;

// Returns true if n is prime, else

// return false.
// i is current divisor to check.
bool isPrime(int n, int i = 2)
{
// Base cases
if (n <= 2)
return (n == 2) ? true : false;
if (n % i == 0)
return false;
if (i * i > n)
return true;

// Check for next divisor

return isPrime(n, i + 1);
}

// Driver Program
int main()
{
int n = 15;
if (isPrime(n))
cout << "Yes";
else
cout << "No";

return 0;
}