CONSTRUCTORS AND DESTRUCTORS

Transcription

1 UNIT-II CONSTRUCTORS AND DESTRUCTORS Contents: Constructors Default constructors Parameterized constructors Constructor with dynamic allocation Copy constructor Destructors Operator overloading Overloading through friend function Overloading the assignment operator Type conversion Explicit constructor Constructors: What is the use of Constructor? The main use of constructors is to initialize objects. The function of initialization is automatically carried out by the use of a special member function called a constructor. Constructor: Constructor is a special member function. This is used to give initial values to member variables. The general form is: Rules: constructor_name(parameters) statements to give initial values to member variables It should be declared as public. No return type needed. When the object is declared for the class, it automatically executes the constructor and initialized the variables. There are two types of constructors. They are: 1. Constructor without parameters 2. Constructor with parameters (or) parameterized constructor

2 1. Constructor without parameters OR Default Constructor: This constructor has no arguments in it. Default Constructor is also called as no argument constructor. For example: class Exforsys private: int a,b; public: Exforsys();... ; Exforsys :: Exforsys() a=0; b=0; 2. Constructor with parameters OR Parameterized constructor: Constructor can be invoked with arguments. The arguments list can be specified within braces similar to arguments-list in the function constructors with arguments are called parameterized constructors. We must pass the initial values as arguments to the constructor function when object is declared. The general form is: Classname object( argument_list ); (or) Classname object = classname(argument_value_list);

3 This can be done in two ways: 1. By calling the constructor explicitly. 2. By calling the constructor implicitly. For Example: class sample int a,b; public: sample(int x,int y); ; sample::sample(int x,int y) a=x; b=y; Example: smaple S=sample(2,3);//explicit call; sample S(2,3);//implicit call; //parameterized constructors #include<iostream.h> class sample int a,b; public: sample(int,int);//constructor decalred void display()

4 count<< a= <<a<<end/; count<< b= <<b<<end/; ; sample::sample(int x,int y) a=x; b=y; main() sample S(2,3);//implicit call sample S2=sample(4,5);//explicit call S1.display(); S2.display(); Output: a a =2 b = 3 a = 4 b = 5 Constructor with dynamic allocation: The constructors can also be used to allocate memory while creating objects. This will enable the system to allocate the right amount for each object when the objects are not of the same size, thus resulting in the saving of memory. Allocation of memory to objects at the time of their construction is known as dynamic construction of objects. //Constructors with new #include<iostream.h>

5 class vector int * v; // pointer to vector int sz; // Size of a vector public: vector(int size) sz=size; v=new int[size]; ~vector() delete v; //release vector memory void read() for(int i=0;i<sz;i++) cin>>v[i]; void show_sum() int sum=0; for(int i=0;i<sz;i++) Sum+=v[i]; cout<<sum; ; void main() int count; cout<< How many elements are in the vector ; cin>>count;

6 vector v1(count); v1.read(); v1.show_sum(); Copy constructor: This constructor takes one argument. Also called one argument constructor. The main use of copy constructor is to initialize the objects while in creation, also used to copy an object. The copy constructor allows the programmer to create a new object from an existing one by initialization. For example to invoke a copy constructor the programmer writes: Exforsys e3(e2); or Exforsys e3=e2; Both the above formats can be sued to invoke a copy constructor. For Example: #include <iostream.h> class Exforsys() private: int a; public: Exforsys() Exforsys(int w) a=w;

7 Exforsys(Exforsys& e) a=e.a; cout<< Example of Copy Constructor ; void result() cout<< a; ; void main() Exforsys e1(50); Exforsys e3(e1); cout<< \ne3= ;e3.result(); the above the copy constructor takes one argument an object of type Exforsys which is passed by reference. The output of the above program is Example of Copy Constructor: e3=50 Some important points about constructors: A constructor takes the same name as the class name. The programmer cannot declare a constructor as virtual or static, nor can the programmer declare a constructor as const, volatile, or const volatile. No return type is specified for a constructor. The constructor must be defined in the public. The constructor must be a public member.

