类初始化与拷贝消除

int a;         // 无初始化器（默认初始化）
int b = 5;     // 等号后的初始化器（拷贝初始化）
int c( 6 );    // 圆括号中的初始化器（直接初始化）

// 列表初始化方法（C++11）
int d { 7 };   // 花括号中的初始化器（直接列表初始化）
int e = { 8 }; // 等号后花括号中的初始化器（拷贝列表初始化）
int f {};      // 初始化器为空花括号（值初始化）

#include <iostream>

class Foo
{
public:
    // 默认构造函数
    Foo()
    {
        std::cout << "Foo()\n";
    }

    // 普通构造函数
    Foo(int x)
    {
        std::cout << "Foo(int) " << x << '\n';
    }

    // 拷贝构造函数
    Foo(const Foo&)
    {
        std::cout << "Foo(const Foo&)\n";
    }
};

int main()
{
    // 调用Foo()默认构造函数
    Foo f1;           // 默认初始化
    Foo f2{};         // 值初始化（推荐）

    // 调用foo(int)普通构造函数
    Foo f3 = 3;       // 拷贝初始化（仅限非显式构造函数）
    Foo f4(4);        // 直接初始化
    Foo f5{ 5 };      // 直接列表初始化（推荐）
    Foo f6 = { 6 };   // 拷贝列表初始化（仅限非显式构造函数）

    // 调用foo(const Foo&)拷贝构造函数
    Foo f7 = f3;      // 拷贝初始化
    Foo f8(f3);       // 直接初始化
    Foo f9{ f3 };     // 直接列表初始化（推荐）
    Foo f10 = { f3 }; // 拷贝列表初始化

    return 0;
}

#include <iostream>

class Something
{
    int m_x{};

public:
    Something(int x)
        : m_x{ x }
    {
        std::cout << "Normal constructor\n";
    }

    Something(const Something& s)
        : m_x { s.m_x }
    {
        std::cout << "Copy constructor\n";
    }

    void print() const { std::cout << "Something(" << m_x << ")\n"; }
};

int main()
{
    Something s { Something { 5 } }; // 关注这一行
    s.print();

    return 0;
}

Something s { 5 }; // 只调用Something(int)，不需要拷贝构造函数

#include <iostream>

class Something
{
public:
    Something() = default;
    Something(const Something&)
    {
        std::cout << "Copy constructor called\n";
    }
};

Something rvo()
{
    return Something{}; // 调用Something()和拷贝构造函数
}

Something nrvo()
{
    Something s{}; // 调用Something()
    return s;      // 调用拷贝构造函数
}

int main()
{
    std::cout << "Initializing s1\n";
    Something s1 { rvo() }; // 调用拷贝构造函数

    std::cout << "Initializing s2\n";
    Something s2 { nrvo() }; // 调用拷贝构造函数

    return 0;
}