Constructors

Introduction

In the previous lesson, you learned how classes define types and how objects are created as instances of those types.

When an object is created, its data members need suitable initial values before the object is used. Requiring programmers to perform every initialization manually after object creation would make programs repetitive and error-prone.

Student student1;

student1.rollNumber = 101;
student1.name = "Rahul";

C++ provides constructors to make initialization part of object creation itself.

Student student1(101, "Rahul");

What is a Constructor?

A constructor is a special non-static member function used to initialize an object of a class type.

A constructor has the same name as its class and does not have a return type. It is selected and invoked as part of object initialization.

class Student
{
public:
    Student()
    {
        // Constructor body
    }
};

Student student1;
        │
        ▼
Student() Constructor
        │
        ▼
Initialize student1
        │
        ▼
Object Ready

Why Do We Need Constructors?

Objects often need valid initial state before they can be used safely. Constructors allow a class to control how its objects begin their lifetimes.

Real-World Analogy

Imagine receiving a new smartphone. Before you can use it, the device needs an operating system, essential configuration, and initial settings.

A constructor serves a similar purpose for an object. It performs the initialization required when the object begins its lifetime.

📱 New Device
      │
      ▼
⚙️ Initial Setup
      │
      ▼
🔧 Configure State
      │
      ▼
✅ Ready to Use

Characteristics of Constructors

Constructor Syntax

A constructor is declared inside the class using the class name and no return type.

class ClassName
{
public:
    ClassName()
    {
        // Constructor body
    }
};

class Student
{
public:
    Student()
    {
        // Initialization logic
    }
};

// ❌ Incorrect
void Student()
{
}

// ✅ Correct
Student()
{
}

When is a Constructor Called?

A constructor is invoked as part of object initialization. The constructor selected depends on the form of initialization and the arguments provided.

Student student1;

Student student1;
Student student2(101);
Student student3(102, "Amit");

Example 1: Default Constructor

A default constructor is a constructor that can be called with no arguments.

#include <iostream>

class Student
{
public:
    Student()
    {
        std::cout << "Constructor Executed";
    }
};

int main()
{
    Student student1;

    return 0;
}

Constructor Executed

Example 2: Initializing Data Members

Constructors are commonly used to give data members suitable initial values.

#include <iostream>
#include <string>

class Student
{
public:
    int rollNumber;
    std::string name;

    Student()
        : rollNumber(101), name("Rahul")
    {
    }
};

int main()
{
    Student student1;

    std::cout << student1.rollNumber << std::endl;
    std::cout << student1.name;

    return 0;
}

The syntax after the constructor parameter list is called a member initializer list. It initializes the data members before the constructor body executes.

Student()
    : rollNumber(101), name("Rahul")
{
}

101
Rahul

Default vs Parameterized Constructors

Constructors can initialize every object with the same values or accept arguments so that different objects begin with different state.

Student()
    : rollNumber(0), name("Unknown")
{
}

Student(int r, std::string n)
    : rollNumber(r), name(n)
{
}

Example 3: Parameterized Constructor

A parameterized constructor receives values during object creation and uses them to initialize the object.

#include <iostream>
#include <string>

class Student
{
public:
    int rollNumber;
    std::string name;

    Student(int r, std::string n)
        : rollNumber(r), name(n)
    {
    }
};

int main()
{
    Student student1(101, "Rahul");

    std::cout << student1.rollNumber << std::endl;
    std::cout << student1.name;

    return 0;
}

Student student1(101, "Rahul");
          │       │
          │       └────► n
          └────────────► r

r = 101
n = Rahul
    │
    ▼
┌──────────────────────┐
│ rollNumber = 101     │
│ name       = Rahul   │
└──────────────────────┘

101
Rahul

Constructor Overloading

Constructor overloading means defining multiple constructors in the same class with different parameter lists.

#include <string>

class Student
{
public:
    int rollNumber;
    std::string name;

    Student()
        : rollNumber(0), name("Unknown")
    {
    }

    Student(int r)
        : rollNumber(r), name("Unknown")
    {
    }

    Student(int r, std::string n)
        : rollNumber(r), name(n)
    {
    }
};

Student s1;
Student s2(101);
Student s3(102, "Rahul");

Memory Representation

Consider an object initialized using Student student1(101, "Rahul"). The constructor establishes the initial state of the object.

Student student1(101, "Rahul");

student1
┌────────────────────────┐
│ rollNumber = 101       │
│ name       = Rahul     │
└────────────────────────┘

The constructor itself is not stored separately inside every object. Non-static data members contribute to each object’s state, while member functions are part of the class definition.

Constructor Execution Flow

Object initialization follows a defined sequence. Data members are initialized before the constructor body executes.

class Student
{
public:
    int rollNumber;
    std::string name;

    Student(int r, std::string n)
        : rollNumber(r), name(n)
    {
        std::cout << "Constructor body";
    }
};

Student student1(101, "Rahul");
              │
              ▼
Select Matching Constructor
              │
              ▼
Initialize rollNumber
              │
              ▼
Initialize name
              │
              ▼
Execute Constructor Body
              │
              ▼
Object Initialization Complete

Real-World Applications

Constructors are used throughout software systems to establish the initial state of newly created objects.

BankAccount account(
    "ACC101",
    "Rahul",
    5000.0
);

Create Account
      │
      ▼
Validate Required Values
      │
      ▼
Initialize Account State
      │
      ▼
Account Ready

Advantages of Constructors

Common Beginner Mistakes

// ❌ Incorrect
void Student()
{
}

// ✅ Correct
Student()
{
}

class Student
{
public:
    // ❌ Wrong name
    // Person() {}

    // ✅ Correct
    Student() {}
};

Student student1;

// ❌ Incorrect
// student1.Student();

class Student
{
public:
    Student(int r)
    {
    }
};

// ❌ No matching constructor
// Student student1;

// ✅ Matching constructor
Student student2(101);

Best Practices

class Student
{
private:
    int rollNumber;
    std::string name;

public:
    Student(int r, std::string n)
        : rollNumber(r), name(n)
    {
    }
};

class Student
{
public:
    explicit Student(int rollNumber)
    {
    }
};

Frequently Asked Questions

Key Takeaways

Summary

Constructors are special member functions used during object initialization. They allow a class to control how its objects begin their lifetimes.

A default constructor can initialize an object without arguments, while a parameterized constructor accepts values that allow different objects to begin with different state.

Constructor overloading allows a class to provide multiple valid initialization forms. The compiler selects an appropriate constructor according to the supplied arguments.

Member initializer lists are the preferred way to initialize data members because initialization occurs before the constructor body executes.

By designing constructors carefully, classes can reduce repetitive setup code and help ensure that objects begin their lifetimes in meaningful states.

Now that you understand how objects are initialized, the next lesson will introduce destructors, which are special member functions involved when an object’s lifetime ends.