8 Overloading of constructors is possible. This will be explained in later sections of this tutorial. Multiple Constructor (or) Constructor Overloading: If a class has more than one constructor, then it is called multiple constructors. This technique is called overloading constructors, because all constructors have the same name and they differ only in the number of arguments or data types. Example: #include<iostream.h> #include<conio.h> class con int c; public: con(); con(int x); con(int x,int y); con(int x,int y,int z); ; con ::con() c=0; cout<<"\n\n\t Result is :\t"<<c; con ::con(int x) c=x*x; cout<<"\n\n\t Result is :\t"<<c; con::con(int x,int y) c=x*y; cout<<"\n\n\t Result is :\t"<<c;

9 con ::con(int x,int y,int z) c=x*y*z; cout<<"\n\n\t Result is :\t"<<c; void main() clrscr(); cout<<"\n\n\t OUTPUT:\n"; con c; con s(3); con s1(3,5); con s2(3,2,2); getch(); Constructor with default arguments: If we give initial values to the member variables inside the argument list of constructor then it is called constructor with default arguments. The general form is: constructor_name (return_type variable1= value1, return_type variable2= value2,. return_type variable n= value n member_variable1 = variable1; member_variable2 = variable2.. member_variable n = variable n;

10 At the time of object declaration, depending upon the value, the constructor automatically assign the values to member variables. If any value is missing this will be taken from the argument list values. Example: #include <iostream> #include <iostream.h> #include <conio.h> class myclass int a,b; public: myclass(int x, int y); // constructor ~myclass(); // destructor void show(); ; myclass::myclass(int x = 30, int y = 40) cout << "In constructor\n"; a = x; b = y; void myclass::show() cout << "A =" << a << endl << "B =" << b << endl; cout << "Sum is " << a+b << endl; void main() clrscr(); myclass ob1(10,20); myclass ob2(5); ob1.show(); ob2.show();

11 Output: A = 10 B = 20 Sum is 30 A = 5 B = 40 Sum is 45 Destructors: Destructors are usually used to deallocate memory and do other cleanup for a class object and its class members when the object is destroyed. A destructor is called for a class object when that object passes out of scope or is explicitly deleted. A destructor is a member function with the same name as its class prefixed by a ~ (tilde). For example: class X public: // Constructor for class X X(); // Destructor for class X ~X(); ; A destructor takes no arguments and has no return type. Its address cannot be taken. Destructors cannot be declared const, volatile, const volatile or static. A destructor can be declared virtual or pure virtual.

12 If no user-defined destructor exists for a class and one is needed, the compiler implicitly declares a destructor. This implicitly declared destructor is an inline public member of its class. The compiler will implicitly define an implicitly declared destructor when the compiler uses the destructor to destroy an object of the destructor's class type. Suppose a class A has an implicitly declared destructor. The following is equivalent to the function the compiler would implicitly define for A: A::~A() The compiler first implicitly defines the implicitly declared destructors of the base classes and nonstatic data members of a class A before defining the implicitly declared destructor of A A destructor of a class A is trivial if all the following are true: It is implicitly defined All the direct base classes of A have trivial destructors The classes of all the nonstatic data members of A have trivial destructors If any of the above are false, then the destructor is nontrivial. A union member cannot be of a class type that has a nontrivial destructor. Class members that are class types can have their own destructors. Both base and derived classes can have destructors, although destructors are not inherited. If a base class A or a member of A has a destructor, and a class derived from A does not declare a destructor, a default destructor is generated. The default destructor calls the destructors of the base class and members of the derived class. The destructors of base classes and members are called in the reverse order of the completion of their constructor:

13 1. The destructor for a class object is called before destructors for members and bases are called. 2. Destructors for nonstatic members are called before destructors for base classes are called. 3. Destructors for nonvirtual base classes are called before destructors for virtual base classes are called. When an exception is thrown for a class object with a destructor, the destructor for the temporary object thrown is not called until control passes out of the catch block. Destructors are implicitly called when an automatic object (a local object that has been declared auto or register, or not declared as static or extern) or temporary object passes out of scope. They are implicitly called at program termination for constructed external and static objects. Destructors are invoked when you use the delete operator for objects created with the new operator. For example: #include <string> class Y private: char * string; int number; public: // Constructor Y(const char*, int); // Destructor ~Y() delete[] string; ;

14 // Define class Y constructor Y::Y(const char* n, int a) string = strcpy(new char[strlen(n) + 1 ], n); number = a; int main () // Create and initialize // object of class Y Y yobj = Y("somestring", 10); //... // Destructor ~Y is called before // control returns from main() Operator Overloading: An operator function defines the operations that the overloaded operator will perform relative to the class upon which it will work. An operator function is created using the keyword operator. The operator overloading feature of C++ is one of the methods of realizing polymorphism. C++ has the ability to provide the operators with a special meaning to an operator is known as operator overloading. We can overload all the C++ operators except the following: Scope resolution operator(::) Size of operator(size of) Conditional operator(?:) Class member access operator(.,.*, *) Pointer to member declarator(::*)

15 Broadly classifying operators are of two types namely: Unary Operators Binary Operators Unary Operators: As the name implies takes operate on only one operand. Some unary operators are namely ++ called as Increment operator, -- called as Decrement Operator,!, ~, unary minus. Binary Operators: The arithmetic operators, comparison operators, and arithmetic assignment operators all this which we have seen in previous section of operators come under this category. Both the above classification of operators can be overloaded. So let us see in detail each of this. Operator Overloading Unary operators As said before operator overloading helps the programmer to define a new functionality for the existing operator. This is done by using the keyword operator. The general syntax for defining an operator overloading is as follows: return_type classname :: operator operator symbol(argument).. statements;

16 Thus the above clearly specifies that operator overloading is defined as a member function by making use of the keyword operator. In the above: return_type is the data type returned by the function class name - is the name of the class operator is the keyword operator symbol is the symbol of the operator which is being overloaded or defined for new functionality :: - is the scope resolution operator which is used to use the function definition outside the class. The usage of this is clearly defined in our earlier section of How to define class members. For example : Suppose we have a class say Exforsys and if the programmer wants to define a operator overloading for unary operator say ++, the function is defined as Inside the class Exforsys the data type that is returned by the overloaded operator is defined as

17 class Exforsys private:. public: void operator ++( ); ; So the important steps involved in defining an operator overloading in case of unary operators are namely: Inside the class the operator overloaded member function is defined with the return data type as member function or a friend function. The concept of friend function we will define in later sections. If in this case of unary operator overloading if the function is a member function then the number of arguments taken by the operator member function is none as seen in the below example. In case if the function defined for the operator overloading is a friend function which we will discuss in later section then it takes one argument. The operator overloading is defined as member function outside the class using the scope resolution operator with the keyword operator as explained above Now let us see how to use this overloaded operator member function in the program #include <iostream.h> class Exforsys private: int x; public: Exforsys( ) x=0; void display(); //Constructor

18 ; void Exforsys ++( ); void Exforsys :: display() cout<< \nvalue of x is: << x; void Exforsys :: operator ++( ) //Operator Overloading for operator ++ defined ++x; void main( ) Exforsys e1,e2; //Object e1 and e2 created cout<< Before Increment cout << \nobject e1: <<e1.display(); cout << \nobject e2: <<e2.display(); ++e1; //Operator overloading applied ++e2; cout<< \n After Increment cout << \nobject e1: <<e1.display(); cout << \nobject e2: <<e2.display(); The output of the above program is: Before Increment Object e1: Value of x is: 0 Object e1: Value of x is: 0 Before Increment

19 Object e1: Value of x is: 1 Object e1: Value of x is: 1 In the above example we have created 2 objects e1 and e2 f class Exforsys. The operator ++ is overloaded and the function is defined outside the class Exforsys. Operator Overloading Binary Operators : Binary operators, when overloaded, are given new functionality. The function defined for binary operator overloading, as with unary operator overloading, can be member function or friend function. The difference is in the number of arguments used by the function. In the case of binary operator overloading, when the function is a member function then the number of arguments used by the operator member function is one (see below example). When the function defined for the binary operator overloading is a friend function, then it uses two arguments. Binary operator overloading, as in unary operator overloading, is performed using a keyword operator. Binary operator overloading example: #include <iostream.h> class Exforsys private: int x; int y; public: Exforsys() //Constructor x=0; y=0;

20 void getvalue( ) //Member Function for Inputting Values cout << \n Enter value for x: ; cin >> x; cout << \n Enter value for y: ; cin>> y; void displayvalue( ) //Member Function for Outputting Values cout << value of x is: << x << ; value of y is: <<y Exforsys operator +(Exforsys); ; Exforsys Exforsys :: operator + (Exforsys e2) //Binary operator overloading for + operator defined int x1 = x+ e2.x; int y1 = y+e2.y; return Exforsys(x1,y1); void main( ) Exforsys e1,e2,e3; //Objects e1, e2, e3 created cout<<\n Enter value for Object e1: ; e1.getvalue( ); cout<<\n Enter value for Object e2: ; e2.getvalue( ); e3= e1+ e2; //Binary Overloaded operator used

21 cout<< \nvalue of e1 is: <<e1.displayvalue(); cout<< \nvalue of e2 is: <<e2.displayvalue(); cout<< \nvalue of e3 is: <<e3.displayvalue(); The output of the above program is: Enter value for Object e1: Enter value for x: 10 Enter value for y: 20 Enter value for Object e2: Enter value for x: 30 Enter value for y: 40 Value of e1 is: value of x is: 10; value of y is: 20 Value of e2 is: value of x is: 30; value of y is: 40 Value of e3 is: value of x is: 40; value of y is: 60 In the above example, the class Exforsys has created three objects e1, e2, e3. The values are entered for objects e1 and e2. The binary operator overloading for the operator + is declared as a member function inside the class Exforsys. The definition is performed outside the class Exforsys by using the scope resolution operator and the keyword operator. The important aspect is the statement: e3= e1 + e2; The binary overloaded operator + is used. In this statement, the argument on the left side of the operator +, e1, is the object of the class Exforsys in which the binary overloaded operator + is a member function. The right side of the operator + is e2. This is passed as an argument to the operator +. Since the object e2 is passed as argument to the operator + inside the function defined for binary operator overloading, the values are accessed as e2.x and e2.y. This is added with e1.x and e1.y, which are accessed

22 directly as x and y. The return value is of type class Exforsys as defined by the above example. There are important things to consider in operator overloading with C++ programming language. Operator overloading adds new functionality to its existing operators. The programmer must add proper comments concerning the new functionality of the overloaded operator. The program will be efficient and readable only if operator overloading is used only when necessary. Operator Overloading Using a Friend Function: The only difference between a friend function and member function is that, the friend function requires the arguments to be explicitly passed to the function and processes them explicitly, whereas the member function considers the first argument implicitly. Friend function can either be used with unary function is as follows: Friend return_type operator operator_symbol(arg1[,arg2]) // body of operator friend function Friend function is not allowed to access members of a class directly, but it can access all the members including the private members by using objects of that class. //unary operator overloading using friend function #include<iostream.h> class complex float real,imag; public:

23 complex() real=imag=0.0; void read data() cout<< Real part? ; cin>>real; cout<< Imag part? ; cin>>imag; void Putdata() cout<< ( <<real; cout<<, <<imag<< ) ; //overloading unary operator overloading friend complex operator-(complex C1) complex C; C.real=-C1.real; C.imag=-C1.imag; return(c); ; void main() complex C1,C2; cout<< Enter Complex C1 //<<end/;

24 C1.readdata(); C2=-C1; C2.Putdata(); Output: Enter Complex C1 Rear Part? 1.5 Imag Part? 1.5 (-1.5,2.5) //Addition of two complex number using friend function #include<iostream.h> class complex float real,imag; public: complex() complex(int realpart) real=realpart; void readata() cout<< Real Part? ; cin>>real; cout<< Imag Part? ; cin>>imag; void putdata() cout<< ( <<real;

25 ; cout<<, <<imag<< ) ; friend complex operator+(complex C1,complex C2) complex operator+(complex C1,complex C2) complex C; C.real=C1.real+C2.real; C.imag=C1.imag+C2.imag; return(c); void main() Complex C1,C2,C3=3.0; Cout<< Enter Complex C1 <<end/; C1.readdata(); Cout<< Enter Complex C2 <<end/; C2.readdata(); C3=C1+C2; C3.putdata(); C3=C1+2.0; C3.putdata(); C3=3.0+C2; C3.putdata(); Output: Enter Complex C1 Real Part? 1 Imag Part? 2 Enter Complex C2

