Constructors and destructors in C++ part 2

Constructors
A special member function having same
name as that of its class which is used to
initialize some valid values to the
member variables.

Key points while defining constructor
A constructor has same name as that of the class to
which it belongs.
 A constructor is executed automatically whenever
the object is created
A constructor doesn`t have a return type, not even
void
 We can declare more than one constructor in a class.
These constructor differ in there parameter list.
If you don’t provide a constructor of your own then
the compiler generates a default constructor
(expects no parameters and has an empty
body).
A constructor can preferably be used for
initialization and not for inputoutput operations.

• They can’t be inherited; through a derived class,
can call the base class constructor.
• Like other C++ functions, they can have default
arguments.
• Constructors can’t be virtual.
• Constructors can be inside the class definition or
outside the class definition.
• Constructor can’t be friend function.
• They can’t be used in union.

Contd..
• Constructor should be declared in the public section
of the class. If it is not declared in public section of
the class then the whole class become private . By
doing this the object of the class created from
outside cannot invoke the constructor which is the
first member function to be executed
automatically.

Syntax
class CLASSNAME
{
public:
CLASSNAME([parameter list]);
};

Example
#include<iostream.h>
#include<conio.h>
class Rectangle
{
private:
int length,breadth;
public:
Rectangle()
{
length=5,breadth=6;
}
void area()
{
int a=(length*breadth);
cout<<"area is"<<a;
}
};
void main()
{
clrscr();
Rectangle r1;
r1.area();
getch();
}

TYPES OF CONSTRUCTOR
• 1.Default Constructor
• 2.Parameterized Constructor
• 3.Copy Constructor

Parameterized Constructor
In order to initialize various data elements of
different objects with different values when they
are created. C++ permits us to achieve this objects
by passing argument to the constructor function
when the object are created . The constructor that
can take arguments are called parameterized
constructors

class abc
{
int m, n;
public:
abc (int x, int y); // parameterized constructor
................
.................
};
abc : : abc (int x, int y)
{
m = x;
n = y;
}

Parameterized constructor
#include<conio.h>
class Rectangle
{
private:
int length,breadth;
public:
Rectangle(int a,int b)
{
length=a;
breadth=b;
}
void area()
{
int a=(length*breadth);
cout<<"area is="<<a;
}
};
void main()
{
Rectangle r1(5,6);
Rectangle r2(7,8);
clrscr();
r1.area();cout<<endl;
r2.area();
getch();
}

Copy constructor
• A constructor is a constructor that creates a new
object using an existing object of the same class
• and initializes each data member of newly created
object with corresponding data member of existing
object passed as argumnt.
• since it creates a copy of an existing object so it is
called copy constructor.

Example
class counter
{
Int c;
public:
Counter(int a) //single parameter constructor
{
c=a;
}
counter(counter &ob) //copy constructor
{
cout<<“copy constructor invoked”;
c=ob.c;
}
}

void show()
{
cout<<c;
}
};
void main()
{
clrscr();
counter C1(10);
counter C2(C1);// call copy constructor
C1.show();
C2.show();
getch();
}

Another example of copy constructor
#include<iostream>
#include<conio.h>
using namespace std;
class Point
{
private:
int x, y;
public:
Point(int x1, int y1)
{
x = x1;
y = y1;
}

// Copy constructor
Point(const Point &p2)
{
x = p2.x;
y = p2.y;
}
int getX()
{
return x;
}
int getY()
{
return y;
}
};

int main()
{
Point p1(10, 15); // Normal constructor is called here
Point p2 = p1; // Copy constructor is called here
// Let us access values assigned by constructors
cout << "p1.x = " << p1.getX() << ", p1.y = " << p1.getY();
cout << "np2.x = " << p2.getX() << ", p2.y = " << p2.getY();
return 0;
}

class code
{
int id;
public:
code() { }
code(int a)
{
id = a;
}
code (code & x)
{
id = x. id;
}
void display()
{ cout<<id;
} };
int main()
{
code A(100);
code B(A);
code C = A;
code D;
D = A;
A.display();
B.display();
C.display();
D.display();
getch();
return 0;
}

Destructors
Is a member function having same name
as that of constructor but it is preceded
by a tilde(~) symbol and is executed
automatically when object of a class is
destroyed

Key points while defining destructor
• A destructor has same name as that of the class to which it belongs
preceded by tilde(~)sign.
• A destructor is executed automatically whenever the object is destroyed.
• A destructor doesn`t have a return type, not even void and no arguments
• There is only one destructor in class .
• If you don’t provide a destructor of your own then the compiler generates a
default destructor
• A destructor can be used to deallocate memory for an object and declared
in the public section.

