Types Of Constructor In C++, Purpose, Example Of Constructor

Hello guys, welcome back to our blog. Here in this article, we will discuss the types of constructor in C++, and why constructor is needed, and we will also share an example for each type of constructor.

If you have any electrical, electronics, and computer science doubts, then ask questions. You can also catch me on Instagram – CS Electrical & Electronics.

Also, read:

Types Of Constructor In C++

In C++, there are several types of constructors that can be used to initialize objects of a class. These include:

Default constructor: A constructor with no parameters that are used to create objects with default values for their data members.
Parameterized constructor: A constructor with one or more parameters that are used to create objects with specific values for their data members.
Copy constructor: A constructor with a single parameter of the same class type that is used to create a new object that is a copy of an existing object.
Move constructor: A constructor with a single parameter of the same class type that is used to create a new object by moving the data from an existing object.
Conversion constructor: A constructor with a single parameter of a different type that is used to create a new object by converting the value of the parameter to the class type.

Here is an example of a class with different types of constructors in C++:

class MyClass
{
public:
  // Default constructor
  MyClass()
  {
    // Initialize the data members with default values
    ...
  }

  // Parameterized constructor
  MyClass(int x, int y)
  {
    // Initialize the data members with the values of the parameters
    ...
  }

  // Copy constructor
  MyClass(const MyClass& other)
  {
    // Copy the data members from the other object
    ...
  }

  // Move constructor
  MyClass(MyClass&& other)
  {
    // Move the data members from the other object
    ...
  }

  // Conversion constructor
  MyClass(double value)
  {
    // Convert the value of the parameter to the class type and initialize the data members
    ...
  }

  // Other member functions
  void myFunction();
  ...
};

In general, a class should have at least one constructor, either a default constructor or a parameterized constructor. This ensures that objects of the class can be created and initialized properly. Additionally, a class can have multiple constructors to allow for different ways of creating and initializing objects.

01. Default constructor:

In C++, a default constructor is a constructor with no parameters that is used to create objects with default values for their data members. A class can have at most one default constructor. If a class does not have a default constructor and no other constructors are defined, the compiler will automatically generate a default constructor for the class.

Here is an example of a default constructor in C++:

class MyClass
{
public:
  // Default constructor
  MyClass()
  {
    // Initialize the data members with default values
    x = 0;
    y = 0;
  }

  // Other member functions
  void myFunction();
  ...

private:
  // Data members
  int x;
  int y;
};

To create an object of the MyClass class, you can use the default constructor with no arguments, as follows:

// Create an object of the MyClass class using the default constructor
MyClass myObject;

The default constructor will initialize the x and y data members of the myObject object with the default value of 0.

If a class has one or more constructors defined, the compiler will not automatically generate a default constructor for the class. In this case, you can define a default constructor for the class if you want to allow objects to be created using the default constructor. You can also define multiple constructors for a class, including a default constructor, to allow for different ways of creating and initializing objects.

02. Parameterized constructor

In C++, a parameterized constructor is a constructor with one or more parameters that are used to create objects with specific values for their data members. A class can have multiple parameterized constructors with different parameter lists.

Here is an example of a parameterized constructor in C++:

class MyClass
{
public:
  // Parameterized constructor
  MyClass(int x, int y)
  {
    // Initialize the data members with the values of the parameters
    this->x = x;
    this->y = y;
  }

  // Other member functions
  void myFunction();
  ...

private:
  // Data members
  int x;
  int y;
};

To create an object of the MyClass class, you can use the parameterized constructor with the appropriate arguments, as follows:

// Create an object of the MyClass class using the parameterized constructor
MyClass myObject(5, 10);

The parameterized constructor will initialize the x and y data members of the myObject object with values of 5 and 10, respectively.

If a class has a parameterized constructor, you can also use the default constructor to create objects with default values for their data members. However, if a class has only parameterized constructors defined, you must use one of the parameterized constructors to create objects of the class. In this case, the default constructor is not automatically generated by the compiler.

03. Copy constructor

In C++, a copy constructor is a constructor with a single parameter of the same class type that is used to create a new object that is a copy of an existing object. A copy constructor is automatically called when an object of the class is passed by value as an argument to a function, returned from a function, or assigned to another object of the same class.

Here is an example of a copy constructor in C++:

class MyClass
{
public:
  // Copy constructor
  MyClass(const MyClass& other)
  {
    // Copy the data members from the other object
    x = other.x;
    y = other.y;
  }

  // Other member functions
  void myFunction();
  ...

private:
  // Data members
  int x;
  int y;
};

The copy constructor takes a constant reference to an object of the same class as its parameter. This allows the copy constructor to access the data members of the other object without modifying them.

Here is an example of how the copy constructor is called in different situations:

// Create an object of the MyClass class
MyClass myObject(5, 10);

// Pass the object by value as an argument to a function
void myFunction(MyClass obj)
{
  // A copy of the object is created and passed to the function
  ...
}

// Call the function
myFunction(myObject);

// Assign the object to another object of the same class
MyClass anotherObject = myObject;

// Return the object from a function
MyClass myFunction()
{
  // Create an object of the MyClass class
  MyClass obj(5, 10);

  // Return the object by value
  return obj;
}

In each of these cases, the copy constructor is called to create a new object that is a copy of the original object. The copy constructor will copy the values of the data members from the original object to the new object.

If a class does not have a copy constructor defined, the compiler will automatically generate a default copy constructor for the class. This default copy constructor will perform a shallow copy of the object, meaning that it will only copy the values of the data members, but not the objects they refer to. If a class has pointers or other objects as data members, you should define a custom copy constructor that performs a deep copy of the object, which copies the objects referred to by the pointers as well as the values of the data members.

04. Move constructor

In C++, a move constructor is a constructor that is used to move an object from one location to another. It is typically used when an object needs to be passed to a function by value, but the object is too large to be copied. Instead of copying the object, the move constructor will “move” the object to the new location, leaving the original object in a valid but unspecified state. This allows the object to be passed to the function without incurring the performance overhead of making a copy.

Here is an example of a simple class that has a move constructor:

class MyClass
{
public:
    MyClass() {}
    MyClass(const MyClass& other) {} // copy constructor
    MyClass(MyClass&& other) {} // move constructor

    // other members...
};

In this example, the MyClass the class has a default constructor, a copy constructor, and a move constructor. The move constructor takes an object of the type MyClass as its parameter, but it has the && (rvalue reference) specifier. This indicates that the other object is an rvalue, which means that it is a temporary object that is eligible to be moved.

To use the move constructor, you can simply pass an rvalue to a function that expects an object of type MyClass as an argument. For example:

void myFunction(MyClass obj)
{
    // use obj...
}

int main()
{
    MyClass x;
    myFunction(std::move(x));
    return 0;
}

In this code, myFunction takes an object of type MyClass by value. When myFunction is called, the std::move the function is used to cast the x object to an rvalue, which causes the move constructor to be called to move the x object into the obj parameter of myFunction. This allows the x object to be passed to myFunction without being copied.

The move constructor is a useful optimization that can improve the performance of your code when you need to pass large objects by value. It is especially useful in cases where the object being moved is likely to be destroyed after it is moved, such as when it is a temporary object or when it is being returned from a function.

05. Conversion constructor

In C++, a conversion constructor is a constructor that is used to create an object from a different type. It is a special type of constructor that is called when an object is explicitly or implicitly converted to a new type.

Here is an example of a simple class that has a conversion constructor:

class MyClass
{
public:
    MyClass() {}
    MyClass(int x) {} // conversion constructor

    // other members...
};

In this example, the MyClass class has a default constructor and a conversion constructor that takes an int as its parameter. This conversion constructor allows an int to be converted to a MyClass object. For example:

int main()
{
    int x = 5;
    MyClass y(x); // calls conversion constructor
    return 0;
}

In this code, the x variable is an int with the value 5. When it is passed as an argument to the MyClass constructor, the conversion constructor is called to create a MyClass object from the int value. This allows the int value to be converted to a MyClass object without the need for explicit type conversion.

Conversion constructors are useful when you want to allow objects of your class to be converted to other types. This can be useful when you want to make your class compatible with other types, or when you want to make it easier to use your class in different contexts. However, you should use conversion constructors carefully, as they can make your code more difficult to understand and can lead to unexpected behavior if they are not used correctly.

This was about “Types Of Constructor In C++“. I hope this article may help you all a lot. Thank you for reading.

Also, read: