怎样初始化结构体变量 聚合初始化与构造函数方法

struct Point {
    int x;
    int y;
};

Point p = {10, 20}; // 这就是聚合初始化，直观明了

struct Line {
    Point start;
    Point end;
};

Line l = {{0, 0}, {100, 100}}; // 嵌套的聚合初始化

struct Rectangle {
    int width;
    int height;

    // 默认构造函数
    Rectangle() : width(0), height(0) {
        // 可以在这里做一些额外的初始化工作
        // 比如打印日志，或者设置默认值
    }

    // 带参数的构造函数
    Rectangle(int w, int h) : width(w), height(h) {
        if (width < 0 || height < 0) {
            // 这就是构造函数能做的事：数据验证
            // 抛出异常或者修正数据
            width = 0;
            height = 0; // 简单处理为0，实际可能更复杂
        }
    }

    // 拷贝构造函数，当从另一个Rectangle创建时调用
    Rectangle(const Rectangle& other) : width(other.width), height(other.height) {
        // 可以在这里执行深拷贝逻辑，如果成员是指针或资源
    }
};

// 使用构造函数初始化
Rectangle r1; // 调用默认构造函数，width和height都是0
Rectangle r2(50, 30); // 调用带参数的构造函数
Rectangle r3(-10, 20); // 构造函数会处理非法输入，width变为0
Rectangle r4 = r2; // 调用拷贝构造函数

new

Rectangle

Rectangle()

Rectangle(int, int)

Rectangle r = {10, 20};

Point p = {20};

x

y

struct Person {
    std::string name;
    int age;
};

Person p = {.name = "Alice", .age = 30}; // C++20，非常清晰

Line l = {0, 0, 100, 100}; // 这种写法是合法的，它会根据成员类型自动匹配
                           // 相当于 Line l = {{0, 0}, {100, 100}};

#include <fstream>
#include <string>
#include <stdexcept> // 用于抛出异常

struct FileHandle {
    std::fstream file;
    std::string filename;

    // 构造函数：负责打开文件
    FileHandle(const std::string& name, std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out)
        : filename(name) { // 初始化成员
        file.open(filename, mode);
        if (!file.is_open()) {
            // 文件打开失败，这是典型的构造函数需要处理的错误情况
            // 可以抛出异常，或者设置一个错误状态
            throw std::runtime_error("Failed to open file: " + filename);
        }
        // 文件成功打开，此时FileHandle对象处于有效状态
    }

    // 析构函数：负责关闭文件，确保资源释放
    ~FileHandle() {
        if (file.is_open()) {
            file.close();
            // std::cout << "File " << filename << " closed." << std::endl; // 实际项目中可能不打印
        }
    }

    // 禁用拷贝构造和拷贝赋值，因为文件句柄通常不适合简单拷贝
    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;

    // 允许移动语义
    FileHandle(FileHandle&& other) noexcept
        : file(std::move(other.file)), filename(std::move(other.filename)) {
        // 确保源对象处于有效但未拥有资源的状态
    }
    FileHandle& operator=(FileHandle&& other) noexcept {
        if (this != &other) {
            if (file.is_open()) file.close(); // 关闭当前文件
            file = std::move(other.file);
            filename = std::move(other.filename);
        }
        return *this;
    }

    // 提供一个方法来检查文件是否有效
    bool isValid() const {
        return file.is_open();
    }
};

// 使用示例
try {
    FileHandle logFile("app.log", std::ios_base::app); // 尝试打开文件
    if (logFile.isValid()) {
        logFile.file << "Application started." << std::endl;
    }
} catch (const std::runtime_error& e) {
    // 捕获构造函数中抛出的异常
    std::cerr << "Error: " << e.what() << std::endl;
}

FileHandle

init_file_handle(FileHandle& fh, ...)

{}

// 避免 vexing parse:
// MyObject obj(); // 这被解析为函数声明，而非对象创建
// 使用统一初始化：
MyObject obj{}; // 明确创建对象并调用默认构造函数
MyObject obj{arg1, arg2}; // 调用带参数的构造函数

struct Product {
    std::string name = "Unnamed"; // 类内成员初始化
    double price = 0.0;
    int quantity = 1;

    // 如果没有提供name和price，它们会使用类内默认值
    Product(int q) : quantity(q) {}
    // 如果没有自定义构造函数，聚合初始化时也会优先使用类内默认值
};

Product p1; // name="Unnamed", price=0.0, quantity=1
Product p2(5); // name="Unnamed", price=0.0, quantity=5
Product p3{"Laptop", 1200.0, 2}; // 聚合初始化，覆盖默认值

struct Config {
    int max_threads;
    std::string log_file;
    bool debug_mode;
};

// C++20 指定初始化器，无需关心成员顺序
Config cfg = {.debug_mode = true, .log_file = "/var/log/app.log", .max_threads = 8};

std::unique_ptr

new

delete

// 假设有一个复杂的对象需要创建
class ComplexObject {
public:
    // 私有构造函数，强制通过工厂方法创建
    ComplexObject(int id, const std::string& data) : id_(id), data_(data) { /* ... */ }

    // 工厂方法
    static std::unique_ptr<ComplexObject> create(int id, const std::string& data) {
        // 可以在这里进行更复杂的验证或资源准备
        if (id < 0) {
            return nullptr; // 或者抛出异常
        }
        return std::make_unique<ComplexObject>(id, data);
    }
private:
    int id_;
    std::string data_;
};

// 使用工厂方法创建对象
auto obj = ComplexObject::create(10, "some_data");
if (obj) {
    // 对象成功创建
} else {
    // 创建失败
}