26 Real Part? 3 Imag Part? 4 (4,6) (3,2) (6,4) Using a Friend to Overload ++ or : If we want to use a friend function to overload the increment or decrement operators, you must pass the operand as a reference parameter. This is because friend functions do not have this pointers. #include <iostream> using namespace std; class loc int longitude, latitude; public: loc() loc(int lg, int lt) longitude = lg; latitude = lt; void show() cout << longitude << " "; cout << latitude << "\n"; loc operator=(loc op2); friend loc operator++(loc &op); friend loc operator--(loc &op); ;

27 // Overload assignment for loc. loc loc::operator=(loc op2) longitude = op2.longitude; latitude = op2.latitude; return *this; // i.e., return object that generated call // Now a friend; use a reference parameter. loc operator++(loc &op) op.longitude++; op.latitude++; return op; // Make op-- a friend; use reference. loc operator--(loc &op) op.longitude--; op.latitude--; return op; int main() loc ob1(10, 20), ob2; ob1.show(); ++ob1; ob1.show(); // displays ob2 = ++ob1; ob2.show(); // displays 12 22

28 --ob2; ob2.show(); // displays return 0; If we want to overload the postfix versions of the increment and decrement operators using a friend, simply specify a second, dummy integer parameter. For example, this shows the prototype for the friend, postfix version of the increment operator relative to loc. // friend, postfix version of ++ friend loc operator++(loc &op, int x); Overloading new and delete: It is possible to overload new and delete. You might choose to do this if you want to use some special allocation method. For example, you may want allocation routines that automatically begin using a disk file as virtual memory when the heap has been exhausted. Whatever the reason, it is a very simple matter to overload these operators. The skeletons for the functions that overload new and delete are shown here: // Allocate an object. void *operator new(size_t size) /* Perform allocation. Throw bad_alloc on failure. Constructor called automatically. */ return pointer_to_memory; // Delete an object. void operator delete(void *p)

