Aggregate Initialization in C++ 20

C++20 has undergone several upgrades that aim to streamline and enhance the code. Among these improvements lies a remarkable modification that simplifies the initialization process of aggregates, such as arrays, structs, and classes lacking user-declared constructors. In C++20, you can use aggregate initialization to instantly initialize an aggregate type by enclosing its components in braces. This addition to the language omits the need for convoluted syntax while also minimizing the chance of mistakes.

Aggregate Initialization

Aggregate initialization in earlier versions of C++ was only applicable in elementary instances, such as populating arrays or structs using a value sequence. Nevertheless, the latest version of C++ has extended this feature, enabling intricate aggregate initialization including setting up non-static data members of a class.

Syntax:

Type object_name{value1, value2, ..., valueN};

Examples of Aggregate Initialization

Example 1: 

// C++ Program to demonstrate the use of Aggregate
// Initialization.
#include <iostream>

struct Person {
    std::string name;
    int age;
    std::string address;
};

int main()
{
    // Initialize a Person struct using aggregate
    // initialization
    Person p1{ "John", 33, "New York" };

    // Print out the values of the Person struct
    std::cout << "Name: " << p1.name << std::endl;
    std::cout << "Age: " << p1.age << std::endl;
    std::cout << "Address: " << p1.address << std::endl;

    return 0;
}

Name: John
Age: 33
Address: New York

Example 2: 

// C++ Program  to demonstrate the use of Aggregate
// Initialization.
#include <iostream>

class Date {
public:
    int year;
    int month;
    int day;
};

int main()
{
    // Initialize a Date object using aggregate
    // initialization
    Date d{ 2023, 4, 29 };

    // Print out the values of the Date object
    std::cout << "Year: " << d.year << std::endl;
    std::cout << "Month: " << d.month << std::endl;
    std::cout << "Day: " << d.day << std::endl;

    return 0;
}

Year: 2023
Month: 4
Day: 29

Advantages of Aggregate Initialization

The advantages of using aggregate initialization are mentioned below:

• Concise and easy to read: Initializing objects in a struct or class can be done in a concise and easy-to-read manner using aggregate initialization. This method involves using a single line of code.
• Efficient: Aggregate initialization can save time and memory by bypassing the need to call the constructors of object members. This method proves especially beneficial for initializing sizable arrays or structures.
• Flexible: The flexibility of aggregate initialization enables us to only initialize certain members of an object while leaving the others to retain their default values. This proves advantageous in cases where complete initialization is not necessary or some members require intricate initialization specifications.
• Supports initializer lists: With the provision of C++20, initializing objects with a group of values has become even more convenient as it allows for the utilization of initialization lists as parameters for aggregate initialization.
• Portable: The ability for objects to be initialized across various platforms and architectures in a portable manner is made possible by aggregate initialization, which is universally accepted by all major compilers and integrated in the C standard.