对象初始化与生命周期¶

class Clock {
public:
    int hour;
    int minute;
    int second;
};

Clock globalClock;        // 全局对象：hour=0, minute=0, second=0（自动初始化）

int main() {
    Clock localClock;     // 局部对象：hour, minute, second 未初始化（垃圾值）
    static Clock staticClock;  // 静态对象：hour=0, minute=0, second=0（自动初始化）
    return 0;
}

class Clock {
public:
    void show() const;
private:
    int hour {0};     // 默认值为 0
    int minute {0};   // 默认值为 0
    int second {0};   // 默认值为 0
};

int main() {
    Clock c1;         // hour=0, minute=0, second=0
    Clock c2;         // hour=0, minute=0, second=0
    // 每个对象都有一致的默认状态
    return 0;
}

class Clock {
public:
    Clock();                      // 默认构造函数
    Clock(int h, int m, int s);   // 带参数的构造函数
private:
    int hour, minute, second;
};

class Clock {
public:
    Clock(int h, int m, int s);   // 声明构造函数
private:
    int hour, minute, second;
};
// 实现：使用初始化列表
Clock::Clock(int h, int m, int s) 
: hour(h), minute(m), second(s) {
    // 初始化列表先于构造函数体执行
}
// 使用
Clock c1(8, 30, 0);     // 08:30:00
Clock c2(23, 59, 59);   // 23:59:59

class Clock {
public:
    Clock() = default;
    Clock(int h = 0, int m = 0, int s = 0);
private:
int hour, minute, second;
};

Clock::Clock(int h, int m, int s)
    : hour(0), minute(0), second(0) {
}

Clock c;     // 编译器无法区分具体要调用哪个构造函数

class Clock {
public:
    Clock(int h, int m, int s)
        : hour(0), minute(0), second(0) {   // 先设置为安全的默认值
        setTime(h, m, s);   // 复用 setTime 的检查逻辑
    }

    bool setTime(int h, int m, int s) {
        if (h < 0 || h >= 24) return false;
        if (m < 0 || m >= 60) return false;
        if (s < 0 || s >= 60) return false;
        hour = h;
        minute = m;
        second = s;
        return true;
    }
private:
    int hour, minute, second;
};

class Clock {
public:
    // 无参构造函数委托给带参构造函数
    Clock() : Clock(0, 0, 0) {}

    // 带参构造函数包含完整的初始化逻辑
    Clock(int h, int m, int s) : hour(h), minute(m), second(s) {}

private:
    int hour, minute, second;
};

int main() {
    Clock c1;                // 调用默认构造函数（无参）
    Clock c2(8, 30, 0);      // 调用带参构造函数

    // Clock c3();           // 错误！这不是对象定义，而是函数声明

    Clock c4 = Clock(14, 5, 30);  // 先构造临时对象，再拷贝给 c4（不推荐，实际可能被优化）

    return 0;
}

class Point {
public:
    // 普通构造函数
    Point(int x = 0, int y = 0) : x(x), y(y) {}

    // 复制构造函数
    Point(const Point& other) : x(other.x), y(other.y) {}

    void show() const {
        cout << "(" << x << ", " << y << ")";
    }
private:
    int x, y;
};

// 使用复制构造函数
Point p1(3, 4);
Point p2(p1);   // 调用复制构造函数，p2 成为 p1 的副本
p1.show();      // (3, 4)
p2.show();      // (3, 4)

Point p1(3, 4);
Point p2(p1);    // 调用复制构造函数
Point p3 = p1;   // 也调用复制构造函数（注意：这是初始化，不是赋值）

void printPoint(Point p) {   // 传值参数，实参拷贝给形参时调用复制构造函数
    p.show();
}

Point p1(3, 4);
printPoint(p1);   // 调用复制构造函数（实参 p1 拷贝到形参 p）