29 /* Free memory pointed to by p. Destructor called automatically. */ The type size_t is a defined type capable of containing the largest single piece of memory that can be allocated. (size_t is essentially an unsigned integer.) The parameter size will contain the number of bytes needed to hold the object being allocated. This is the amount of memory that our version of new must allocate. The overloaded new function must return a pointer to the memory that it allocates, or throw a bad_alloc exception if an allocation error occurs. Beyond these constraints, the overloaded new function can do anything else you require. When you allocate an object using new (whether your own version or not), the object's constructor is automatically called. The delete function receives a pointer to the region of memory to be freed. It then releases the previously allocated memory back to the system. When an object is deleted, its destructor function is automatically called. Example #include <iostream> #include <cstdlib> #include <new> using namespace std; class loc int longitude, latitude; public: loc() loc(int lg, int lt) longitude = lg; latitude = lt;

30 void show() cout << longitude << " "; cout << latitude << "\n"; void *operator new(size_t size); void operator delete(void *p); ; // new overloaded relative to loc. void *loc::operator new(size_t size) void *p; cout << "In overloaded new.\n"; p = malloc(size); if(!p) bad_alloc ba; throw ba; return p; // delete overloaded relative to loc. void loc::operator delete(void *p) cout << "In overloaded delete.\n"; free(p); int main() loc *p1, *p2;

