C++ Programming Tutorials - Constructors

Welcome to C++ Programming Tutorial

Your guide to getting started with advanced C++ concepts.

Constructors in C++

A constructor in C++ is a special member function of a class that is executed whenever we create a new object of that class. The constructor initializes the object's properties and sets up any necessary resources.

Types of Constructors

1. Default Constructor

The default constructor is a constructor that takes no arguments. If no constructors are defined, the compiler provides a default constructor.

#include <iostream>

class MyClass {
public:
    MyClass() {
        std::cout << "Default Constructor Called" << std::endl;
    }
};

int main() {
    MyClass obj; // Calls default constructor
    return 0;
}

In this example, MyClass() is the default constructor. It is called when an object of MyClass is created without any arguments.

2. Parameterized Constructor

A parameterized constructor takes one or more arguments to initialize the object with specific values. It allows you to pass values during the creation of an object.

#include <iostream>

class MyClass {
public:
    int value;
    MyClass(int val) {
        value = val;
        std::cout << "Parameterized Constructor Called" << std::endl;
    }
};

int main() {
    MyClass obj(10); // Calls parameterized constructor
    std::cout << "Value: " << obj.value << std::endl;
    return 0;
}

Here, MyClass(int val) is a parameterized constructor that initializes the value with the passed argument.

3. Copy Constructor

The copy constructor creates a new object as a copy of an existing object. It is used to initialize a new object as a copy of an existing object of the same class.

#include <iostream>

class MyClass {
public:
    int value;
    MyClass(int val) : value(val) {}
    MyClass(const MyClass &obj) {
        value = obj.value;
        std::cout << "Copy Constructor Called" << std::endl;
    }
};

int main() {
    MyClass obj1(20); // Calls parameterized constructor
    MyClass obj2 = obj1; // Calls copy constructor
    std::cout << "Value of obj2: " << obj2.value << std::endl;
    return 0;
}

In this example, MyClass(const MyClass &obj) is the copy constructor. It initializes obj2 as a copy of obj1.

4. Parameterized Dynamic Constructor

A parameterized dynamic constructor allocates memory dynamically based on the arguments provided. This allows for more flexible object creation and management of resources.

#include <iostream>

class MyClass {
public:
    int* data;
    MyClass(int size) {
        data = new int[size]; // Allocate memory dynamically
        std::cout << "Parameterized Dynamic Constructor Called" << std::endl;
    }
    ~MyClass() {
        delete[] data; // Deallocate memory
    }
};

int main() {
    MyClass obj(5); // Calls parameterized dynamic constructor
    return 0;
}

In this example, MyClass(int size) is a parameterized dynamic constructor that allocates an array of integers based on the provided size.

5. Overloaded Constructors

Overloaded constructors are multiple constructors with the same name but different parameters. They provide different ways to initialize objects based on the arguments passed.

#include <iostream>

class MyClass {
public:
    int value1;
    int value2;
    MyClass() : value1(0), value2(0) {} // Default constructor
    MyClass(int val1) : value1(val1), value2(0) {} // Parameterized constructor
    MyClass(int val1, int val2) : value1(val1), value2(val2) {} // Overloaded constructor
    void display() {
        std::cout << "Value1: " << value1 << ", Value2: " << value2 << std::endl;
    }
};

int main() {
    MyClass obj1; // Calls default constructor
    MyClass obj2(10); // Calls parameterized constructor
    MyClass obj3(20, 30); // Calls overloaded constructor
    obj1.display();
    obj2.display();
    obj3.display();
    return 0;
}

Here, MyClass(), MyClass(int val1), and MyClass(int val1, int val2) are overloaded constructors providing different initialization options.

6. Constructor with Default Arguments

A constructor with default arguments allows you to specify default values for parameters, making them optional during object creation.

#include <iostream>

class MyClass {
public:
    int value1;
    int value2;
    MyClass(int val1 = 1, int val2 = 2) : value1(val1), value2(val2) {} // Constructor with default arguments
    void display() {
        std::cout << "Value1: " << value1 << ", Value2: " << value2 << std::endl;
    }
};

int main() {
    MyClass obj1; // Calls constructor with default arguments
    MyClass obj2(10); // Calls constructor with one argument
    MyClass obj3(20, 30); // Calls constructor with two arguments
    obj1.display();
    obj2.display();
    obj3.display();
    return 0;
}

In this example, MyClass(int val1 = 1, int val2 = 2) is a constructor with default arguments. It can be called with zero, one, or two arguments.

Important Points:

Previous Next
Modern Footer