Need for Destructors
• To de-initialize the objects when they are destroyed
• To clear memory space occupied by a data
member.

syntax
class CLASSNAME
{
……………….
public:
~CLASSNAME([parameter list]);
};

Note
• Execute the program in Turbo c++.
• To see the output, press Alt+F5

Program on destructor
Class sample
{
Public:
Sample
{
Cout<<“object born”<<endl;
}

Public:
{
~sample
{
Cout<<object dies<<endl;
}
};

int main()
{
sample s;
Cout<<“main terminated”<<endl;
getch();
return 0;
}

Example
#include<conio.h>
class counter
{
int id;
public:
counter(int i)
{
id=i;
cout<<“contructor of object with id=”<<id;

~counter()
{
cout<<“destructor with id=”<<id;
}
};
void main()
{
counter c1(1);
counter c2(2);
counter c3(3);
cout<<“n end of main”;
getch();
}

• Output
constructor of object with id=1
End of main
destructor with id=3
Note ::Destructor Always deallocate memory in reverse order.

1 Statically allocated object for class A in C++ is
A *obj = new A();
A obj;
A obj = new A();
None

When you create an object of a class A like A obj ;
then which one will be called automatically
A Constructor
B Destructor
C Copy constructor
D Assignment operator

3 Data members and member functions of a class in
C++ program are by default
protected
public
private
None

4 Which operator is used to allocate an object
dynamically of a class in C++?
Scope resolution operator
Conditional operator
New operator
Membership access

The static member functions __________________
a) Have access to all the members of a class
b) Have access to only constant members of a class
c.) Have access to only the static members of a class
d) Have direct access to all other class members also

The static member functions ____________________
a.) Can be called using class name
b) Can be called using program name
c) Can be called directly
d) Can’t be called outside the function

Which among the following is true?
a) Static member functions can be overloaded
b.) Static member functions can’t be overloaded
c) Static member functions can be overloaded using
derived classes
d) Static member functions are implicitly overloaded

Which keyword should be used to declare the static
member functions?
a.) static
b) stat
c) const
d) common

Assume class TEST. Which of the following statements
is/are responsible to invoke copy constructor?
a. TEST T2(T1)
b. TEST T4 = T1
c. T2 = T1
D). both a and b

Which of the following statements are not true about
destructor?
1. It is invoked when object goes out of the scope
2. Like constructor, it can also have parameters
3. It can be virtual
4. It can be declared in private section
5. It bears same name as that of the class and precedes Lambda
sign.
a. Only 2, 3, 5
b. Only 2, 3, 4
c). Only 2, 4, 5
d. Only 3, 4, 5

A Constructor that does not have any parameters is
called____________ Constructor.
a. Custom
b. Dynamic
c. Static
d). Default

Which of the followings are true about constructors?
1. A class can have more than one constructor.
2. They can be inherited.
3. Their address can be referred.
4. Constructors cannot be declared in protected section of the class.
5. Constructors cannot return values.
a. Only 1,2,4
b. 1,2,4,5
c. 1,3,5
d.) 1,4,5

In a program, If there exists a function template with
two parameters and normal function say void add(int
, int), so add(3,4) will _____________________ .
a. Invoke function template body as it is generic one
b.) Invokes normal function as it exactly matches
with its prototype
c. Not be called and Compiler issues warning
d. Not be called and Compiler issues ambiguity in
calling add()

Constructors and destructors in C++ part 2

Recommended

More Related Content

What's hot (20)

Similar to Constructors and destructors in C++ part 2 (20)

More from Lovely Professional University (20)

Recently uploaded (20)

Constructors and destructors in C++ part 2