《C++进阶之C++11》【列表初始化 + 右值引用】

//基本语法一：
Type variable{arg1, arg2, ...};

//基本语法二：
Type variable = {arg1, arg2, ...};

//内置数据类型的初始化
int num = {5};
double d = {3.14};

//数组的初始化
int arr[]{1, 2, 3, 4, 5};

#include <iostream>
#include <vector>
#include <string>


/*--------------------------- 自定义类类型 ---------------------------*/
class Person 
{
public:
    // 构造函数可以使用初始化列表
    Person(std::string n, int a, double h)
        : name{ n }, 
        age{ a }, 
        height{ h } 
    { }

    void display() const 
    {
        std::cout << "Name: " << name
            << ", Age: " << age
            << ", Height: " << height 
            << "m" << std::endl;
    }

private:
    std::string name;
    int age;
    double height;
};

/*--------------------------- 聚合类 ---------------------------*/
class Point 
{
public:
    int x;
    int y;
    int z;
};

int main() 
{
    //1.自定义类的列表初始化
    Person p1{ "Alice", 25, 1.68 };  // 使用构造函数初始化
    Person p2 = { "Bob", 30, 1.75 }; // 也可以使用等号形式

    p1.display();
    p2.display();

    //2.聚合类的直接列表初始化
    Point pt1{ 10, 20, 30 };        // 直接初始化成员变量
    Point pt2 = { 40, 50, 60 };     // 使用等号形式

    std::cout << "Point 1: (" << pt1.x << ", " << pt1.y << ", " << pt1.z << ")" << std::endl;
    std::cout << "Point 2: (" << pt2.x << ", " << pt2.y << ", " << pt2.z << ")" << std::endl;

    return 0;
}

#include <vector>
#include <map>

//使用语法一进行初始化
std::vector<int> v = { 1, 2, 3, 4, 5 };
std::map<std::string, int> m = { {"apple", 1}, {"banana", 2} };

/* 列表初始化对 STL 容器特别友好
*   - 调用 push_back、insert 等接口时：
*   - 用 {} 可直接构造 “多参数对象”，无需手动创建临时对象
*
*/

//使用语法二进行初始化
std::vector<int> v{ 1, 2, 3, 4, 5 };
std::map<std::string, int> m{ {"one", 1}, {"two", 2} };

// 定义一个结构体 Point，用于表示二维坐标点
struct Point
{
    int _x;  
    int _y;  
};

int main()
{
    //1.初始化一个整型数组 array1，花括号内依次是数组元素的初始值
    int array1[] = { 1, 2, 3, 4, 5 }; //注意：编译器会根据初始值的数量自动推导数组长度为 5

    //2.初始化一个长度为 5 的整型数组 array2
    int array2[5] = { 0 }; //注意：花括号内只有一个初始值 0，此时数组的第一个元素被初始化为 0，剩余未显式初始化的元素会被默认初始化为 0（对于内置整型类型）

    //3.初始化结构体 Point 的对象 p
    Point p = { 1, 2 }; //注意：按照结构体成员的声明顺序，用花括号内的值依次初始化 _x 和 _y

    return 0;  
}

class Point 
{
public:
    int x, y;
    Point(int a, int b) : x(a), y(b) {}
};

// 列表初始化：先匹配构造函数，编译器优化后直接构造
Point p{1, 2}; 

int a = {3.14};  // 编译错误，窄化转换

template<class T> class initializer_list;

#include <iostream>
#include <initializer_list>

