Learn C++ Online

Destructors in C++

A destructor in C++, as the name implies, is used to destroy the objects that have been created by a constructor. Like a constructor, the destructor in C++ is a member function whose name is the same as the class name but is preceded by a tilde (~). For example, the destructor for the class integer can be defined as shown below: ~integer() { } A destructor in C++ never takes any arguments nor does it return any value. It will be invoked implicitly by the compiler upon exit from the program (or the block or the function as the case may be) to clean up the storage that is no longer accessible. It is a good practice to declare destructors in a program since it releases memory space for future use. Whenever new is used to allocate memory in the constructors, we should use delete to free that memory....

Constructor with Default Arguments in C++

It is possible in C++ to define constructors with default arguments. For example, the constructor integer(), defined in the previous section (Constructors in C++), can be defined as follows: integer(int x, int y = 3); The default value of the argument y is 3. Thus, the statement: integer a(1); assigns the value 1 to x variable and 3 to y (by default). However, the statement: integer a(1, 5); assigns 1 to x and 5 to y. The actual parameters, when specified, overrides the default value. Note: The missing arguments must be the trailing ones.

Parameterized Constructors in C++

The constructor integer(), defined in the previous section (Constructors in C++), initializes the data members of all the objects to zero. However, in practice it may be necessary to initialize the various data elements of different objects with different values when the are created. C++ permits us to achieve this objective by passing arguments to the constructor function when the objects are created. The constructors that can take the arguments are called parameterized constructors. The constructor integer() may be modified to take arguments as shown below: class integer { private: int m, n; public: integer(int x, int y); //parameterized constructor … … }; integer :: integer(int x, int y) { m = x; n = y; } When a constructor has been parameterized, the object declaration statement such as: integer in1; may not work. We must pass the initial values as arguments to the constructor function when an object is...

Constructors in C++

A constructor in C++ is a special member function whose task is to initialize the objects of its class. It is special because its name is the same as the class name. The constructor is invoked whenever an object of its associated class is created. It is called constructor because it constructs the values of data members of the class. A constructor is declared and defined as follows: class integer //class with a constructor { private: int m, n; public: integer(); //constructor declared … … }; integer :: integer() //constructor defined { m = 0; n = 0; } When a class contains a constructor like the one defined above, it is guaranteed that an object created by the class will be initialized automatically. For example, the declaration: integer in1; //object in1 created not only creates the object in1 of type integer but also initializes its data members m and...

Array of Objects in C++

We know that an array can be of any data type. Hence, we can also have arrays of variables that are of the type class. Such variables are called array of objects. Consider the following class definition: class employee { char name[30]; float age; public: void getdata(); void putdata(); }; The identifier employee is a user-defined data type and can be used to create objects that relate to different categories of the employee. For example, consider the following: employee managers[3]; //array of manager employee foremen[15]; //array of foreman employee workers[75]; //array of worker In above declaration, the array managers contains three objects (managers), namely, managers[0], managers[1] and managers[2], of the type employee class. Similarly, the foremen array contains 15 objects (foremen) and the workers array contains 75 objects (workers). Since, an array of objects behave like any other array, we can use the usual array-accessing methods to access individual elements...

Friend Functions and Friend Classes in C++

We have been emphasizing that the private members cannot be accessed from outside the class. That is, a non-member function cannot have an access to the private data of a class. However, there could be a situation where we would like two classes to share a particular function. For example, consider a case where two classes, manager and scientist, have been defined. We would like to use a function income() to operate on the objects of both these classes. In such situations, C++ allows the common function to be made friendly with both the classes, thereby allowing the function to have access to the private data of these classes. Such a function need not be a member of any of these classes. To make an outside class “friendly” to a class, we have to simply declare this function as a friend of the class as illustrated below: class ABC {...