Section 1.1: Default Constructor

A default constructor is one that does not accept any arguments, allowing for the creation of a class instance with standard default values. If a constructor is not explicitly defined, the compiler automatically generates an implicit default constructor with an empty body.

The following example demonstrates how a default constructor can be utilized. Here, the variables numberOfLegs and livesOnLand are initialized accordingly.

Upon executing the program, you will observe the result below. If the constructor mentioned earlier is absent, the compiler will provide an empty default constructor, leading to nonsensical output since no values were initialized in the memory locations being referenced.

Section 1.2: Parameterized Constructor

A parameterized constructor accepts arguments, enabling the instantiation of an object with user-defined attributes. In the example below, we can create an instance of fish by passing the relevant attributes.

Running this program will yield the anticipated results.

Section 1.3: Copy Constructor

A copy constructor is a method designed to initialize a new object using an existing instance of the same class. It is defined with the following signature:

class-name (const class-name &)

In our example, it appears as Animal(const Animal &obj).

When the program is run, you will see the outputs demonstrating that the copy constructor is invoked when fish1 is assigned to fish2. It is important to note that if fish2 is created first and then assigned fish1, only the assignment operator will be used.

Section 1.4: Understanding the Need for a Copy Constructor

If a copy constructor is not explicitly defined, the compiler will generate one by default. However, if your class contains pointer variables, you must define a copy constructor manually to avoid unexpected behavior.

Consider the scenario where numberOfLegs is an integer pointer, and we do not provide an explicit copy constructor, as shown in the following program:

// Hypothetical example

Animal fish1(numLegsPtr); // fish1 initialized with pointer

Animal fish2(fish1); // fish2 initialized via copy constructor

We print the number of legs for each object and modify fish1's number of legs, which reveals a critical issue: both objects share the same pointer address.

From the output, it becomes evident that both fish1 and fish2 reference the same address in memory. When fish1 updates its value, fish2 reflects this change as well. The compiler's implicit copy constructor performed a shallow copy, copying the address rather than allocating a new one for fish2.

To solve this, we can implement a copy constructor that ensures each object has its own separate memory allocation for numberOfLegs.

By doing so, each object maintains its own value independently.

Another reason for defining a copy constructor is to prevent dangling pointers. If two objects share a pointer to the same memory address and one is deleted (e.g., when it goes out of scope), the other will point to an invalid address, potentially causing a program crash.