C++自定义类型默认值和构造技巧

int

class MyClass {
public:
    int value;
    std::string name;

    // 显式默认构造函数
    MyClass() : value(0), name("default") { // 使用成员初始化列表
        // 构造函数体可以为空，或者做一些额外的设置
    }
};

:

const

= default

= delete

class AnotherClass {
public:
    int id;
    // 明确告诉编译器生成默认构造函数
    AnotherClass() = default; 

    // 阻止编译器生成默认构造函数（例如，当你要求所有对象必须通过特定参数构造时）
    // AnotherClass() = delete; 

    // 其他构造函数...
    AnotherClass(int _id) : id(_id) {}
};

= default

= delete

class YetAnotherClass {
public:
    int count = 10; // 类内成员初始化
    std::string label = "unknown";
    std::vector<int> data; // 默认构造
};

class Product {
public:
    std::string name;
    double price;
    int quantity;

    // 主构造函数
    Product(std::string n, double p, int q) : name(std::move(n)), price(p), quantity(q) {
        // 额外的逻辑，比如验证
        if (price < 0) price = 0;
        if (quantity < 0) quantity = 0;
    }

    // 委托构造函数：只提供名称和价格，数量默认为1
    Product(std::string n, double p) : Product(std::move(n), p, 1) {
        // 这里可以有额外的逻辑，但通常为空，避免重复初始化
    }

    // 委托构造函数：只提供名称，价格和数量都有默认值
    Product(std::string n) : Product(std::move(n), 0.0, 1) {}
};

MyClass()

= default

= delete

= default

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

    // 手动定义了一个带参数的构造函数
    Widget(int i, const std::string& n) : id(i), name(n) {}

    // 明确告诉编译器，请生成你的默认构造函数吧
    // 这样即使定义了其他构造函数，默认构造函数也依然存在
    Widget() = default; 
};

// Widget w1; // 现在可以了，会调用编译器生成的默认构造函数
// Widget w2(1, "test"); // 也可以

= default

= delete

class ForcefulObject {
public:
    int uniqueId;

    ForcefulObject(int id) : uniqueId(id) {}

    // 明确禁止默认构造
    ForcefulObject() = delete; 
};

// ForcefulObject obj1; // 编译错误！
// ForcefulObject obj2(123); // OK

= delete

class BadExample {
public:
    int value;
    const int const_value; // const成员

    BadExample(int v) {
        value = v; // 赋值
        // const_value = 10; // 错误！const成员不能被赋值
    }
};

value = v;

value

v

const_value

const

class GoodExample {
public:
    int value;
    const int const_value;
    std::string name; // 类类型成员
    std::vector<int>& ref_vec; // 引用成员

    // 注意：引用成员必须在初始化列表中初始化
    GoodExample(int v, int cv, const std::string& n, std::vector<int>& vec) 
        : value(v), const_value(cv), name(n), ref_vec(vec) {
        // 构造函数体
        // 此时所有成员都已完成初始化
    }
};

:

value(v)

const_value(cv)

std::vector

std::string

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

class ResourceHolder {
public:
    std::vector<int> data;
    std::string name;

    // 默认构造
    ResourceHolder() = default;

    // 构造函数
    ResourceHolder(int size, const std::string& n) : name(n) {
        data.resize(size);
        std::iota(data.begin(), data.end(), 0); // 填充数据
        std::cout << "普通构造: " << name << ", data size: " << data.size() << std::endl;
    }

    // 拷贝构造函数
    ResourceHolder(const ResourceHolder& other) 
        : data(other.data), name(other.name) { // 深拷贝
        std::cout << "拷贝构造: " << name << ", data size: " << data.size() << std::endl;
    }

    // 移动构造函数 (C++11)
    ResourceHolder(ResourceHolder&& other) noexcept // noexcept很重要
        : data(std::move(other.data)), name(std::move(other.name)) { // 资源“窃取”
        // 确保源对象处于有效但未指定状态
        // other.data.clear(); // 通常不需要手动清空，std::vector的移动构造会处理
        std::cout << "移动构造: " << name << ", data size: " << data.size() << std::endl;
    }

    // 拷贝赋值运算符
    ResourceHolder& operator=(const ResourceHolder& other) {
        if (this != &other) {
            data = other.data; // 深拷贝
            name = other.name;
        }
        std::cout << "拷贝赋值: " << name << ", data size: " << data.size() << std::endl;
        return *this;
    }

    // 移动赋值运算符 (C++11)
    ResourceHolder& operator=(ResourceHolder&& other) noexcept {
        if (this != &other) {
            data = std::move(other.data); // 资源“窃取”
            name = std::move(other.name);
            // other.data.clear(); // 同上，通常不需要
        }
        std::cout << "移动赋值: " << name << ", data size: " << data.size() << std::endl;
        return *this;
    }

    // 析构函数
    ~ResourceHolder() {
        // std::cout << "析构: " << name << std::endl;
    }
};

// 示例函数，返回一个ResourceHolder对象
ResourceHolder createAndReturnObject(int size, const std::string& n) {
    return ResourceHolder(size, n); // 这里会触发移动构造（RVO/NRVO优化后可能省略）
}

int main() {
    std::cout << "--- 场景1: 拷贝构造 ---" << std::endl;
    ResourceHolder r1(1000, "original");
    ResourceHolder r2 = r1; // 调用拷贝构造

    std::cout << "\n--- 场景2: 移动构造 ---" << std::endl;
    ResourceHolder r3 = createAndReturnObject(2000, "temp_object"); // RVO/NRVO优化，可能不调用移动构造，直接构造到r3
    // 如果没有RVO/NRVO，这里会发生移动构造

    std::cout << "\n--- 场景3: 显式移动 ---" << std::endl;
    ResourceHolder r4(3000, "source");
    ResourceHolder r5 = std::move(r4); // 强制调用移动构造
    std::cout << "r4.data size after move: " << r4.data.size() << std::endl; // r4现在处于有效但未指定状态，data可能为空

    std::cout << "\n--- 场景4: 移动赋值 ---" << std::endl;
    ResourceHolder r6(4000, "target_assign");
    ResourceHolder r7(5000, "source_assign");
    r6 = std::move(r7); // 调用移动赋值
    std::cout << "r7.data size after move assign: " << r7.data.size() << std::endl;

    return 0;
}

createAndReturnObject

std::move