Constructors In C++ With Examples

As an experienced C++ developer, you know that constructors play an integral role in creating and initializing class objects properly. Get an in-depth understanding of what constructors are, how they work, and how to leverage them effectively. This comprehensive guide takes you through constructors from basic to advanced usage, with expert analysis that connects the dots to core object-oriented programming concepts.

What is a Constructor?

A constructor is a special member function that shares the same name as the class itself and is used to initialize objects of that class type. Constructors are invoked automatically when an object is created to allocate the necessary memory and initialize member variables and properties.

For example:

class MyClass {
public:
  MyClass() {
    // Constructor definition
  }
};

MyClass myObject; // Automatically calls constructor

Unlike other member functions, constructors have no return type at all, not even void. Their sole purpose is to setup new objects for usage before any other member functions access them.

Why Use Constructors?

Constructors provide several crucial benefits:

Encapsulation – By centralizing a class‘ initialization logic into its constructors, implementation details can remain private while allowing flexible object creation.

Code Reuse – Parameterized constructors allow constructor code to be reused for creating objects in different ways.

Performance – Constructor initialization is faster than setting values individually post-creation.

Correctness – Constructors establish class invariants, preventing objects from going into invalid states.

Without constructors, initializing class objects safely and efficiently would become highly challenging. Defining the right constructors is key for robust and scalable object-oriented systems.

Types of Constructors

C++ supports three major types of constructors – default constructors, parameterized constructors, and copy constructors.

Default Constructors

A default constructor has no parameters and simply allocates storage space for the new object. Default data member values may be specified as well.

class MyClass {
public:
  MyClass() {
    x = 0; 
    y = 0;
  }

  int x;
  int y;
};

If a class lacks explicitly defined constructors, C++ will automatically generate a parameterless default constructor.

Parameterized Constructors

Parameterized constructors initialize objects based on arguments, allowing varying object states during creation:

class MyClass { 
public:
  MyClass(int x, int y) {
    this->x = x; 
    this->y = y;
  }

  int x;
  int y;  
};

MyClass o1(1, 2); 
MyClass o2(3, 4);

This technique is vital for flexibly constructing objects suited to particular use cases early on.

Copy Constructors

Copy constructors define how an object is initialized when copied into a new object during pass-by-value function arguments or return values.

class MyClass {
public:
  MyClass(const MyClass &source) {
    x = source.x; 
    y = source.y; 
  }

  int x, y;
};  

MyClass o1(1, 2);
MyClass o2 = o1; // Invokes copy constructor

This makes pass-by-value safe and efficient without having to write duplicate assignment logic all over.

Member Initialization Lists

Member initialization lists provide an elegant way to initialize data members and base classes alongside the constructor definition:

class MyClass : public Base {
public:
  MyClass(int x) : Base(x), x(x) { }  

  int x;
};

The motivation behind this technique is improved performance and correctness:

• Member initialization happens before the constructor body runs, allowing faster initialization
• Prevents duplicate assignment logic and enforces DRY principles
• Works for constant and reference members which cannot be assigned to post-creation
• Necessary for initializing base class constructors in derived classes

Overall, member initialization lists are integral for robust class design in C++.

Constructor Overloading

A very useful technique, constructor overloading allows different constructor variants to be defined within a single class:

class MyClass {
public:
  MyClass(){ // Default constructor 
  } 

  MyClass(int x){ // Parameterized constructor 1
    . . .
  }

  MyClass(int x, int y) { // Parameterized constructor 2
   . . .
  }
};

MyClass o1; // Invokes default constructor
MyClass o2(1); // Invokes overloaded variant 1
MyClass o3(1, 2); // Invokes overloaded variant 2

The compiler differentiates between these based on the arguments passed. This avoids having to write redundant initialization logic repeatedly while enabling broader reuse of constructors.

Relation to Object Composition

Constructor overloading also facilitates object composition – a fundamental OOP concept where classes can be composed or built using other classes. The outer class simply invokes the appropriate inner class constructors from its own constructor overloads.

This builds up complexity incrementally through simpler objects.

Inheriting Constructors in Derived Classes

For derived classes, the base class constructors are always invoked before the derived class constructor to ensure proper initialization order:

1. The base default constructor is automatically called
2. Non-default base constructors must be called explicitly via member initialization lists
3. Order of constructor chaining matters when multiple inheritance levels are involved

For example:

class Base {
  Base(int x); 
};

class Derived : public Base {
public:
  Derived(int x, int y) : Base(x) { 
     . . .
  }  
};

Derived d(5, 3); // Calls Base(5) before Derived(...)

Importance of Constructor Order in Inheritance

Mandating base class constructor call order prevents derived classes from accessing incomplete base class state during their initialization. This discipline is required for building robust class hierarchies.

When are Constructors Called?

Constructor invocation happens automatically in C++ whenever a new object requires initialization in scenarios like:

• Object creation via new
• Passing objects by value as function arguments
• Returning objects by value from functions
• Static object initialization upon entering scope
• Temporary objects during exception handling

Wherever an object comes into scope, its constructor builds it for proper usage.

Destructors – The Counterpart to Constructors

Just as constructors initialize new objects, destructors "clean up" objects right before they go out of scope. The destructor syntax looks like:

class MyClass {
public:
  ~MyClass() { 
    // Cleanup statements
  }
};

Common destructor tasks include:

• Releasing acquired resources like files, network connections etc.
• Deleting dynamically allocated memory
• Flushing file handles and streams
• Firing custom completion events/callbacks

Well-written destructors prevent resource leaks and invalid object state upon destruction – complementary to constructors.

Conclusion

From basics like default constructors to sophisticated applications in inheritance, this guide covers everything C++ developers need to know about properly leveraging constructors. Proper constructor design promotes encapsulation, code reuse and performance while powering essential OOP techniques like inheritance and composition. Use this comprehensive reference to take your object-oriented programming skills to the next level by mastering constructors in C++!