【C/C++ 构造函数和析构函数可以重载吗？】

class MyClass {
public:
    // 重载的构造函数
    MyClass();                      // 默认构造函数
    MyClass(int value);             // 单参数构造函数
    MyClass(int a, double b);       // 多参数构造函数
    MyClass(const std::string& s);  // 不同类型参数
};

class MyClass {
public:
    ~MyClass();  // 唯一合法的析构函数声明
    
    // 以下都是错误的：
    // ~MyClass(int x); 
    // ~MyClass(const std::string&);
};

class File {
public:
    File();                             // 创建空文件
    File(const std::string& path);      // 通过路径打开
    File(const File& other);            // 拷贝构造（也是一种重载）
    File(File&& other) noexcept;        // 移动构造（C++11）
};

class Rectangle {
public:
    // 单个构造函数通过默认参数实现多种构造方式
    Rectangle(int w = 10, int h = 10) 
        : width(w), height(h) {}
};

class Employee {
public:
    Employee() : Employee("Unknown", 0) {}  // 委托给其他构造
    Employee(std::string name) : Employee(name, 0) {}
    Employee(std::string name, int id) 
        : name(name), id(id) {}
};

class Base {
public:
    virtual ~Base() = default;  // 基类虚析构
};

class Derived : public Base {
public:
    ~Derived() override;  // 只能有一个析构函数
};

Base* obj = new Derived();
delete obj;  // 必须能正确调用Derived的析构函数

class StringWrapper {
public:
    StringWrapper(const char* str);  // 单参数构造
};

void func(StringWrapper sw);

func("hello");  // 隐式转换：const char* → StringWrapper

explicit StringWrapper(const char* str);

class Base {
public:
    virtual ~Base() {}  // 虽然不能重载，但可以是虚函数
};