C++自定义类型数组初始化与操作方法

struct

class

class MyObject {
public:
    int id;
    std::string name;

    MyObject() : id(0), name("Default") {
        // std::cout << "MyObject default constructed." << std::endl;
    }

    MyObject(int i, const std::string& n) : id(i), name(n) {
        // std::cout << "MyObject(" << id << ", " << name << ") constructed." << std::endl;
    }

    // 假设还有其他成员函数和析构函数
    ~MyObject() {
        // std::cout << "MyObject " << id << " destructed." << std::endl;
    }
};

void staticArrayExample() {
    // 1. 默认初始化：所有元素调用默认构造函数
    MyObject objects1[3]; // objects1[0], objects1[1], objects1[2] 都会是 MyObject(0, "Default")

    // 2. 列表初始化：可以为部分或全部元素提供构造参数
    MyObject objects2[3] = {
        MyObject(1, "Alpha"),
        {2, "Beta"} // C++11 允许省略类型名
    }; // objects2[0]是(1, "Alpha"), objects2[1]是(2, "Beta"), objects2[2]会调用默认构造函数

    MyObject objects3[] = { // 数组大小可以自动推断
        {10, "Gamma"},
        {11, "Delta"},
        {12, "Epsilon"}
    };

    // 操作：通过索引访问
    std::cout << "objects2[0].name: " << objects2[0].name << std::endl;
    objects3[1].name = "Updated Delta";
    std::cout << "objects3[1].name: " << objects3[1].name << std::endl;
}

new[]

void dynamicArrayExample() {
    // 1. 使用 new[] 默认构造：要求 MyObject 有一个可访问的默认构造函数
    MyObject* dynamicObjects1 = new MyObject[5]; // 5个MyObject对象都会调用默认构造函数
    // ... 操作 dynamicObjects1
    dynamicObjects1[0].id = 100;
    dynamicObjects1[0].name = "Dynamic One";

    // 2. C++11 列表初始化动态数组：可以在 new[] 后直接跟初始化列表
    // 注意：这种方式通常用于已知固定数量的元素，并且可以提供所有构造参数的情况
    MyObject* dynamicObjects2 = new MyObject[3]{
        {1, "Foo"},
        {2, "Bar"},
        {3, "Baz"}
    };
    // 如果列表元素少于数组大小，剩余的会默认构造
    // 如果列表元素多于数组大小，编译错误

    // 3. 循环手动构造（当没有默认构造函数或需要自定义每个元素的构造参数时，不推荐直接用 new[]）
    // 这种场景下，通常会选择 std::vector，因为它能更好地管理内存和对象生命周期。
    // 如果非要用原生指针，那可能需要先分配裸内存，再用 placement new，但这超出了日常使用的范畴。
    // 或者，最常见的做法是，分配后，再循环赋值（如果自定义类型支持赋值操作）。

    // 操作：同样通过索引访问
    std::cout << "dynamicObjects2[1].name: " << dynamicObjects2[1].name << std::endl;

    // 释放内存：必须使用 delete[]，否则会导致内存泄漏和未定义行为
    delete[] dynamicObjects1;
    delete[] dynamicObjects2;
    dynamicObjects1 = nullptr; // 良好的编程习惯
    dynamicObjects2 = nullptr;
}

std::vector<MyObject>

MyObject objects[5];

MyObject* dynamicObjects = new MyObject[5];

MyObject

new MyObject[N]

delete[] dynamicObjects;

delete dynamicObjects;

new[]

delete

new MyObject[N]

N

new MyObject[N](arg1, arg2)

new[]

std::vector

std::vector

std::vector

std::vector

new[]

delete[]

delete[]

std::vector

std::vector

push_back

emplace_back

resize

std::vector

size()

empty()

clear()

at()

begin()

end()

std::sort

std::find

std::vector

at()

std::out_of_range

std::vector

MyObject objects[N];

new MyObject[N];

class MyObjectWithoutDefault {
public:
    int value;
    // 没有默认构造函数
    MyObjectWithoutDefault(int v) : value(v) {
        // std::cout << "MyObjectWithoutDefault(" << value << ") constructed." << std::endl;
    }
    ~MyObjectWithoutDefault() {
        // std::cout << "MyObjectWithoutDefault(" << value << ") destructed." << std::endl;
    }
};

void staticArrayNoDefaultCtor() {
    // 必须提供所有元素的初始化参数
    MyObjectWithoutDefault arr1[3] = {
        MyObjectWithoutDefault(10),
        {20}, // C++11 允许省略类型名
        MyObjectWithoutDefault(30)
    };

    // 错误：MyObjectWithoutDefault arr2[3]; // 编译错误，没有默认构造函数
    // 错误：MyObjectWithoutDefault arr3[3] = { {1}, {2} }; // 编译错误，剩余元素无法默认构造
}

std::vector

std::vector

void dynamicArrayNoDefaultCtorWithVector() {
    // 1. 预留空间后，使用 emplace_back 或 push_back 逐个添加
    std::vector<MyObjectWithoutDefault> vec1;
    vec1.reserve(3); // 预留空间，避免频繁重新分配
    vec1.emplace_back(100); // 直接在vector内部构造
    vec1.emplace_back(200);
    vec1.push_back(MyObjectWithoutDefault(300)); // 也可以这样，但 emplace_back 效率更高

    // 2. C++11 列表初始化 vector
    std::vector<MyObjectWithoutDefault> vec2 = {
        {400},
        MyObjectWithoutDefault(500),
        {600}
    };

    // 3. 使用带有构造函数参数的初始化器列表（C++11）
    // 对于 new[] 动态数组，C++11 允许在 new[] 后面直接跟初始化列表
    // 但这仍然要求你提供所有元素的初始化参数，且数量必须与数组大小匹配
    MyObjectWithoutDefault* dynamicArr = new MyObjectWithoutDefault[2]{
        {700},
        {800}
    };
    // 如果是 new MyObjectWithoutDefault[2]{{700}}; 则编译错误，因为第二个元素无法默认构造。

    // ... 操作 vec1, vec2, dynamicArr

    delete[] dynamicArr;
}

std::vector

emplace_back