What is Constructor
3 minute read
Constructor and Destructor
What is a
constructor? Is it compulsory to use constructors in a class? Or What is constructor? Explain with its syntax and examples. Also include its type.
Ø A constructor is
a ‘special’ member function whose task is to initialize the object of its
class.
Ø Name of
constructor is same as the name of its class.
Ø Constructor is
invoked whenever an object of its associated class is created.
Ø It constructs
the values of data members of the class so that it is called constructer.
Ø It is not
mandatory to use constructor in a class.
Ø A constructor is
declared and defined as follows:
class student
{
int mark1,
mark2;
public:
student (void); // constructor declared
:
: : : : : : :
};
student ::
student (void) // constructor defined
{
mark1 = 0;
mark2 = 0;
}
Ø There is no need
to write any statement to invoke the constructor, because it invokes
implicitly.
Ø A constructor
that has no argument is called the default constructor.
Ø A constructer
that has argument is called parameterized constructer.
Ø Copy constructer takes an object as argument,
and is used to copy values of data members of one object into other object.
Write the
characteristics of the constructor?
Ø It should be
declared in the public section.
Ø They are invoke
automatically when the objects are created.
Ø They do not have
return types, not even void and therefore, and they cannot return values.
Ø They cannot be
inherited, through a derived class can call the base class constructor.
Ø Like other C++
functions, constructor has default arguments.
Ø Constructors
cannot be virtual.
Ø We cannot refer
to their addresses.
Ø An object with a
constructor cannot be used as a member of a union.
Ø Constructor make ‘implicit calls’ to the operators new and delete when memory allocation is
required.
11) Explain copy
constructor and parameterized constructor.
(a) Copy constructor:
The constructor
that creates a new class object from an existing object of the same class is
called copy constructor.
Example:
class number
{
int n;
public:
number(){ }
number(int a){ n
= a; }
number(number
& x) // copy constructor
{
n = x.n; // copy in the value
}
};
int main()
{
number no1(10);
number no2(no1);
return 0;
}
(b)Parameterized constructor:
The constructor
that can take arguments are called parameterized constructor.
Example:
class number
{
int n;
public:
number(){}
number(int a){ n = a; } // parameterized constructor
};
int main()
{
number no1(10);
return 0;
}
12) What are the
features of a copy constructor?
Ø Copy constructor
is a special type of parameterized constructor.
Ø It copies one
object to another.
Ø It is invoked
for the object being created.
Ø The object of
the class is passed as the argument of parameter to it.
Ø Copy constructor
copies one object to other by its member-wise.
Ø If it does not
derived, then the compiler defines it for us.
Ø A reference
variable has been used as an argument.
13)
What is dynamic
constructor? Explain?
v
The
constructors can also be used to allocate memory while creating objects. This
will enable the system to allocate the right amount of memory for each object
when the objects are not of the same site.
v
Allocating
of memory to objects at the time of their construction is known as dynamic
construction of objects.
v
In
this, the memory is allocated with the help of new operator.
v
It
results in saving memory.
Example:
#include
<iostream.h>
#
include <string.h>
class
string
{
char
*name;
int
length;
public:
string
() // constructor-1
{
length = 0;
name = new char
[length+1];
}
string
(char * S) // constructor-2
{
length = strlen
(S);
name = new char
[length +1]; //one additional char for
NULL
strcpy(name, S);
}
void display(void)
{
cout <<
name << ”\n”;
}
};
int
main()
{
char
* first = “Joseph ”;
String
name1(first), name2(“Louis”);
String
name3(first+”Louis”);
name1.display();
name2.display();
name3.display();
return
0;
}
v
Output
of the above program :
Joseph
Louis
Joseph
Louis
14)
Explain
constructors with default arguments?
Ø It is possible
to define constructor with default arguments.
Ø In this if we do
not pass the argument to the constructor then parameter is assigned to default
argument.
Ø For example: the constructor
student () can be declared as follows:
o student (int
mark1, int mark2 = 0)
o { . . . . .
//constructor body }
Ø The default
value of the argument mark2 is zero (0). Then the statement
student s1(10);
assigns the
value 10 to the mark1 and 0 to the mark2, but in the statement
student s2(20,
30);
assigns the
value 20 to mark1 and 30 to mark2 and overrides the default value.
Ø The default
argument constructor can be called with either one argument or no arguments.