31 try p1 = new loc (10, 20); catch (bad_alloc xa) cout << "Allocation error for p1.\n"; return 1; try p2 = new loc (-10, -20); catch (bad_alloc xa) cout << "Allocation error for p2.\n"; return 1;; p1->show(); p2->show(); delete p1; delete p2; return 0; Output from this program is. In overloaded new. In overloaded new In overloaded delete. In overloaded delete.

32 Overloading the Assignment Operator: The compiler generates a default assignment operator (operator=) for all classes that do not define their own The default assignment behavior is the same as that of memberwise initialization Memberwise assignment can cause the same memory leak / dangling pointers problems that we saw with memberwise initialization To override this default assignment, the class must define the assignment operator as follows: ClassName& ClassName :: operator=(const ClassName& C)... The above definition will cause the user-defined assignment operator to be used in place of the system-defined default. Example: #include <iostream.h> #include <string.h> class Product public: Product() : name(null) Product(char* str); const Product& operator=(const Product& ); void Print() cout << "Product: " << name << endl; const char* getproduct() const return name; private: char * name; ; Product :: Product(char* str) name = new char[strlen(str)+1]; strcpy(name, str);

33 const Product& Product :: operator=(const Product& p) delete [] name; name = new char[strlen(p.getproduct())+1]; strcpy(name, p.getproduct()); return *this; // This will allow assignments to be chained int main() Product p1("hammer"), p2("shovel"), p3; p3 = p2; // p2 and p3 will have equivalent name strings p2.print(); p3.print(); p3 = p2 = p1; // p1, p2, and p3 will have equivalent name strings p1.print(); p2.print(); p3.print(); return 0; The keyword this : The keyword this represents a pointer to the object whose member function is being executed. It is a pointer to the object itself. One of its uses can be to check if a parameter passed to a member function is the object itself. For example, // this #include <iostream> using namespace std; class CDummy public: int isitme (CDummy& param); ; int CDummy::isitme (CDummy& param)

