C++ Array Of Classes Constructor

MUAZHAN

5 min read

·

Jul 05, 2024

32

Share

C++ Array of Classes and Constructors

In C++, it's often useful to work with arrays of objects. This allows you to manage and access multiple instances of the same class efficiently. When working with such arrays, understanding how constructors play a role is crucial.

Initializing Objects within an Array

Let's imagine you have a class named Employee with attributes like name and salary. You can create an array of Employee objects like this:

#include 

class Employee {
public:
    std::string name;
    double salary;

    // Constructor
    Employee(const std::string& n, double s) : name(n), salary(s) {}

    void display() {
        std::cout << "Name: " << name << ", Salary: $" << salary << std::endl;
    }
};

int main() {
    Employee employees[3]; // Array of 3 Employee objects

    // Initialize each object individually
    employees[0] = Employee("John Doe", 50000.0);
    employees[1] = Employee("Jane Smith", 60000.0);
    employees[2] = Employee("Peter Jones", 45000.0);

    // Display employee details
    for (int i = 0; i < 3; ++i) {
        employees[i].display();
    }

    return 0;
}

Explanation:

1. Constructor: The Employee class has a constructor that takes the employee's name and salary as arguments. It initializes the object's data members.
2. Array Declaration: Employee employees[3] declares an array named employees that can hold 3 Employee objects.
3. Initialization: We initialize each object in the array using the constructor by assigning a new Employee object to each element.

Initializing Arrays with Constructors

The above approach can be repetitive for larger arrays. You can use a more efficient approach by initializing objects directly during array creation:

#include 

class Employee {
public:
    std::string name;
    double salary;

    // Constructor
    Employee(const std::string& n, double s) : name(n), salary(s) {}

    void display() {
        std::cout << "Name: " << name << ", Salary: $" << salary << std::endl;
    }
};

int main() {
    // Initialize objects during array creation
    Employee employees[3] = {
        Employee("John Doe", 50000.0),
        Employee("Jane Smith", 60000.0),
        Employee("Peter Jones", 45000.0)
    };

    // Display employee details
    for (int i = 0; i < 3; ++i) {
        employees[i].display();
    }

    return 0;
}

Explanation:

1. Array Declaration & Initialization: We declare and initialize the employees array directly using curly braces {}. Inside the braces, we provide Employee objects with their constructor arguments.

This approach is more concise and efficient, especially when working with large arrays.

Using Initialization Lists

For simpler constructors, you can use initialization lists directly within the array declaration:

#include 

class Employee {
public:
    std::string name;
    double salary;

    // Constructor
    Employee(const std::string& n, double s) : name(n), salary(s) {}

    void display() {
        std::cout << "Name: " << name << ", Salary: $" << salary << std::endl;
    }
};

int main() {
    // Initialize objects using initialization lists
    Employee employees[3] = {
        {"John Doe", 50000.0},
        {"Jane Smith", 60000.0},
        {"Peter Jones", 45000.0}
    };

    // Display employee details
    for (int i = 0; i < 3; ++i) {
        employees[i].display();
    }

    return 0;
}

Explanation:

1. Initialization Lists: Instead of creating Employee objects directly, we use initialization lists within the curly braces to directly provide values for the name and salary members.

Conclusion

Understanding the role of constructors when working with arrays of classes is crucial for proper initialization and efficient code. The methods discussed above provide different ways to initialize objects within an array, allowing you to choose the approach that best suits your specific needs and the complexity of your constructor.