C++ Constructor Return Type
Introduction of Constructor
A constructor in C++ is a unique member function inside a class responsible for setting up the properties or data members of objects produced from that class. When you create a class object, the constructors are automatically called to ensure the object is appropriately set up and in a helpful beginning state. They are an essential component of C++'s object-oriented programming and are vital in enclosing a class's behaviour and data.
Constructors have the same name as the class they belong to and no return type, not even void. You may build objects with various initialisations depending on your needs by using overloaded constructors, which let a class have numerous constructors with unique argument lists. Constructors contribute to the dependable and maintainable nature of C++ programs by ensuring that objects are created with the appropriate initialisation.
Purpose of Constructor in C++
Constructors are a key component of object-oriented programming in C++ and serve several important purposes. Here are the primary goals and duties of constructors in C++, thoroughly explained:
- Object Initialisation: The main purpose of the constructor is to create an object, and the constructor initialises the object properties or data members. The created object should be valid in the form of consistency and state. The data elements of the object that is designed and are appropriately initialised by the constructor will always focus and ensure that it does not contain any garbage value or the undefinable state.
- Encapsulation: In encapsulation, the constructor plays a significant role, which is part and parcel of object-oriented programming. The attributes and functions that operate in the data are combined into a single unit or class by using encapsulation. By hiding the specifics of how an object is configured from the outside world via constructors, you may encapsulate the initialisation code within the class. By separating the implementation details, this encapsulation supports the development of clean, modular, and maintainable code.
- Customization and Overloading: C++ enables the creation of numerous constructors for a class, each with an individual set of parameters. Using this functionality, you may adjust how objects get started based on various situations. You may, for instance, have a parameterised constructor that accepts particular values to initialise an object and a default constructor that takes no inputs. Constructor overloading enables flexibility for many use cases and guarantees that objects may be constructed with the proper starting state.
- Memory Allocation and Resource Management: Constructors can be used for memory allocation and resource management in addition to initialising data members. For instance, constructors can allocate memory, set up pointers, and carry out any necessary resource allocation activities in classes that deal with dynamic memory (such as allocating memory for arrays or linked lists). To prevent memory leaks and resource-related problems, constructors are in charge of obtaining and initialising resources.
- Inheritance and Base Class Initialisation: Constructors are also crucial in inheritance, as derived classes inherit characteristics and behaviour from base classes. It is frequently necessary for constructors in derived classes to call constructors in their base classes to guarantee that the inherited attributes are correctly initialised. This ensures initialisation flows smoothly from the base class to the derived class.
- Object Copying: Copy constructors are a constructor that is used when objects are copied. They provide you with the ability to manage how object copying is carried out. You may choose whether a deep or shallow duplicate of an object is created according to your needs by providing a custom copy constructor.
Types of Constructors in C++
The constructor is defined in 3 types, such as:
- Default constructor
- Parameterised Constructor
- Copy Constructor
1. Default constructor
In C++, a default constructor is a type of constructor that accepts no parameters and calls itself automatically when a class object is created without any particular initialisation variables. Providing default values for the object's data members primarily guarantees that objects are initialised and genuine. When you wish to build objects without giving any starting values and instead depend on logical default settings, default constructors are very helpful.
Designing classes and objects in C++ requires carefully defining constructors. When an object is formed, the attributes or data members are initialised by specific member functions known as constructors. The constructor cannot have any return types, not even void, and its name must correspond to the class name. To prevent uninitialised or garbage values in attributes, constructors are crucial in guaranteeing that objects are in a correct state from the time they are created.
There are several different kinds of constructors, including copy constructors (for constructing things by copying data from existing objects), parameterised constructors (with variables to customise initialisation), and default constructors (with no parameters). Additionally, constructors may be overloaded to handle various initialisation possibilities.
By hiding the internals of object setup from other code, proper initialisation within constructors supports encapsulation, a key idea in object-oriented programming. Constructors should be carefully documented and utilised to design strong and stable C++ classes, paying attention to resource management and exception handling as appropriate.
Example code on default constructor:
#include<iostream>
using namespace std;
class Rectangle {
Public:
int length;
// Length of the rectangle
int width;
// Width of the rectangle
// Default Constructor
Rectangle() {
length = 5; // Default length
width = 3; // Default width
}
};
int main() {
// Default constructor called when an object is created
Rectangle r;
// Display the dimensions of the rectangle
cout << "Rectangle dimensions: " << r.length << "x" << r.width << " units" << endl;
return 0;
}
Output:
Explanation:
This C++ code illustrates the development of a simple Rectangle class and its use in the main function. The length and width properties, which specify a geometric rectangle's dimensions, are represented by the Rectangle class.
The class specification includes a default constructor. The length attribute and width attribute are set to 5 units and 3 units, respectively, by this default constructor. When a Rectangle class object is created without any initialisation settings specified, this empty constructor is automatically invoked. A Rectangle class object called r is generated in the main method.
The default constructor is used when creating objects because no exact dimensions are specified. As a result, r is started with a length and breadth of 5 and 3 units, respectively. The cout command is then used by the code to show the rectangle's dimensions to the console. It confirms that the default constructor properly initialised the r object with the default settings by printing "Rectangle dimensions: 5x3 units" in the output.
2. Parameterised Constructor:
In C++, a parameterised constructor is a type of constructor that accepts one or more arguments or parameters when creating an object to modify how it is initialised. Unlike default constructors, which offer predefined beginning values for an object's attributes, parameterised constructors let you build objects with customised initial values. When you wish to initialise objects differently based on multiple conditions, parameterised constructors are crucial.
Parameterised constructors' key features and considerations:
- Custom Initialisation: You may customise the initial state of an object by using parameterised constructors, which let you give parameters when constructing new objects. The data elements of the object are initialised using these parameters in the constructor.
- Overloading: A class may declare several parameterised constructors, each with a unique set of inputs. Overloading of constructors is what this is called. By selecting the right constructor depending on the supplied inputs, you may build objects with different initialisation choices.
- Initialisation List: In a parameterised constructor, the values of the data members are typically set using an initialisation list. When working with complicated or class-type characteristics, initialisation lists are effective and recommended for setting up member variables.
Program on the parameterised constructor:
#include<iostream>
#include<string>
class Employee {
Public:
//Parameterised Constructor
Employee(std::string empName, int empAge) : name(empName), age(empAge) {
// Additional initialisation code can be placed here if needed
}
//method to display employee's information
void displayInfo() {
std::cout << "Employee Name: " << name << ", Employee Age: " << age << " years" << std::endl;
}
Private:
std::string name;
int age;
};
int main() {
// Creating employee objects using the parameterised Constructor
Employee employee1("John Doe", 30);
Employee employee2("Jane Smith", 25);
// Displaying information about the created employees
std::cout << "Employee 1: ";
employee1.displayInfo();
std::cout << "Employee 2: ";
employee2.displayInfo();
return 0;
}
Output:
Explanation:
The above C++ code establishes the Employee class and uses it in the main function. The name property is a string, and age is an integer, and together, they make up the Employee class, which is used to represent employees.
An empName (employee name) and empAge (employee age) parameterised constructor is included in the class, allowing you to build Employee objects with precise values for these two variables. These parameters are used in the constructor to set the name and age of the private data members. Encapsulating data by making characteristics private and granting controlled access through public methods like displayInfo is an intelligent practice. The parameterised constructor is used in the main process to generate the two Employee objects, employee1 and employee2. Each object is initialised with unique employee data, such as the employee's name and age. To display each item's specific characteristics, the displayInfo method is invoked on each object.
The programme output contains details about the two employees, including their names and ages. In this code, the idea of encapsulation is shown, with the class enclosing the employee data and offering a simple interface for accessing and displaying that data. It also highlights using parameterised constructors, a fundamental idea in C++ class design and object-oriented programming, to initialise objects with particular values.
3. Copy Constructor in C++:
Copy Constructor in C++ is a special type of function. When creating a new object, the copy constructor is used to copy the values of existing objects of the same type. It is the copying of the same type of existing object and initialising to the new object. Copy constructors are very helpful for ensuring that objects are copied accurately and that any resources assigned dynamically are managed appropriately.
- Purpose: A copy constructor's principal job is to create a copy of an existing object. It assures that the produced object is a deep or shallow identical depending on the design and requirements of the class.
- Default Copy Constructor: The compiler creates a default copy constructor if you don't expressly declare one in your class. This copy constructor, by default, only makes a shallow copy, which only duplicates the values of data members. This might cause issues for classes that include pointers or dynamically allocated resources if it needs to be handled appropriately.
- Deep Copy vs Shallow Copy: You can provide your copy constructor to make a deep copy of the object if you like. The copy constructor will match the object's data and allocate extra memory as necessary. This is essential if your class uses pointers, arrays, or other dynamic resources.
- Use Cases: When providing objects as values, returning objects as values from functions, or initialising one object with the values of another, copy constructors are employed.
Example code:
#include<iostream>
class Employee {
Public:
std::string empName; // Employee's name
int empAge; // Employee's age
//Parameterised constructor
Employee(std: :string name, int age) : empName(name), empAge(age) {}
// Copy constructor
Employee(const Employee &source) : empName(source.empName), empAge(source.empAge) {}
//method to display employee's information
void displayInfo() {
std: :cout << "Employee Name: " << empName << ", Employee Age: " << empAge << " years" << std: :endl;
}
};
int main(){
// Creating two Employee objects and demonstrating the copy constructor
Employee employee1("John Smith", 35); // Creating the first employee
Employee employee2 = employee1;
// Using the copy constructor to create the second employee
// Displaying information about the employees
std: :cout << "Employee 1 Info:" << std: :endl;
employee1.displayInfo();
std: :cout << "Employee 2 Info (Copy of Employee 1):" << std: :endl;
employee2.displayInfo();
return 0;
}
Output:
Explanation:
This C++ code defines the Employee class and demonstrates its use within the main function. With two attributes—empName for the employee's name and empAge for their age—the Employee class serves as a model for employee data.
A parameterised constructor within the class that accepts the two parameters, name and age, enables you to initialise Employee instances with particular employee data. A special copy constructor is also available, guaranteeing a precise copy of an existing Employee object when building a new one. The empName and empAge properties are successfully transferred from the source object to the new object thanks to this copy constructor.
Two Employee objects, employee1 and employee2, are created in the main function. Employee2 is initialised as a clone of Employee1 by using the copy constructor, whereas Employee1 is initialised with the name "John Smith" and aged 35. Then, for each object, the displayInfo method is used to show the appropriate employee information.
The program's output displays data for both workers, showing that the copy constructor successfully turned the employee2 into a duplicate of the employee1. Especially when working with user-defined classes like employees, this code sample illustrates the critical function of copy constructors in guaranteeing exact object copying and proper handling of class characteristics.
Constructor with Default Arguments
In C++, a constructor type called default arguments enables you to provide default values for one or more of its parameters. By allowing you to call the constructor without any arguments, the feature makes it easier to create objects because the default values are always utilised.
The main benefit of constructors with default arguments is that they provide the user of the class the opportunity to make some constructor parameters optional. This eliminates the requirement for several overloaded constructors and simplifies the interface of the constructor. The constructor declaration specifies default argument values, which must be compile-time considered constants or expressions.
When you have a class with characteristics that may have appropriate default values or when you wish to provide flexibility in how objects are initialised, these constructors are very helpful. When considering whether to utilise default parameters, it's crucial to exercise precaution and take your code's readability and maintainability into account.
Dynamic Initialisation Using a Constructor
In C++, the method of allocating memory and initialising objects during runtime instead of compile-time is known as dynamic initialisation using constructors. When you need to generate objects whose size or attributes can only be established once the program is running, this is especially helpful. It enables you to use tools like new or malloc to allocate memory on the heap before employing a constructor to initialise the object inside that memory.
When working with user-defined kinds of objects, dynamic initialisation is frequently used, especially when the size or properties of the object are decided during programme execution. When working with objects of different sizes, such as those in polymorphic hierarchies, or when designing data structures like linked lists and trees, this method can be crucial since it allows the construction of objects with various features.
When utilising dynamic initialisation, you use new or similar techniques to create a memory for the object on the heap. Then, you call the proper constructor to initialise the object inside that memory. To avoid memory leaks, which happen when memory is not deallocated when it is no longer required, adequate management of dynamically allocated memory is essential. In C++, when the memory that was created using new is no longer needed, it should be released using the delete command.
Does the Constructor have Any Return Type in C++?
Constructors are unique member functions of a class in C++ that initialise objects at creation time. Constructors don't have a return type, not even void, unlike conventional functions. This method separates constructors from other member functions and requires that the constructor name correctly correspond to the class name.
The constructors' inability to provide a return value emphasises their importance in object initialisation rather than their ability to do so. This is a basic rule of the language. The constructor is automatically called when an object is formed to initialise the object's state and attributes to legitimate and valid values.
The constructor's body is where initialisation activities, including setting starting values, allocating memory, and other required setup duties, are completed. The constructor typically handles any initialisation process issue via an error-handling mechanism or by throwing an exception.