C++聚合體初始化的方法是什么

本篇內容介紹了“C++聚合體初始化的方法是什么”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

聚合體初始化(aggregate initialization)

C++有很多初始化對象的方法。其中之一叫做 聚合體初始化(aggregate initialization) ，這是聚合體專有的一種初始化方法。

從C語言引入的初始化方式是用花括號括起來的一組值來初始化類：

struct Data {
    std::string name;
    double value;
};
Data x = {"test1", 6.778};

自從C++11起，你可以忽略等號：

Data x{<!--{cke_protected}{C}%3C!%2D%2D%20%2D%2D%3E-->"test1", 6.778};

自從C++17起，聚合體可以擁有基類。也就是說像下面這種從其他類派生出的子類也可以使用這種初始化方法：

struct MoreData : Data {
    bool done;
}
MoreData y{{"test1", 6.778}, false};

如你所見，聚合體初始化時可以用一個子聚合體初始化來初始化類中來自基類的成員。

另外，你甚至可以省略子聚合體初始化的花括號：

MoreData y{<!--{cke_protected}{C}%3C!%2D%2D%20%2D%2D%3E-->"test1", 6.778, false};

這樣寫將遵循嵌套聚合體初始化時的通用規則，你傳遞的實參被用來初始化哪一個成員取決于它們的順序。

擴展聚合體初始化的動機

如果沒有這個特性，那么所有的派生類都不能使用聚合體初始化，這意味著你要像下面這樣定義構造函數：

struct Cpp14Data : Data {
    bool done;
    Cpp14Data (const std::string& s, double d, bool b) : Data{s, d}, done{b} {
    }
};
Cpp14Data y{"test1", 6.778, false};

現在我們不再需要定義任何構造函數就可以做到這一點。

我們可以直接使用嵌套花括號的語法來實現初始化，

如果給出了內層初始化需要的所有值就可以省略內層的花括號：

MoreData x{{"test1", 6.778}, false};    // 自從C++17起OK
MoreData y{"test1", 6.778, false};      // OK

注意因為現在派生類也可以是聚合體，所以其他的一些初始化方法也可以使用：

MoreData u;     // OOPS：value/done未初始化
MoreData z{};   // OK: value/done初始化為0/false

如果覺得這樣很危險，可以使用成員初始值：

struct Data {
    std::string name;
    double value{0.0};
};
struct Cpp14Data : Data {
    bool done{false};
};

或者，繼續提供一個默認構造函數。

使用聚合體擴展

聚合體初始化的一個典型應用場景是對一個派生自C風格結構體并且添加了新成員的類進行初始化。例如：

struct Data {
    const char* name;
    double value;
};
struct CppData : Data {
    bool critical;
    void print() const {
        std::cout << '[' << name << ',' << value << "]\n";
    }
};
CppData y{{"test1", 6.778}, false};
y.print();

這里，內層花括號里的參數被傳遞給基類Data。

注意你可以跳過初始化某些值。在這種情況下，跳過的成員將會進行默認初始化

（基礎類型會被初始化為0、false或者nullptr，類類型會默認構造）。

例如：

CppData x1{};           // 所有成員默認初始化為0值
CppData x2{{"msg"}}     // 和{{"msg", 0.0}, false}等價
CppData x3{{}, true};   // 和{{nullptr, 0.0}, true}等價
CppData x4;             // 成員的值未定義

注意使用空花括號和不使用花括號完全不同：

x1的定義會把所有成員默認初始化為0值，

因此字符指針name被初始化為nullptr，

double類型的value初始化為0.0，

bool類型的flag初始化為false。x4的定義沒有初始化任何成員。所有成員的值都是未定義的。

你也可以從非聚合體派生出聚合體。例如：

struct MyString : std::string {
    void print() const {
        if (empty()) {
            std::cout << "<undefined>\n";
        }
        else {
            std::cout << c_str() << '\n';
        }
    }
};
MyString x{{"hello"}};
MyString y{"world"};

注意這不是通常的具有多態性的public繼承，因為std::string沒有虛成員函數，

你需要避免混淆這兩種類型。

你甚至可以從多個基類和聚合體中派生出聚合體：

template<typename T>
struct D : std::string, std::complex<T>
{
    std::string data;
};

你可以像下面這樣使用和初始化：

D<float> s{{"hello"}, {4.5, 6.7}, "world"}; // 自從C++17起OK
D<float> t{"hello", {4.5, 6.7}, "world"};   // 自從C++17起OK
std::cout << s.data;                        // 輸出："world"
std::cout << static_cast<std::string>(s);   // 輸出："hello"
std::cout << static_cast<std::complex<float>>(s);   //輸出：(4.5,6.7)

內部嵌套的初值列表將按照繼承時基類聲明的順序傳遞給基類。

這個新的特性也可以幫助我們用很少的代碼定義重載的lambda。

聚合體的定義

總的來說，在C++17中滿足如下條件之一的對象被認為是 聚合體 ：

• 是一個數組

• 或者是一個滿足如下條件的 類類型 (class、struct、union)：

• 沒有用戶定義的和explicit的構造函數

• 沒有使用using聲明繼承的構造函數

• 沒有private和protected的非靜態數據成員

• 沒有virtual函數

• 沒有virtual, private, protected的基類

然而，要想使用聚合體初始化來 初始化 聚合體，那么還需要滿足如下額外的約束：

• 基類中沒有private或者protected的成員

• 沒有private或者protected的構造函數

下一節就有一個因為不滿足這些額外約束導致編譯失敗的例子。

C++17引入了一個新的類型特征is_aggregate<>

來測試一個類型是否是聚合體：

template<typename T>
struct D : std::string, std::complex<T> {
    std::string data;
};
D<float> s{{"hello"}, {4.5, 6.7}, "world"};         // 自從C++17起OK
std::cout << std::is_aggregate<decltype(s)>::value; // 輸出1(true)

向后的不兼容性

注意下面的例子不能再通過編譯：

struct Derived;
struct Base {
    friend struct Derived;
private:
    Base() {
    }
};
struct Derived : Base {
};
int main()
{
    Derived d1{};   // 自從C++17起ERROR
    Derived d2;     // 仍然OK（但可能不會初始化）
}

在C++17之前，Derived不是聚合體。因此

Derived d1{};

會調用Derived隱式定義的默認構造函數，這個構造函數會調用基類Base的構造函數。

盡管基類的默認構造函數是private的，但在派生類的構造函數里調用它也是有效的，

因為派生類被聲明為友元類。

自從C++17起，例子中的Derived是一個聚合體，所以它沒有隱式的默認構造函數

（構造函數沒有使用using聲明繼承）。因此，d1的初始化將是一個聚合體初始化，

如下表達式：

std::is_aggregate<Derived>::value

將返回true。

然而，因為基類有一個private的構造函數（見上一節）所以不能使用花括號來初始化。

這和派生類是否是基類的友元無關。

“C++聚合體初始化的方法是什么”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！