Point createPoint() {
    Point p(5, 6);
    return p;     // 返回时可能调用复制构造函数（实际可能被返回值优化 RVO 优化掉）
}

Point p2 = createPoint();   // 可能调用复制构造函数

class Point {
public:
    Point(int x = 0, int y = 0) : x(x), y(y) {}

    // 如果未明确定义复制构造函数，编译器自动生成缺省复制构造函数，等价于：
    // Point(const Point& other) : x(other.x), y(other.y) {}

private:
    int x, y;
};

Point p1(3, 4);
Point p2(p1);   // 调用编译器生成的缺省复制构造函数
                // p2.x = p1.x = 3, p2.y = p1.y = 4

class Clock {
public:
    Clock(int h, int m, int s) : hour(h), minute(m), second(s) {}

    // 缺省复制构造函数足够，逐字节复制三个 int 即可

private:
    int hour, minute, second;
};

Clock c1(8, 30, 0);
Clock c2(c1);   // c2 成为 c1 的独立副本

class UniqueFile {
public:
    UniqueFile(const string& filename);
    // 禁止复制构造
    UniqueFile(const UniqueFile&) = delete;
    // 禁止复制赋值
    UniqueFile& operator=(const UniqueFile&) = delete;
    ~UniqueFile();
private:
    FILE* handle;
};

UniqueFile f1("data.txt");
// UniqueFile f2(f1);   // 错误！复制构造函数被 delete
// UniqueFile f2 = f1;  // 错误！赋值操作符也被 delete

class Buffer {
public:
    Buffer(int size) : data(new int[size]), sz(size) {}

    // 移动构造函数
    Buffer(Buffer&& other) noexcept
        : data(other.data), sz(other.sz) {
        other.data = nullptr;   // 源对象不再拥有资源
        other.sz = 0;
    }

    ~Buffer() {
        delete[] data;   // data 为 nullptr 时 delete 是安全的
    }

private:
    int* data;
    int sz;
};

class FileGuard {
public:
    FileGuard(const string& filename) {
        file = fopen(filename.c_str(), "r");
    }

    ~FileGuard() {   // 析构函数
        if (file) {
            fclose(file);
            cout << "File closed automatically" << endl;
        }
    }

private:
    FILE* file;
};

// 使用
void processData() {
    FileGuard fg("data.txt");
    // ... 处理文件数据
}   // fg 离开作用域，析构函数自动调用，文件被关闭

class Point {
public:
    Point(int x = 0, int y = 0) : x(x), y(y) {}

    // 编译器自动生成缺省析构函数，等价于：
    // ~Point() {}

private:
    int x, y;
};

void func() {
    Point p(3, 4);
    // p 离开作用域时，调用编译器生成的缺省析构函数
    // 对于基本类型 int，析构函数体为空，不需要做任何清理
}

class Student {
public:
    Student(string name, string id) : name(name), id(id) {}
    // 缺省析构函数足够，string 的析构函数会自动释放内部内存
private:
    string name;
    string id;
};

void func() {
    Student s("张三", "2024001");
    // s 离开作用域时，缺省析构函数自动调用 name 和 id 的析构函数
    // string 的析构函数会自动释放其管理的字符数组内存
}

class Buffer {
public:
    Buffer(int size) : data(new int[size]), sz(size) {}

    ~Buffer() {   // 自定义析构函数
        delete[] data;
        cout << "Buffer memory released" << endl;
    }

private:
    int* data;
    int sz;
};

void func() {
    Buffer b(10);
    // ... 使用 b
}   // b 离开作用域，自定义析构函数自动调用，释放 data 指向的内存

class FileGuard {
public:
    FileGuard(const string& filename) {
        file = fopen(filename.c_str(), "r");
        if (!file) {
            throw runtime_error("Cannot open file");
        }
    }

    ~FileGuard() {   // 自定义析构函数
        if (file) {
            fclose(file);
            cout << "File closed automatically" << endl;
        }
    }

private:
    FILE* file;
};