构造函数与析构函数

class File {
public:
    File(const std::string& path);  // 构造函数：打开文件
    ~File();                        // 析构函数：关闭文件
};

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

class Course {
public:
    // 默认构造函数
    Course() : Course("未命名", 0, 0.0) {
        std::cout << "  [默认构造] " << name_ << std::endl;
    }

    // 主构造函数
    Course(std::string name, int credit, double hours)
        : name_(std::move(name)), credit_(credit), hours_(hours) {
        std::cout << "  [主构造] " << name_
                  << " (学分: " << credit_ << ", 课时: " << hours_ << ")" << std::endl;
        validate();
    }

    // 委托构造函数：只需名称，其他用默认值
    Course(std::string name) : Course(std::move(name), 3, 48.0) {}

    // 析构函数
    ~Course() {
        std::cout << "  [析构] " << name_ << std::endl;
    }

    const std::string& getName() const { return name_; }

private:
    void validate() const {
        if (name_.empty()) {
            throw std::invalid_argument("课程名称不能为空");
        }
    }

    std::string name_;
    int credit_;
    double hours_;
};

class Enrollment {
public:
    Enrollment(const std::string& student, const std::string& course)
        : student_(student), course_(course) {
        std::cout << "[选课] " << student_ << " 选了 " << course_.getName() << std::endl;
    }

    ~Enrollment() {
        std::cout << "[退课] " << student_ << " 退出 " << course_.getName() << std::endl;
    }

private:
    std::string student_;
    Course course_;  // 成员对象，构造/析构顺序由声明顺序决定
};

int main() {
    std::cout << "===== 构造函数演示 =====" << std::endl;

    {
        std::cout << "\n-- 创建 Course 对象 --" << std::endl;
        Course c1("高等数学", 5, 64.0);
        Course c2("线性代数");           // 委托构造
        Course c3;                      // 默认构造

        std::cout << "\n-- 作用域结束，对象销毁 --" << std::endl;
    }  // c3, c2, c1 逆序析构

    std::cout << "\n===== 析构顺序 =====" << std::endl;
    {
        Enrollment e("张三", "数据结构");
        // e 析构时先析构 course_，再析构 student_
    }

    return 0;
}

#include <iostream>
#include <string>

class PhoneNumber {
public:
    // 转换构造函数：string → PhoneNumber
    explicit PhoneNumber(const std::string& number) : number_(number) {
        std::cout << "  构造 PhoneNumber: " << number_ << std::endl;
    }

    const std::string& get() const { return number_; }

private:
    std::string number_;
};

class Contact {
public:
    Contact(const std::string& name, const PhoneNumber& phone)
        : name_(name), phone_(phone) {
        std::cout << "  创建联系人: " << name_ << " | "
                  << phone_.get() << std::endl;
    }

private:
    std::string name_;
    PhoneNumber phone_;
};

// 无 explicit 的危险版本
class BadPhoneNumber {
public:
    BadPhoneNumber(const std::string& number) : number_(number) {}

private:
    std::string number_;
};

void dial(const BadPhoneNumber& phone) {
    std::cout << "拨号中..." << std::endl;
}

int main() {
    std::cout << "===== explicit 保护 =====" << std::endl;

    // 必须显式构造 PhoneNumber
    Contact alice("张三", PhoneNumber("13800138000"));

    // 下面这行编译错误（explicit 阻止了隐式转换）
    // Contact bob("李四", "13900139000");

    // 没有 explicit 的话，下面的调用会悄然创建一个 BadPhoneNumber
    dial(std::string("110"));  // 隐式转换：string → BadPhoneNumber → dial

    // 对比：explicit 要求显式写出转换
    // PhoneNumber pn = "13800138000";  // 编译错误（explicit）

    return 0;
}