34 if (&param == this) return true; else return false; int main () CDummy a; CDummy* b = &a; if ( b->isitme(a) ) cout << "yes, &a is b"; return 0; Output: yes, &a is b It is also frequently used in operator= member functions that return objects by reference (avoiding the use of temporary objects). Following with the vector's examples seen before we could have written an operator= function similar to this one: CVector& CVector::operator= (const CVector& param) x=param.x; y=param.y; return *this; In fact this function is very similar to the code that the compiler generates implicitly for this class if we do not include an operator= member function to copy objects of this class.

35 Type Conversion: What is Type Conversion It is the process of converting one type into another. In other words converting an expression of a given type into another is called type casting. How to achieve this?: There are two ways of achieving the type conversion namely: 1. Automatic Conversion otherwise called as Implicit Conversion Type casting otherwise called as Explicit Conversion Let us see each of these in detail: Automatic Conversion otherwise called as Implicit Conversion: This is not done by any conversions or operators. In other words value gets automatically converted to the specific type in which it is assigned. Let us see this with an example: #include <iostream.h> void main() short x=6000; int y; y=x; In the above example the data type short namely variable x is converted to int and is assigned to the integer variable y.

36 So as above it is possible to convert short to int, int to float and so on. Type casting otherwise called as Explicit Conversion: Explicit conversion can be done using type cast operator and the general syntax for doing this is datatype (expression); Here in the above datatype is the type which the programmer wants the expression to gets changed as In C++ the type casting can be done in either of the two ways mentioned below namely: C-style casting C++-style casting The C-style casting takes the synatx as (type) expression This can also be used in C++. Apart from the above the other form of type casting that can be used specifically in C++ programming language namely C++-style casting is as below namely: type (expression) This approach was adopted since it provided more clarity to the C++ programmers rather than the C-style casting. Say for instance the as per C-style casting (type) firstvariable * secondvariable

37 is not clear but when a programmer uses the C++ style casting it is much more clearer as below type (firstvariable) * secondvariable Let us see the concept of type casting in C++ with a small example: #include <iostream.h> void main() int a; float b,c; cout<< Enter the value of a: ; cin>>a; cout<< n Enter the value of b: ; cin>>b; c = float(a)+b; cout<< n The value of c is: <<c; The output of the above program is Enter the value of a: 10 Enter the value of b: 12.5 The value of c is: 22.5 In the above program a is declared as integer and b and c are declared as float. In the type conversion statement namely c = float(a)+b; The variable a of type integer is converted into float type and so the value 10 is converted as 10.0 and then is added with the float variable b with value 12.5 giving a resultant float variable c with value as 22.5

38 SUMMARY: Constructor is a special member function. This is used to give initial values to member variables. Destructors are usually used to deallocate memory and do other cleanup for a class object and its class members when the object is destroyed. A destructor is called for a class object when that object passes out of scope or is explicitly deleted. The operator overloading feature of C++ is one of the methods of realizing polymorphism. Broadly classifying operators are of two types namely: Unary Operators Binary Operators The keyword this represents a pointer to the object whose member function is being executed. It is a pointer to the object itself. Type conversion is the process of converting one type into another. In other words converting an expression of a given type into another is called type casting. IMPORTANT QUESTIONS: PART A 1. Define constructor. 2. Define default constructor. 3. Define parameterized constructor. 4. Define default argument constructor. 5. What is the ambiguity between default constructor and default argument constructor? 6. Define copy constructor. 7. Define dynamic constructor. 8. Define const object. 9. Define destructor.

39 10. Define multiple constructors. 11. Write some special characteristics of constructor 12. Which operators can not be overloaded? 13. What is meant by operator overloading? PART B 1. Explain about Data Handling and member function. Explain copy constructor and destructor with suitable C++ coding 2. Explain operator overloading with an example. 3. How do you overload the operators new and delete? Give a sample program to implement both. 4. Discuss about the constructor overloading in detail. Give an example to implement it. 5. Discuss about various types of constructors in detail. Give some examples.