void print(std::initializer_list<int> list) 
{
    for (auto it = list.begin(); it != list.end(); ++it) 
    {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
}

int main() 
{
    print({1, 2, 3, 4, 5});
    return 0;
}

#include <iostream>
#include <vector>
#include <map>


std::vector<int> v = {1, 2, 3, 4, 5};
std::map<std::string, int> m = {{"apple", 1}, {"banana", 2}};
int main() 
{
    for (auto num : v) 
    {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    
    
    for (auto it = m.begin(); it != m.end(); ++it) 
    {
        std::cout << it->first << ": " << it->second << std::endl;
    }
    return 0;
}

#include <iostream>
#include <vector>
#include <initializer_list>  // 提供 initializer_list 类型支持花括号初始化


// 自定义数组类，封装 std::vector 并支持列表初始化
class MyArray
{
private:
    std::vector<int> data;  // 底层存储容器

public:
    // 支持 initializer_list 的构造函数，允许使用花括号初始化 ---> 例如: MyArray arr = {1, 2, 3};
    MyArray(std::initializer_list<int> list)
    {
        // 遍历 initializer_list 中的元素并添加到 vector
        for (auto value : list)
        {
            data.push_back(value);
        }
    }

    void print()
    {
        for (auto num : data)
        {
            std::cout << num << " ";
        }
        std::cout << std::endl;
    }
};

int main()
{
    // 使用列表初始化语法创建 MyArray 对象
    MyArray arr = { 10, 20, 30 };   // 等价于调用 MyArray({10, 20, 30})

    arr.print();
    return 0;
}

vector<int> v1 = {1,2,3};   // 需支持 3 个元素的构造
vector<int> v2 = {1,2,3,4}; // 又需支持 4 个元素的构造

#include<iostream>
#include<string>
#include<vector>
#include<map>
using namespace std;

int main()
{
    //1. 直接使用 initializer_list<int>（自动推导类型）
    std::initializer_list<int> mylist;
    mylist = { 10, 20, 30 };         // 编译器自动将 {10,20,30} 转为 initializer_list<int>
    cout << sizeof(mylist) << endl;  // 输出 16（通常存两个指针：起始、结束）

    //2. 验证 initializer_list 的底层存储（理解为“栈上的临时数组”）
    // begin() 和 end() 返回的是指向数组的指针，地址接近局部变量 i，说明数据在栈上
    int i = 0;
    cout << mylist.begin() << endl;  // 输出起始指针地址
    cout << mylist.end() << endl;    // 输出结束指针地址
    cout << &i << endl;              // 输出局部变量 i 的地址

    //3. {} 初始化的灵活性：支持任意数量值，语法统一
    // v1：显式调用 initializer_list 构造（传统写法）
    vector<int> v1(initializer_list<int>{1, 2, 3, 4, 5});
    // v2：省略 initializer_list，编译器自动转换（更简洁，推荐）
    vector<int> v2 = { 1,2,3,4,5 };
    // v3：const 引用绑定，延长临时 initializer_list 的生命周期
    const vector<int>& v3 = { 1,2,3,4,5 };

    //4. map 的 {} 初始化：结合 pair 和 initializer_list
    // 编译器自动将 {"sort", "排序"} 转为 pair<string, string>，再用 initializer_list 构造 map
    map<string, string> dict = { {"sort", "排序"}, {"string", "字符串"} };

    //5. initializer_list 版本的赋值操作
    v1 = { 10,20,30,40,50 };  // 直接用 {} 赋值，调用 vector 的 operator=(initializer_list<int>)

    return 0;
}

#include <initializer_list>

class MyClass 
{
public:
    MyClass(std::initializer_list<int> list) 
    {
        for (auto it = list.begin(); it != list.end(); ++it) 
        {
            // 处理列表中的元素
        }
    }
};


MyClass obj = {1, 2, 3};  // 调用MyClass(std::initializer_list<int>)构造函数

#include<iostream>
#include<vector>
using namespace std;

// 定义一个结构体 Point，用于表示简单的二维点坐标
struct Point
{
    int _x;  
    int _y;  
};

// 定义一个类 Date，用于表示日期
class Date
{
public:
    // 日期类的构造函数，带默认参数，若创建对象时不传入参数，将使用默认值（年、月、日都为 1）
    Date(int year = 1, int month = 1, int day = 1)
        // 使用成员初始化列表初始化类的成员变量
        : _year(year)
        , _month(month)
        , _day(day)
    {
        cout << "Date(int year, int month, int day)" << endl;
    }

    // 日期类的拷贝构造函数，用于根据已有的 Date 对象创建新的 Date 对象
    Date(const Date& d)
        // 使用成员初始化列表，用传入的对象 d 的成员变量来初始化当前对象的成员变量
        : _year(d._year)
        , _month(d._month)
        , _day(d._day)
    {
        cout << "Date(const Date& d)" << endl;
    }

private:
    int _year; 
    int _month;
    int _day;   
};


int main()
{
    // ------ C++98 支持的初始化方式 ------
    int a1[] = { 1, 2, 3, 4, 5 };
    int a2[5] = { 0 };
    Point p = { 1, 2 };

    // ------ C++11 支持的初始化方式 ------
    // 内置类型支持 C++11 的列表初始化（可省略等号）
    int x1 = { 2 };

    // 自定义类型支持 C++11 的列表初始化
    cout << "\n-----------Date d1 = { 2025, 1, 1 };-----------" << endl;
    Date d1 = { 2025, 7, 25 };
    /*  注意事项：
    *        这里本质是用 { 2025, 1, 1 } 构造一个 Date 临时对象，
    *        临时对象再去拷贝构造 d1，不过编译器通常会优化，直接用 { 2025, 1, 1 } 直接构造初始化 d1
    */

    cout << "-----------const Date& d2 = { 2025, 7, 25 };-----------" << endl;
    const Date& d2 = { 2025, 7, 25 };
    /*  注意事项：
    *        这里 d2 引用的是用 { 2025, 7, 25 } 构造的临时对象
    *        因为是 const 引用，延长了临时对象的生命周期
    */


    // C++98 支持单参数构造函数的类型转换（隐式转换）
    cout << "\n-----------Date d3 = { 2025 };-----------" << endl;
    Date d3 = { 2025 }; //这里用 {2025} 构造 Date 对象 d3，调用的是带默认参数的构造函数（month 和 day 用默认值 1）

    cout << "-----------Date d4 = 2025;-----------" << endl;
    Date d4 = 2025;  //直接用整数 2025 创建 Date 对象 d4，同样 month 和 day 用默认值 1



    // 可以省略等号的列表初始化方式（C++11 特性）
    Point p1{ 1, 2 };
    int x2{ 2 };
    cout << "\n-----------Date d5{ 2025, 7, 25 };-----------" << endl;
    Date d5{ 2025, 7, 25 };
    cout << "-----------const Date& d6{ 2025, 7, 25 };-----------" << endl;
    const Date& d6{ 2025, 7, 25 };

    // 不支持的情况，只有列表初始化（用 {} ）时，才能省略等号，这种直接赋值的方式不符合列表初始化规则，会编译报错
    // Date d7 2025; 



    /*------------创建一个存储 Date 对象的 vector 容器 v------------*/
    //1.创建vector容器
    vector<Date> v;
    //2.预先预留足够空间（比如：要插入 3 个元素，就预留 3）
    v.reserve(3);

    /*------------将Date类型的对象添加到 vector 容器 v------------*/
    //1.将有名Date对象 d8 拷贝后添加到 vector 中
    cout << "\n将有名Date对象 d1 拷贝后添加到 vector 中" << endl;
    const Date& d8{ 2025, 1, 1 };
    v.push_back(d8);

    //2.将匿名Date对象（2025, 1, 1）添加到 vector 中
    cout << "\n将匿名Date对象（2025, 1, 1）添加到 vector 中" << endl;
    v.push_back(Date(2025, 1, 1));
    /* 注意事项：
    *     vector::push_back 的本质是 “把对象拷贝（或移动）到容器内部”
    *     即使传入的是临时对象，也会先构造临时对象，再拷贝到容器里（编译器可能优化，但基础逻辑要理解）
    */

    //3.比起有名对象和匿名对象传参，用列表初始化直接构造临时对象添加到 vector 中，写法更简洁，更有性价比
    cout << "\n用列表初始化直接构造临时对象添加到 vector 中" << endl;
    v.push_back({ 2025, 1, 1 });

    return 0;  
}

int num = 10; // num 是左值，它在内存中有固定的存储位置

int arr[5];
arr[2] = 3;   // arr[2] 是左值，代表数组中特定位置的元素

struct Point 
{
    int x;
    int y;
};
Point p;
p.x = 5;     // p.x 是左值，是结构体成员

int a = 5 + 3; // 5 + 3 是右值，计算出结果后，这个临时的加法结果在表达式结束后就不再存在

int func() 
{
    return 20;  // 返回值 20 是右值，函数返回后，这个临时值不再独立存在
}
int b = func(); 

#include<iostream>
using namespace std;

int main()
{
    // ================ 左值（lvalue）：可寻址、持久存在 ================
    // 以下的 p、b、c、*p、s、s[0] 都是左值示例

    //1. 指针 p 是左值（存储在栈上，有地址）
    int* p = new int(0);  // p 指向堆上的 int（值为 0）

    //2. 普通变量 b 是左值（存储在栈上，可修改）
    int b = 1;

    //3. const 修饰的变量 c 是左值（虽不可修改，但仍可寻址）
    const int c = b;

    //4. 解引用指针 *p 是左值（可修改堆上的值）
    *p = 10;  // 修改堆上 int 的值为 10

    //5. 字符串 s 是左值（std::string 对象，存储在栈上，内容在堆）
    string s("111111");

    //6. 数组元素 s[0] 是左值（可修改字符串的第一个字符）
    s[0] = 'x';  // 字符串变为 "x11111"

    // 验证左值可寻址：输出地址
    cout << &c << endl;          // 输出 const 左值 c 的地址
    cout << (void*)&s[0] << endl;// 输出字符串首字符的地址（s[0] 是左值）


    // ================ 右值（rvalue）：不可寻址、临时存在 ================
    // 以下的 10、x+y、fmin(x,y)、string("11111") 都是右值示例

    // 1. 字面量 10 是右值（临时值，无地址）
    10;

    // 2. 表达式 x + y 是右值（临时结果，无地址）
    x + y;

    // 3. 函数返回值 fmin(x,y) 是右值（临时结果，无地址）
    fmin(x, y);

    // 4. 临时对象 string("11111") 是右值（表达式结束后销毁）
    string("11111");

    // 尝试取右值地址（编译报错或行为未定义）
     cout << &10 << endl;          // 非法：字面量右值不可寻址
     cout << &(x+y) << endl;       // 非法：表达式右值不可寻址
     cout << &fmin(x, y) << endl;  // 非法：函数返回值右值不可寻址
     cout << &string("11111") << endl; // 非法：临时对象右值不可寻址


    return 0;
}

int x = 10;      // x 是左值
int& ref = x;    // 左值引用 ref 绑定到左值 x
ref = 20;        // 修改 ref 会影响 x（x 变为 20）

// int& invalid_ref = 10;  // 错误：左值引用不能直接绑定右值（字面量 10 是右值）
const int& const_ref = 10; // 合法：const 左值引用可以绑定右值（延长右值生命周期）

void func(const int& value) { /* ... */ }
func(10); // 合法：右值 10 被 const 左值引用接收

int&& rref = 10;  // 右值引用 rref 绑定到右值 10
rref = 20;        // 可修改右值引用（10 变为 20）

int x = 10;
// int&& invalid_rref = x;  // 错误：右值引用不能直接绑定左值 x
int&& valid_rref = std::move(x); // 合法：通过 std::move 将左值转为右值引用

template <class T> 
typename remove_reference<T>::type&& move (T&& arg) 
{
    // 强制类型转换：将 arg 转为右值引用返回
    return static_cast<typename remove_reference<T>::type&&>(arg);
}

void func(int&& rr) 
{
    //注意：rr 是右值引用，但作为变量，它是左值
    
    int& r = rr;    // 允许：左值引用绑左值（rr 是左值）
    int&& rr2 = rr; // 编译报错：右值引用不能直接绑左值（rr 是左值）
    
    //注意：变量有 “存储地址”（左值特征），即使它是右值引用类型。
}

#include<iostream>
using namespace std;

int main()
{
    // ================ 左值：可寻址的持久对象 ================

    int* p = new int(0);  // p 是左值（指针变量，存储在栈）
    int b = 1;            // b 是左值（普通变量，存储在栈）
    const int c = b;      // c 是左值（const 变量，虽不可修改，但可寻址）
    *p = 10;              // *p 是左值（解引用指针，修改堆内存）
    string s("111111");   // s 是左值（std::string 对象，存储在栈）
    s[0] = 'x';           // s[0] 是左值（数组元素，可修改字符串内容）
    double x = 1.1, y = 2.2;  // x、y 是左值


    // ================ 左值引用：给左值取别名 ================
    // 左值引用特征：只能绑定左值（非 const 时），修改引用会影响原对象

    int& r1 = b;          // r1 是左值引用，绑定左值 b
    int*& r2 = p;         // r2 是左值引用（指针的引用），绑定左值 p
    int& r3 = *p;         // r3 是左值引用，绑定左值 *p
    string& r4 = s;       // r4 是左值引用，绑定左值 s
    // char& r5 = s[0];    // 注意：s[0] 是 char（值类型），这里会编译报错！
    // 正确写法：若要绑定 s[0]，需用 const 或值拷贝
    char r5 = s[0];       // 改为值拷贝（s[0] 是 char，不是左值引用的合法目标）


    // ================ 右值引用：给右值取别名 ================

    int&& rr1 = 10;       // rr1 是右值引用，绑定右值 10（字面量）
    double&& rr2 = x + y; // rr2 是右值引用，绑定右值 x+y（表达式结果）
    double&& rr3 = fmin(x, y); // rr3 是右值引用，绑定右值 fmin 返回值
    string&& rr4 = string("11111"); // rr4 是右值引用，绑定右值临时对象


    // ================ 左值引用的特殊规则 ================
    // const 左值引用可以绑定右值（延长右值生命周期）

    const int& rx1 = 10;               // 合法：const 左值引用绑定右值 10
    const double& rx2 = x + y;         // 合法：const 左值引用绑定右值 x+y
    const double& rx3 = fmin(x, y);    // 合法：const 左值引用绑定右值 fmin 返回值
    const string& rx4 = string("11111"); // 合法：const 左值引用绑定右值临时对象

    // ================ 右值引用的特殊规则 ================
    // 右值引用不能直接绑定左值，但可通过 std::move 转换左值为右值引用

    int&& rrx1 = std::move(b);     // 合法：std::move(b) 将左值 b 转为右值引用
    int*&& rrx2 = std::move(p);    // 合法：std::move(p) 将左值 p 转为右值引用
    int&& rrx3 = std::move(*p);    // 合法：std::move(*p) 将左值 *p 转为右值引用
    string&& rrx4 = std::move(s);  // 合法：std::move(s) 将左值 s 转为右值引用
    
    // 以下写法等价于 std::move(s)（C++11 支持直接强转右值引用）
    string&& rrx5 = (string&&)s;

    // ================ 变量表达式的属性：右值引用变量是左值 ================
    // 右值引用变量（如：rr1）本身是左值（有名字和地址）

    cout << &b << endl;    // 输出左值 b 的地址
    cout << &r1 << endl;   // 输出左值引用 r1 的地址（与 &b 相同）
    cout << &rr1 << endl;  // 输出右值引用 rr1 的地址（rr1 是左值）


    // ================ 右值引用的二次绑定：需用 std::move ================
    // 右值引用变量是左值，无法直接绑定新的右值引用，需用 std::move 转换

    int& r6 = rr1;          // 合法：左值引用绑定左值 rr1
    // int&& rrx6 = rr1;    // 错误：右值引用不能直接绑定左值 rr1
    int&& rrx6 = std::move(rr1); // 合法：std::move(rr1) 将左值 rr1 转为右值引用
    return 0;
}

#include <iostream>
#include <string>
using namespace std;

int main()
{
    // 1. 定义左值对象 s1
    std::string s1 = "Test";

    // 2. 右值引用直接绑定左值（错误演示）
    // std::string&& r1 = s1;  
    /* 注意事项：
    *      错误原因：右值引用（&&）的设计初衷是绑定右值（临时对象）
    *      直接绑定左值 s1 会编译报错，需用 std::move 转换左值为右值引用
    */


    /*--------------------“const左值引用”绑定临时对象（延长生命周期）--------------------*/
    const std::string& r2 = s1 + s1;
    /* 注意事项：
    *      原理：s1 + s1 是表达式产生的临时对象（右值）
    *      const左值引用可以绑定右值，并且会延长该临时对象的生命周期
    *      使其在 r2 的作用域内持续存在
    */

    // r2 += "Test";  
    // 错误原因：r2 是 const 左值引用，被 const 修饰的引用无法修改绑定对象的值。

    /*--------------------“右值引用”绑定临时对象（延长生命周期）--------------------*/
    std::string&& r3 = s1 + s1;
    /* 注意事项：
    *      原理：右值引用（&&）直接绑定临时对象（s1 + s1 的结果）
    *      同样会延长临时对象的生命周期，且右值引用本身未被 const 修饰时
    *      可以修改绑定对象的值
    */

    r3 += "Test"; //通过右值引用修改临时对象
    // 合法操作：r3 是非 const 的右值引用，可修改绑定的临时对象内容，这里会将 "Test" 追加到临时对象中。


    std::cout << r3 << '\n'; //输出修改后的结果（s1 + s1 是 "TestTest"，再追加 "Test" 后变为 "TestTestTest"）
    return 0;
}

#include<iostream>
using namespace std;

// 1. “非const左值引用”重载
//    匹配规则：接收普通左值（可修改的左值）
void f(int& x)
{
    std::cout << "左值引用重载 f(" << x << ")\n";
}

// 2. “const左值引用”重载
//    匹配规则：接收 const左值（只读的左值）
void f(const int& x)
{
    std::cout << "const左值引用重载 f(" << x << ")\n";
}

// 3. “右值引用”重载
//    匹配规则：接收右值（临时对象、字面量，或被 std::move 转换的左值）
void f(int&& x)
{
    std::cout << "右值引用重载 f(" << x << ")\n";
}

int main()
{
    // 定义普通左值和 const左值
    int i = 1;          // 普通左值（可修改）
    const int ci = 2;   // const 左值（只读）

    // ================ 实参匹配测试 ================
    f(i);   // 实参是【普通左值】→ 匹配 f(int&)
    f(ci);  // 实参是【const左值】→ 匹配 f(const int&)
    f(3);   // 实参是【右值】→ 匹配 f(int&&)
    // 若没有 f(int&&)，则会匹配 f(const int&)（C++98 兼容逻辑）

    f(std::move(i));    // 实参是【被 move 转换的左值（逻辑上变为右值）】→ 匹配 f(int&&)


    // ================ 右值引用的“左值属性”测试 ================
    int&& x = 1;        // x 是【右值引用变量】，但本身是左值（有名字、可寻址）
    f(x);               // 实参是【左值（右值引用变量）】→ 匹配 f(int&)

    f(std::move(x));    // 实参是【被 move 转换的右值引用变量（逻辑上变为右值）】→ 匹配 f(int&&)

    return 0;
}