C++ Constructor
In C++, constructor is a special method which is invoked automatically at the time of
object creation. It is used to initialize the data members of new object generally. The
constructor in C++ has the same name as class or structure.
In brief, A particular procedure called a constructor is called automatically when an object
is created in C++. In general, it is employed to create the data members of new things. In
C++, the class or structure name also serves as the constructor name. When an object is
completed, the constructor is called. Because it creates the values or gives data for the
thing, it is known as a constructor.
Constructors lack a return type since they don't have a return value.
There can be two types of constructors in C++.
o Default constructor
o Parameterized constructor
C++ Default Constructor
A constructor which has no argument is known as default constructor. It is invoked at the
time of creating object.
Let's see the simple example of C++ default Constructor.
1. #include <iostream>
2. using namespace std;
3. class Employee
4. {
5. public:
6. Employee()
7. {
8. cout<<"Default Constructor Invoked"<<endl;
9. }
10. };
11. int main(void)
12. {
13. Employee e1; //creating an object of Employee
14. Employee e2;
15. return 0;
16. }
Output:
Default Constructor Invoked
Default Constructor Invoked
C++ Parameterized Constructor
A constructor which has parameters is called parameterized constructor. It is used to
provide different values to distinct objects.
Let's see the simple example of C++ Parameterized Constructor.
1. #include <iostream>
2. using namespace std;
3. class Employee {
4. public:
5. int id;//data member (also instance variable)
6. string name;//data member(also instance variable)
7. float salary;
8. Employee(int i, string n, float s)
9. {
10. id = i;
11. name = n;
12. salary = s;
13. }
14. void display()
15. {
16. cout<<id<<" "<<name<<" "<<salary<<endl;
17. }
18. };
19.
20. int main(void) {
21. Employee e1 =Employee(101, "Sonoo", 890000); //creating an object of Employee
22. Employee e2=Employee(102, "Nakul", 59000);
23. e1.display();
24. e2.display();
25. return 0;
26. }
Output:
101 Sonoo 890000
102 Nakul 59000
What distinguishes constructors from a typical member
function?
1. Constructor's name is the same as the class's
2. Default There isn't an input argument for constructors. However, input arguments
are available for copy and parameterized constructors.
3. There is no return type for constructors.
4. An object's constructor is invoked automatically upon creation.
5. It must be shown in the classroom's open area.
6. The C++ compiler creates a default constructor for the object if a constructor is
not specified (expects any parameters and has an empty body).
What are the characteristics of a constructor?
1. The constructor has the same name as the class it belongs to.
2. Although it is possible, constructors are typically declared in the class's public
section. However, this is not a must.
3. Because constructors don't return values, they lack a return type.
4. When we create a class object, the constructor is immediately invoked.
5. Overloaded constructors are possible.
6. Declaring a constructor virtual is not permitted.
7. One cannot inherit a constructor.
8. Constructor addresses cannot be referenced to.
9. When allocating memory, the constructor makes implicit calls to the new and
delete operators.
What is a copy constructor?
A member function known as a copy constructor initializes an item using another object
from the same class-an in-depth discussion on Copy Constructors.
Every time we specify one or more non-default constructors (with parameters) for a class,
we also need to include a default constructor (without parameters), as the compiler won't
supply one in this circumstance. The best practice is to always declare a default
constructor, even though it is not required.
A reference to an object belonging to the same class is required by the copy constructor.
1. Sample(Sample &t)
2. {
3. id=t.id;
4. }
What is a destructor in C++?
An equivalent special member function to a constructor is a destructor. The constructor
creates class objects, which are destroyed by the destructor. The word "destructor,"
followed by the tilde () symbol, is the same as the class name. You can only define one
destructor at a time. One method of destroying an object made by a constructor is to use
a destructor. Destructors cannot be overloaded as a result. Destructors don't take any
arguments and don't give anything back. As soon as the item leaves the scope, it is
immediately called. Destructors free up the memory used by the objects the constructor
generated. Destructor reverses the process of creating things by destroying them.
The language used to define the class's destructor
1. ~ <class-name>()
2. {
3. }
The language used to define the class's destructor outside of it
1. <class-name>: : ~ <class-name>(){}
C++ Destructor
A destructor works opposite to constructor; it destructs the objects of classes. It can be
defined only once in a class. Like constructors, it is invoked automatically.
A destructor is defined like constructor. It must have same name as class. But it is prefixed
with a tilde sign (~).
C++ Constructor and Destructor Example
Let's see an example of constructor and destructor in C++ which is called automatically.
1. #include <iostream>
2. using namespace std;
3. class Employee
4. {
5. public:
6. Employee()
7. {
8. cout<<"Constructor Invoked"<<endl;
9. }
10. ~Employee()
11. {
12. cout<<"Destructor Invoked"<<endl;
13. }
14. };
15. int main(void)
16. {
17. Employee e1; //creating an object of Employee
18. Employee e2; //creating an object of Employee
19. return 0;
20. }
Output:
Constructor Invoked
Constructor Invoked
Destructor Invoked
Destructor Invoked
C++ Polymorphism
The term "Polymorphism" is the combination of "poly" + "morphs" which means many
forms. It is a greek word. In object-oriented programming, we use 3 main concepts:
inheritance, encapsulation, and polymorphism.
Real Life Example Of Polymorphism
Let's consider a real-life example of polymorphism. A lady behaves like a teacher in a
classroom, mother or daughter in a home and customer in a market. Here, a single person
is behaving differently according to the situations.
There are two types of polymorphism in C++:
o Compile time polymorphism: The overloaded functions are invoked by matching
the type and number of arguments. This information is available at the compile
time and, therefore, compiler selects the appropriate function at the compile time.
It is achieved by function overloading and operator overloading which is also
known as static binding or early binding. Now, let's consider the case where
function name and prototype is same.
1. class A // base class declaration.
2. {
3. int a;
4. public:
5. void display()
6. {
7. cout<< "Class A ";
8. }
9. };
10. class B : public A // derived class declaration.
11. {
12. int b;
13. public:
14. void display()
15. {
16. cout<<"Class B";
17. }
18. };
In the above case, the prototype of display() function is the same in both the base and
derived class. Therefore, the static binding cannot be applied. It would be great if the
appropriate function is selected at the run time. This is known as run time
polymorphism.
o Run time polymorphism: Run time polymorphism is achieved when the object's
method is invoked at the run time instead of compile time. It is achieved by method
overriding which is also known as dynamic binding or late binding.
Differences b/w compile time and run time
polymorphism.
Compile time polymorphism Run time polymorphism
The function to be invoked is known at the The function to be invoked is known at the
compile time. run time.
It is also known as overloading, early binding It is also known as overriding, Dynamic
and static binding. binding and late binding.
Overloading is a compile time polymorphism Overriding is a run time polymorphism
where more than one method is having the where more than one method is having
same name but with the different number of the same name, number of parameters
parameters or the type of the parameters. and the type of the parameters.
It is achieved by function overloading and It is achieved by virtual functions and
operator overloading. pointers.
It provides fast execution as it is known at the It provides slow execution as it is known at
compile time. the run time.
It is less flexible as mainly all the things execute It is more flexible as all the things execute
at the compile time. at the run time.
C++ Runtime Polymorphism Example
// an example without the virtual keyword.
1. #include <iostream>
2. using namespace std;
3. class Animal {
4. public:
5. void eat(){
6. cout<<"Eating...";
7. }
8. };
9. class Dog: public Animal
10. {
11. public:
12. void eat()
13. { cout<<"Eating bread...";
14. }
15. };
16. int main(void) {
17. Dog d = Dog();
18. d.eat();
19. return 0;
20. }
Output:
Eating bread...
C++ Run time Polymorphism Example: By using two
derived class
Let's see another example of run time polymorphism in C++ where we are having two
derived classes.
// an example with virtual keyword.
1. #include <iostream>
2. using namespace std;
3. class Shape { // base class
4. public:
5. virtual void draw(){ // virtual function
6. cout<<"drawing..."<<endl;
7. }
8. };
9. class Rectangle: public Shape // inheriting Shape class.
10. {
11. public:
12. void draw()
13. {
14. cout<<"drawing rectangle..."<<endl;
15. }
16. };
17. class Circle: public Shape // inheriting Shape class.
18.
19. {
20. public:
21. void draw()
22. {
23. cout<<"drawing circle..."<<endl;
24. }
25. };
26. int main(void) {
27. Shape *s; // base class pointer.
28. Shape sh; // base class object.
29. Rectangle rec;
30. Circle cir;
31. s=&sh;
32. s->draw();
33. s=&rec;
34. s->draw();
35. s=?
36. s->draw();
37. }
Output:
drawing...
drawing rectangle...
drawing circle...
Runtime Polymorphism with Data Members
Runtime Polymorphism can be achieved by data members in C++. Let's see an example
where we are accessing the field by reference variable which refers to the instance of
derived class.
1. #include <iostream>
2. using namespace std;
3. class Animal { // base class declaration.
4. public:
5. string color = "Black";
6. };
7. class Dog: public Animal // inheriting Animal class.
8. {
9. public:
10. string color = "Grey";
11. };
12. int main(void) {
13. Animal d= Dog();
14. cout<<d.color;
15. }
Output:
Black
C++ Overloading (Function and Operator)
If we create two or more members having the same name but different in number or type
of parameter, it is known as C++ overloading. In C++, we can overload:
o methods,
o constructors, and
o indexed properties
It is because these members have parameters only.
Types of overloading in C++ are:
o Function overloading
o Operator overloading
C++ Function Overloading
Function Overloading is defined as the process of having two or more function with the
same name, but different in parameters is known as function overloading in C++. In
function overloading, the function is redefined by using either different types of
arguments or a different number of arguments. It is only through these differences
compiler can differentiate between the functions.
The advantage of Function overloading is that it increases the readability of the program
because you don't need to use different names for the same action.
C++ Function Overloading Example
Let's see the simple example of function overloading where we are changing number of
arguments of add() method.
// program of function overloading when number of arguments vary.
1. #include <iostream>
2. using namespace std;
3. class Cal {
4. public:
5. static int add(int a,int b){
6. return a + b;
7. }
8. static int add(int a, int b, int c)
9. {
10. return a + b + c;
11. }
12. };
13. int main(void) {
14. Cal C; // class object declaration.
15. cout<<C.add(10, 20)<<endl;
16. cout<<C.add(12, 20, 23);
17. return 0;
18. }
Output:
30
55
Let's see the simple example when the type of the arguments vary.
// Program of function overloading with different types of arguments.
1. #include<iostream>
2. using namespace std;
3. int mul(int,int);
4. float mul(float,int);
5.
6.
7. int mul(int a,int b)
8. {
9. return a*b;
10. }
11. float mul(double x, int y)
12. {
13. return x*y;
14. }
15. int main()
16. {
17. int r1 = mul(6,7);
18. float r2 = mul(0.2,3);
19. std::cout << "r1 is : " <<r1<< std::endl;
20. std::cout <<"r2 is : " <<r2<< std::endl;
21. return 0;
22. }
Output:
r1 is : 42
r2 is : 0.6
Function Overloading and Ambiguity
When the compiler is unable to decide which function is to be invoked among the
overloaded function, this situation is known as function overloading.
When the compiler shows the ambiguity error, the compiler does not run the program.
Causes of Function Overloading:
o Type Conversion.
o Function with default arguments.
o Function with pass by reference.
o Type Conversion:
1. #include<iostream>
2. using namespace std;
3. void fun(int);
4. void fun(float);
5. void fun(int i)
6. {
7. std::cout << "Value of i is : " <<i<< std::endl;
8. }
9. void fun(float j)
10. {
11. std::cout << "Value of j is : " <<j<< std::endl;
12. }
13. int main()
14. {
15. fun(12);
16. fun(1.2);
17. return 0;
18. }
The above example shows an error "call of overloaded 'fun(double)' is ambiguous".
The fun(10) will call the first function. The fun(1.2) calls the second function according to
our prediction. But, this does not refer to any function as in C++, all the floating point
constants are treated as double not as a float. If we replace float to double, the program
works. Therefore, this is a type conversion from float to double.
o Function with Default Arguments
1. #include<iostream>
2. using namespace std;
3. void fun(int);
4. void fun(int,int);
5. void fun(int i)
6. {
7. std::cout << "Value of i is : " <<i<< std::endl;
8. }
9. void fun(int a,int b=9)
10. {
11. std::cout << "Value of a is : " <<a<< std::endl;
12. std::cout << "Value of b is : " <<b<< std::endl;
13. }
14. int main()
15. {
16. fun(12);
17.
18. return 0;
19. }
The above example shows an error "call of overloaded 'fun(int)' is ambiguous". The fun(int
a, int b=9) can be called in two ways: first is by calling the function with one argument,
i.e., fun(12) and another way is calling the function with two arguments, i.e., fun(4,5). The
fun(int i) function is invoked with one argument. Therefore, the compiler could not be
able to select among fun(int i) and fun(int a,int b=9).
o Function with pass by reference
Let's see a simple example.
1. #include <iostream>
2. using namespace std;
3. void fun(int);
4. void fun(int &);
5. int main()
6. {
7. int a=10;
8. fun(a); // error, which f()?
9. return 0;
10. }
11. void fun(int x)
12. {
13. std::cout << "Value of x is : " <<x<< std::endl;
14. }
15. void fun(int &b)
16. {
17. std::cout << "Value of b is : " <<b<< std::endl;
18. }
The above example shows an error "call of overloaded 'fun(int&)' is ambiguous". The
first function takes one integer argument and the second function takes a reference
parameter as an argument. In this case, the compiler does not know which function is
needed by the user as there is no syntactical difference between the fun(int) and fun(int
&).
C++ Operators Overloading
Operator overloading is a compile-time polymorphism in which the operator is
overloaded to provide the special meaning to the user-defined data type. Operator
overloading is used to overload or redefines most of the operators available in C++. It is
used to perform the operation on the user-defined data type. For example, C++ provides
the ability to add the variables of the user-defined data type that is applied to the built-
in data types.
The advantage of Operators overloading is to perform different operations on the same
operand.
Operator that cannot be overloaded are as follows:
o Scope operator (::)
o Sizeof
o member selector(.)
o member pointer selector(*)
o ternary operator(?:)
Syntax of Operator Overloading
1. return_type class_name : : operator op(argument_list)
2. {
3. // body of the function.
4. }
Where the return type is the type of value returned by the function.
class_name is the name of the class.
operator op is an operator function where op is the operator being overloaded, and the
operator is the keyword.
Rules for Operator Overloading
o Existing operators can only be overloaded, but the new operators cannot be
overloaded.
o The overloaded operator contains atleast one operand of the user-defined data
type.
o We cannot use friend function to overload certain operators. However, the member
function can be used to overload those operators.
o When unary operators are overloaded through a member function take no explicit
arguments, but, if they are overloaded by a friend function, takes one argument.
o When binary operators are overloaded through a member function takes one
explicit argument, and if they are overloaded through a friend function takes two
explicit arguments.
C++ Operators Overloading Example
Let's see the simple example of operator overloading in C++. In this example, void
operator ++ () operator function is defined (inside Test class).
// program to overload the unary operator ++.
1. #include <iostream>
2. using namespace std;
3. class Test
4. {
5. private:
6. int num;
7. public:
8. Test(): num(8){}
9. void operator ++() {
10. num = num+2;
11. }
12. void Print() {
13. cout<<"The Count is: "<<num;
14. }
15. };
16. int main()
17. {
18. Test tt;
19. ++tt; // calling of a function "void operator ++()"
20. tt.Print();
21. return 0;
22. }
Output:
The Count is: 10
Let's see a simple example of overloading the binary operators.
// program to overload the binary operators.
1. #include <iostream>
2. using namespace std;
3. class A
4. {
5.
6. int x;
7. public:
8. A(){}
9. A(int i)
10. {
11. x=i;
12. }
13. void operator+(A);
14. void display();
15. };
16.
17. void A :: operator+(A a)
18. {
19.
20. int m = x+a.x;
21. cout<<"The result of the addition of two objects is : "<<m;
22.
23. }
24. int main()
25. {
26. A a1(5);
27. A a2(4);
28. a1+a2;
29. return 0;
30. }
Output:
The result of the addition of two objects is : 9
