Classes class A { ... };

Outline Constructor Destructor C++

Constructor Initialization of objects using constructors Calling the constructors if a member is an object C++

Initialization of Objects Using Constructors When an object is created a constructor is called. The name of the constructor must be the same as the name of the class. Function names can be overloaded in C++, thus a class can have multiple constructors. In this case the lists of formal parameters must be different. There is no return value for constructors, and it is not allowed to use the void keyword. C++

Example class Person { char* name; public: Person(); // default constructor Person(char* _name); Person(const Person& p); //copy //constructor ~Person(); void Display(); }; C++

Default Constructor The list a formal parameters must be empty, or if there are formal parameters then all these arguments must have a default value. If a class has a default constructor, then it is possible to define an object without giving the list of actual parameters. C++

If there is no Constructor If we don’t define a constructor, then an empty default constructor will be generated automatically. If there is at least one constructor, then no default constructor will be generated, therefore if we need one we should define it. C++

classname(const classname & object); Copy Constructor Purpose: define an object using another object of the same type. Form: classname(const classname & object); The const keyword is present because the actual parameter must not change. C++

Default Constructor Person::Person() { name = new char[1]; *name = 0; cout << "Default constructor\n"; } C++

Conventional Constructor Person::Person(char* _name) { name = new char[strlen(_name)+1]; strcpy(name, _name); cout << "Conventional constructor\n"; } C++

Copy Constructor Person::Person(const Person& p) { name = new char[strlen(p.name)+1]; strcpy(name, p.name); cout << "Copy constructor\n"; } C++

Destructor and Display Method Person::~Person() { cout << "Destructor\n"; delete[] name; } void Person::Display() { cout << name << endl; C++

The main function int main() { Person A; A.Display(); Person B("Stroustrup Bjarne"); B.Display(); Person *C = new Person("Kernighan Brian"); C->Display(); delete C; } C++

Output Default constructor Conventional constructor Stroustrup Bjarne Kernighan Brian Destructor C++

If there is no Copy Constructor If we don’t define a copy constructor, then a default copy constructor is generated which simply copies all the bytes of the data members (memberwise copy). This method gives good result if there are no pointers between the members. C++

Another main Function int main() { Person B("Stroustrup Bjarne"); B.Display(); // ... Person D(B); //the same as Person D = B; D.Display(); } If there is no copy constructor, then the destructor is called twice for the same memory location. C++

Example: MyVector The copy constructor The Sum member function The main function C++

The Class Declaration class MyVector { private: int *elem; int dim; public: MyVector(int *e, int d); MyVector(const MyVector & v); ~MyVector(); void SquareVect(); MyVector Sum(MyVector & v); void Display(); }; C++

The Copy Constructor MyVector::MyVector(const MyVector & v) { dim = v.dim; elem = new int[dim]; for(int i=0; i < dim; i++) elem[i] = v.elem[i]; } C++

The Sum Member Function MyVector MyVector::Sum(MyVector & v) { if (dim != v.dim) { cerr << "Error: different dimensions"; exit(1); } int* x = new int[dim]; C++

The Sum Member Function for(int i = 0; i < dim; i++) x[i] = elem[i] + v.elem[i]; MyVector t(x, dim); delete [] x; return t; } C++

The main Function int main() { int x[]={1, 2, 3, 4, 5}; MyVector v1(x, 5); int y[]={2, 4, 6, 8, 10}; MyVector v2(y, 5); v1.Sum(v2).Display(); // 3 6 9 12 15 } C++

Calling the Constructors if a Member is an Object An object of a class can contain other objects as data members. Example: class C { C_1 ob_1; C_2 ob_2; … C_n ob_n; }; C++

The Constructor In this case the constructor has the form: C(argumentlist) : list-of-objects The list of object has the form: ob_1(arglist_1), ob_2(arglist_2), ..., ob_n(arglist_n) where argumentlist is the list of formal parameters in class C, and arglista_i is the list of arguments of the object ob_i. C++

Example The Pair Class husband: Person wife : Person C++

The Pair Class class Pair { Person husband; Person wife; public: } C++

The Pair Class Pair(Person& thehusband, Person& thewife); Pair(char* husband_name, char* wife_name) : husband(husband_name), wife(wife_name) { } void Display(); }; C++

Constructor Definition, and the Display Method inline Pair::Pair(Person& thehusband, Person& thewife) : husband(thehusband), wife(thewife) { } void Pair::Display() { cout << "Husband: "; husband.Display(); cout << "Wife: "; wife.Display(); C++

The main function int main() { Pair XY; XY.Display(); Person A("A"); Person B("B"); Pair AB(A, B); AB.Display(); Pair UV("U", "V"); UV.Display(); } C++

Output Husband: Wife: Husband: A Wife: B Husband: U Wife: V C++

Destructor If an object is no longer used, the destructor will be executed. The name of the destructor starts with ~ and after that, the name of the class is given. There is no return value for destructors, and it is not allowed to use the void keyword. C++

Example #include <iostream> #include <cstring> using namespace std; class PrintOut { char* name; public: PrintOut(char* n); ~PrintOut(); }; C++

Constructor PrintOut::PrintOut(char* n) { name = new char[strlen(n)+1]; strcpy(name, n); cout << "Creating: " << name << endl; } C++

Destructor PrintOut::~PrintOut() { cout << "Freeing: " << name << endl; delete name; } C++

Global and local objects void MyFunction() { cout << "Calling MyFunction\n"; PrintOut local("LOCAL"); } PrintOut global("GLOBAL"); C++

The main function int main() { PrintOut* dynamic = new PrintOut("DYNAMIC"); MyFunction(); cout << "Continue the main function\n"; delete dynamic; } C++

Output Creating: GLOBAL Creating: DYNAMIC Calling MyFunction Creating: LOCAL Freeing: LOCAL Continue the main function Freeing: DYNAMIC Freeing: GLOBAL C++