（三）C++对象内存模型那些事儿：特殊成员函数

#include <iostream>
#include <utility>

class Resource {
private:
    int* data;
    size_t size;

public:
    // 默认构造函数
    Resource() : data(nullptr), size(0) {
        std::cout << "Default constructor called" << std::endl;
    }

    // 带参数的构造函数
    explicit Resource(size_t n) : size(n) {
        data = new int[size];
        std::cout << "Parameterized constructor called" << std::endl;
    }

    // 析构函数
    ~Resource() {
        delete[] data;
        std::cout << "Destructor called" << std::endl;
    }

    // 拷贝构造函数
    Resource(const Resource& other) : size(other.size) {
        data = new int[size];
        std::copy(other.data, other.data + size, data);
        std::cout << "Copy constructor called" << std::endl;
    }

    // 拷贝赋值运算符
    Resource& operator=(const Resource& other) {
        if (this != &other) {  // 自赋值检查
            delete[] data;     // 释放原有资源
            size = other.size;
            data = new int[size];
            std::copy(other.data, other.data + size, data);
        }
        std::cout << "Copy assignment called" << std::endl;
        return *this;
    }

    // 移动构造函数
    Resource(Resource&& other) noexcept
        : data(other.data), size(other.size) {
        other.data = nullptr;  // 转移资源所有权
        other.size = 0;
        std::cout << "Move constructor called" << std::endl;
    }

    // 移动赋值运算符
    Resource& operator=(Resource&& other) noexcept {
        if (this != &other) {
            delete[] data;     // 释放原有资源
            data = other.data; // 转移资源所有权
            size = other.size;
            other.data = nullptr;
            other.size = 0;
        }
        std::cout << "Move assignment called" << std::endl;
        return *this;
    }

    // 辅助函数
    size_t getSize() const { return size; }
};

#include <iostream>

// 1. 成员对象没有默认构造函数
class NoDefaultCtor {
public:
    explicit NoDefaultCtor(int x) : value(x) {}
private:
    int value;
};

// 2. 基类没有默认构造函数
class BaseWithParam {
public:
    explicit BaseWithParam(int x) : baseValue(x) {}
private:
    int baseValue;
};

// 3. 含有const或引用成员
class SpecialMembers {
private:
    NoDefaultCtor member;        // 1. 成员没有默认构造函数
    const int constValue;        // 3. const成员
    int& refValue;               // 3. 引用成员

public:
    // 必须提供构造函数，编译器无法生成默认构造函数
    SpecialMembers(int x, int& ref)
        : member(x), constValue(42), refValue(ref) {}
};

class DerivedClass : public BaseWithParam {
public:
    // 2. 基类没有默认构造函数，必须显式调用基类构造函数
    DerivedClass(int x) : BaseWithParam(x) {}
};

// 4. 显式删除默认构造函数
class DeletedDefault {
public:
    DeletedDefault() = delete;
    explicit DeletedDefault(int x) : value(x) {}
private:
    int value;
};

// 5. 私有默认构造函数
class PrivateDefault {
private:
    PrivateDefault() = default;  // 外部无法访问
public:
    static PrivateDefault create() { return PrivateDefault(); }
};

C cObj;
    C::C()
        B::B()
            A::A()
                vptr = A::vftable;
                cout << "A::A()" << endl;
            // done A ctor
            vptr = B::vftable;
            cout << "B::B()" << endl;
        // done B ctor
        vptr = C::vftable;
        m_c = 11;
        cout << "C::C()" << endl;
    // done C ctor

#include <iostream>

class A {
public:
    A() {
        vptr = &A_vtable;  // 设置A的虚函数表指针
        std::cout << "A constructor" << std::endl;
        print();  // 调用A::print()
    }
    virtual void print() { std::cout << "A::print()" << std::endl; }
    virtual ~A() = default;
};

class B : public A {
public:
    B() {
        vptr = &B_vtable;  // 更新为B的虚函数表指针
        std::cout << "B constructor" << std::endl;
        print();  // 调用B::print()
    }
    void print() override { std::cout << "B::print()" << std::endl; }
};

class C : public B {
private:
    int m_c;
public:
    C() {
        vptr = &C_vtable;  // 更新为C的虚函数表指针
        m_c = 11;
        std::cout << "C constructor" << std::endl;
        print();  // 调用C::print()
    }
    void print() override { std::cout << "C::print()" << std::endl; }
};

// 使用示例
int main() {
    C obj;  // 输出：A constructor -> A::print() -> B constructor -> B::print() -> C constructor -> C::print()
    return 0;
}

#include <iostream>

class Member {
public:
    ~Member() { std::cout << "Member destructor" << std::endl; }
};

class Base {
public:
    virtual ~Base() { std::cout << "Base destructor" << std::endl; }
};

class Derived : public Base {
private:
    Member member1;
    Member member2;

public:
    // 编译器生成的析构函数等价于：
    ~Derived() {
        // 1. 用户代码（如果有）
        std::cout << "Derived destructor" << std::endl;

        // 2. 按声明的逆序析构成员变量
        // member2.~Member();  // 后声明的先析构
        // member1.~Member();

        // 3. 调用基类析构函数
        // Base::~Base();
    }
};

int main() {
    {
        Derived obj;
    }  // 析构顺序：Derived -> member2 -> member1 -> Base
    return 0;
}

#include <iostream>
#include <memory>

class Base {
public:
    virtual ~Base() {  // 虚析构函数确保正确的多态析构
        std::cout << "Base destructor" << std::endl;
    }
};

class Derived : public Base {
private:
    int* data;

public:
    Derived() : data(new int[100]) {
        std::cout << "Derived constructor" << std::endl;
    }

    ~Derived() override {
        delete[] data;
        std::cout << "Derived destructor" << std::endl;
    }
};

void polymorphicDestruction() {
    Base* ptr = new Derived();
    delete ptr;  // 正确调用：Derived析构 -> Base析构

    // 如果Base的析构函数不是虚函数，只会调用Base析构函数
    // 导致Derived的资源泄露
}

int main() {
    polymorphicDestruction();
    return 0;
}

#include <iostream>

// 编译器会生成默认拷贝构造函数的情况
class SimpleCopyable {
private:
    int value;
    double data;

public:
    SimpleCopyable(int v, double d) : value(v), data(d) {}
    // 编译器自动生成：SimpleCopyable(const SimpleCopyable& other) = default;
};

// 编译器不会生成默认拷贝构造函数的情况
class NonCopyable {
private:
    std::unique_ptr<int> ptr;  // unique_ptr不可拷贝
    const int constValue;      // const成员
    int& refValue;             // 引用成员

public:
    NonCopyable(int& ref) : ptr(std::make_unique<int>(42)), constValue(100), refValue(ref) {}

    // 必须显式定义或删除拷贝构造函数
    NonCopyable(const NonCopyable&) = delete;
};

#include <iostream>

class Trackable {
public:
    Trackable() { std::cout << "Default constructor" << std::endl; }
    Trackable(const Trackable&) { std::cout << "Copy constructor" << std::endl; }
    ~Trackable() { std::cout << "Destructor" << std::endl; }
};

Trackable createObject() {
    Trackable local;
    return local;  // 可能触发拷贝构造（取决于编译器优化）
}

void processObject(Trackable obj) {  // 参数传递时调用拷贝构造
    // 函数体
}

int main() {
    std::cout << "=== 直接初始化 ===" << std::endl;
    Trackable obj1;

    std::cout << "=== 拷贝初始化 ===" << std::endl;
    Trackable obj2 = obj1;  // 调用拷贝构造函数

    std::cout << "=== 函数参数传递 ===" << std::endl;
    processObject(obj1);    // 调用拷贝构造函数

    std::cout << "=== 函数返回值 ===" << std::endl;
    Trackable obj3 = createObject();  // 可能调用拷贝构造函数

    return 0;
}

// 错误的拷贝构造函数声明
class Wrong {
public:
    Wrong(Wrong other);  // 会导致无限递归！
    // 调用此构造函数需要先拷贝参数other，又会调用拷贝构造函数...
};

// 正确的拷贝构造函数声明
class Correct {
public:
    Correct(const Correct& other);  // const引用避免递归，提高效率

    // const引用的优势：
    // 1. 无性能开销（不需要拷贝参数）
    // 2. 避免无限递归
    // 3. 可以接受临时对象
    // 4. 可以接受const对象
};

#include <iostream>
#include <memory>

// 编译器会生成移动构造函数
class AutoMovable {
private:
    std::unique_ptr<int> ptr;
    std::string name;

public:
    AutoMovable(int value, const std::string& n)
        : ptr(std::make_unique<int>(value)), name(n) {}

    // 编译器自动生成移动构造函数和移动赋值运算符
    // AutoMovable(AutoMovable&&) = default;
    // AutoMovable& operator=(AutoMovable&&) = default;
};

// 编译器不会生成移动构造函数（因为定义了析构函数）
class ManualMovable {
private:
    int* data;
    size_t size;

public:
    explicit ManualMovable(size_t n) : size(n), data(new int[size]) {}

    // 定义了析构函数，编译器不会生成移动构造函数
    ~ManualMovable() { delete[] data; }

    // 需要手动定义移动构造函数
    ManualMovable(ManualMovable&& other) noexcept
        : data(other.data), size(other.size) {
        other.data = nullptr;
        other.size = 0;
    }

    ManualMovable& operator=(ManualMovable&& other) noexcept {
        if (this != &other) {
            delete[] data;
            data = other.data;
            size = other.size;
            other.data = nullptr;
            other.size = 0;
        }
        return *this;
    }
};

#include <iostream>
#include <vector>

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

public:
    ResourceHolder(const std::string& n) : name(n) {
        data.resize(1000000);  // 大量数据
        std::cout << "Constructor: " << name << std::endl;
    }

    // 拷贝构造：复制资源（开销大）
    ResourceHolder(const ResourceHolder& other)
        : data(other.data), name(other.name + "_copy") {
        std::cout << "Copy constructor: " << name << std::endl;
    }

    // 移动构造：转移资源所有权（开销小）
    ResourceHolder(ResourceHolder&& other) noexcept
        : data(std::move(other.data)), name(std::move(other.name)) {
        name += "_moved";
        std::cout << "Move constructor: " << name << std::endl;
    }

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

ResourceHolder createResource() {
    return ResourceHolder("temp");  // 返回时可能触发移动构造
}

int main() {
    std::cout << "=== 移动构造示例 ===" << std::endl;
    ResourceHolder res1 = createResource();

    std::cout << "=== 拷贝vs移动对比 ===" << std::endl;
    ResourceHolder res2 = res1;                    // 拷贝构造
    ResourceHolder res3 = std::move(res1);         // 移动构造

    std::cout << "res2: " << res2.getName() << std::endl;
    std::cout << "res3: " << res3.getName() << std::endl;

    return 0;
}

#include <vector>
#include <iostream>

class ThrowingMove {
public:
    ThrowingMove() = default;

    // 移动构造函数可能抛异常
    ThrowingMove(ThrowingMove&& other) {
        // 可能抛出异常的操作
        if (/* 某些条件 */ false) {
            throw std::runtime_error("Move failed");
        }
    }
};

class NoThrowMove {
public:
    NoThrowMove() = default;

    // 移动构造函数保证不抛异常
    NoThrowMove(NoThrowMove&& other) noexcept {
        // 安全的移动操作，不会抛异常
    }
};

void demonstrateVectorBehavior() {
    std::vector<ThrowingMove> vec1;
    vec1.reserve(2);
    vec1.emplace_back();
    vec1.emplace_back();

    // 容量不足时扩容：由于移动构造函数可能抛异常，
    // vector会选择拷贝而非移动来保证异常安全
    vec1.emplace_back();  // 使用拷贝构造函数

    std::vector<NoThrowMove> vec2;
    vec2.reserve(2);
    vec2.emplace_back();
    vec2.emplace_back();

    // 容量不足时扩容：由于移动构造函数标记为noexcept，
    // vector会选择移动来提高性能
    vec2.emplace_back();  // 使用移动构造函数
}

#include <iostream>

class RequiredInitList {
private:
    const int constMember;           // 1. const成员
    int& refMember;                  // 2. 引用成员
    std::string stringMember;        // 3. 有参构造函数的类成员

public:
    // 必须使用初始化列表
    RequiredInitList(int value, int& ref, const std::string& str)
        : constMember(value)         // const成员必须初始化
        , refMember(ref)             // 引用成员必须初始化
        , stringMember(str)          // 避免默认构造+赋值的开销
    {
        // 构造函数体：所有成员已经初始化完成
        std::cout << "Constructor body executed" << std::endl;
    }
};

class BaseWithParam {
public:
    explicit BaseWithParam(int x) : value(x) {}
private:
    int value;
};

class DerivedClass : public BaseWithParam {
public:
    // 4. 基类需要参数时必须在初始化列表中调用
    DerivedClass(int baseValue, int derivedValue)
        : BaseWithParam(baseValue)   // 必须显式调用基类构造函数
        , derivedMember(derivedValue)
    {}

private:
    int derivedMember;
};

#include <iostream>

class ExpensiveClass {
public:
    ExpensiveClass() {
        std::cout << "ExpensiveClass default constructor" << std::endl;
    }

    ExpensiveClass(int value) {
        std::cout << "ExpensiveClass parameterized constructor: " << value << std::endl;
    }

    ExpensiveClass(const ExpensiveClass& other) {
        std::cout << "ExpensiveClass copy constructor" << std::endl;
    }

    ExpensiveClass& operator=(const ExpensiveClass& other) {
        std::cout << "ExpensiveClass assignment operator" << std::endl;
        return *this;
    }
};

class InitializationDemo {
private:
    int member1;
    ExpensiveClass member2;  // 注意：声明顺序决定初始化顺序
    int member3;

public:
    // 推荐：使用初始化列表
    InitializationDemo(int a, int b, int c)
        : member3(c)        // 尽管在初始化列表中写在前面
        , member1(a)        // 但实际初始化顺序仍按声明顺序
        , member2(b)        // 直接调用带参构造函数
    {
        std::cout << "Constructor body" << stdendl;
    }

    // 不推荐：在构造函数体中赋值
    /*
    InitializationDemo(int a, int b, int c) {
        // member2首先被默认构造，然后赋值
        // 这样会调用默认构造函数 + 赋值运算符，效率低
        member1 = a;
        member2 = ExpensiveClass(b);  // 创建临时对象并赋值
        member3 = c;
    }
    */
};

int main() {
    std::cout << "=== 使用初始化列表 ===" << std::endl;
    InitializationDemo obj(1, 42, 3);

    // 输出顺序（按声明顺序）：
    // ExpensiveClass parameterized constructor: 42
    // Constructor body

    return 0;
}

#include <iostream>

class MyClass {
private:
    int data;

public:
    MyClass(int value) : data(value) {}

    // 非静态成员函数
    void memberFunction(int param) {
        data += param;  // 实际上是 this->data += param;
        std::cout << "Member function called, data = " << data << std::endl;
    }

    // 静态成员函数
    static void staticFunction(int param) {
        // 没有this指针，无法访问非静态成员
        std::cout << "Static function called with param = " << param << std::endl;
    }
};

// 编译器将成员函数转换为类似这样的形式：
void MyClass_memberFunction(MyClass* this, int param) {
    this->data += param;
    std::cout << "Member function called, data = " << this->data << std::endl;
}

int main() {
    MyClass obj(10);

    // 成员函数调用
    obj.memberFunction(5);  // 编译器转换为 MyClass_memberFunction(&obj, 5);

    // 静态函数调用
    MyClass::staticFunction(20);  // 直接调用，无需对象实例

    return 0;
}

#include <iostream>

class Base {
public:
    virtual void virtualFunc() {
        std::cout << "Base::virtualFunc()" << std::endl;
    }

    void normalFunc() {
        std::cout << "Base::normalFunc()" << std::endl;
    }

    virtual ~Base() = default;
};

class Derived : public Base {
public:
    void virtualFunc() override {
        std::cout << "Derived::virtualFunc()" << std::endl;
    }

    void normalFunc() {  // 这不是重写，而是隐藏
        std::cout << "Derived::normalFunc()" << std::endl;
    }
};

void demonstrateVirtualCall(Base& obj) {
    // 虚函数调用：运行时确定调用哪个版本
    obj.virtualFunc();  // 根据对象实际类型调用相应版本

    // 普通函数调用：编译时确定
    obj.normalFunc();   // 总是调用Base::normalFunc()
}

int main() {
    Derived derivedObj;

    std::cout << "=== 直接调用 ===" << std::endl;
    derivedObj.virtualFunc();  // Derived::virtualFunc()
    derivedObj.normalFunc();   // Derived::normalFunc()

    std::cout << "=== 通过基类引用调用 ===" << std::endl;
    demonstrateVirtualCall(derivedObj);
    // 输出：
    // Derived::virtualFunc() （动态绑定）
    // Base::normalFunc()     （静态绑定）

    return 0;
}

#include <iostream>

class CopyMoveDemo {
private:
    std::string data;

public:
    CopyMoveDemo(const std::string& str) : data(str) {}

    // 拷贝构造：保留原对象
    CopyMoveDemo(const CopyMoveDemo& other) : data(other.data) {
        std::cout << "Copy constructor: " << data << std::endl;
    }

    // 移动构造：转移资源
    CopyMoveDemo(CopyMoveDemo&& other) noexcept : data(std::move(other.data)) {
        std::cout << "Move constructor: " << data << std::endl;
    }

    const std::string& getData() const { return data; }
};

void demonstrateCopyVsMove() {
    CopyMoveDemo original("Hello");

    // 拷贝：original保持不变
    CopyMoveDemo copy = original;
    std::cout << "Original after copy: " << original.getData() << std::endl;
    std::cout << "Copy: " << copy.getData() << std::endl;

    // 移动：original被"掏空"
    CopyMoveDemo moved = std::move(original);
    std::cout << "Original after move: " << original.getData() << std::endl;
    std::cout << "Moved: " << moved.getData() << std::endl;
}

#include <iostream>

class Base {
private:
    std::string baseName;

public:
    Base(const std::string& name) : baseName(name) {
        std::cout << "Base constructor: " << baseName << std::endl;
    }

    Base(const Base& other) : baseName(other.baseName) {
        std::cout << "Base copy constructor: " << baseName << std::endl;
    }

    Base(Base&& other) noexcept : baseName(std::move(other.baseName)) {
        std::cout << "Base move constructor: " << baseName << std::endl;
    }

    virtual ~Base() {
        std::cout << "Base destructor: " << baseName << std::endl;
    }

    Base& operator=(const Base& other) {
        if (this != &other) {
            baseName = other.baseName;
            std::cout << "Base copy assignment: " << baseName << std::endl;
        }
        return *this;
    }

    Base& operator=(Base&& other) noexcept {
        if (this != &other) {
            baseName = std::move(other.baseName);
            std::cout << "Base move assignment: " << baseName << std::endl;
        }
        return *this;
    }
};

class Derived : public Base {
private:
    std::string derivedName;

public:
    Derived(const std::string& base, const std::string& derived)
        : Base(base), derivedName(derived) {
        std::cout << "Derived constructor: " << derivedName << std::endl;
    }

    // 拷贝构造：必须显式调用基类拷贝构造
    Derived(const Derived& other)
        : Base(other), derivedName(other.derivedName) {
        std::cout << "Derived copy constructor: " << derivedName << std::endl;
    }

    // 移动构造：必须显式调用基类移动构造
    Derived(Derived&& other) noexcept
        : Base(std::move(other)), derivedName(std::move(other.derivedName)) {
        std::cout << "Derived move constructor: " << derivedName << std::endl;
    }

    ~Derived() override {
        std::cout << "Derived destructor: " << derivedName << std::endl;
    }

    // 拷贝赋值：必须调用基类拷贝赋值
    Derived& operator=(const Derived& other) {
        if (this != &other) {
            Base::operator=(other);  // 调用基类拷贝赋值
            derivedName = other.derivedName;
            std::cout << "Derived copy assignment: " << derivedName << std::endl;
        }
        return *this;
    }

    // 移动赋值：必须调用基类移动赋值
    Derived& operator=(Derived&& other) noexcept {
        if (this != &other) {
            Base::operator=(std::move(other));  // 调用基类移动赋值
            derivedName = std::move(other.derivedName);
            std::cout << "Derived move assignment: " << derivedName << std::endl;
        }
        return *this;
    }
};

#include <iostream>
#include <memory>
#include <stdexcept>

// 问题示例：构造函数中的原始指针
class ProblematicClass {
private:
    int* ptr1;
    int* ptr2;

public:
    ProblematicClass() {
        ptr1 = new int(42);

        // 如果这里抛出异常，ptr1会泄露！
        if (/* 某些条件 */ false) {
            throw std::runtime_error("Construction failed");
        }

        ptr2 = new int(24);
    }

    ~ProblematicClass() {
        delete ptr1;
        delete ptr2;
    }
};

// 推荐方案1：智能指针
class SafeClass {
private:
    std::unique_ptr<int> ptr1;
    std::unique_ptr<int> ptr2;

public:
    SafeClass()
        : ptr1(std::make_unique<int>(42))
        , ptr2(std::make_unique<int>(24))
    {
        // 即使这里抛出异常，智能指针也会自动清理
        if (/* 某些条件 */ false) {
            throw std::runtime_error("Construction failed");
        }
    }

    // 无需显式析构函数，智能指针自动管理内存
};

// 推荐方案2：RAII包装
class RAIIClass {
private:
    int* ptr1;
    int* ptr2;

public:
    RAIIClass() : ptr1(nullptr), ptr2(nullptr) {
        try {
            ptr1 = new int(42);

            if (/* 某些条件 */ false) {
                throw std::runtime_error("Construction failed");
            }

            ptr2 = new int(24);
        } catch (...) {
            // 异常处理：清理已分配的资源
            delete ptr1;
            delete ptr2;
            throw;  // 重新抛出异常
        }
    }

    ~RAIIClass() {
        delete ptr1;
        delete ptr2;
    }
};

// Rule of Zero: 使用RAII，无需自定义特殊成员函数
class RuleOfZero {
private:
    std::unique_ptr<int> data;
    std::string name;
    std::vector<double> values;

public:
    RuleOfZero(const std::string& n) : name(n), data(std::make_unique<int>(42)) {}
    // 编译器自动生成所有特殊成员函数
};

// Rule of Three: 需要自定义析构函数时，通常也需要拷贝构造和拷贝赋值
class RuleOfThree {
private:
    int* data;
    size_t size;

public:
    explicit RuleOfThree(size_t n) : size(n), data(new int[size]) {}

    // 1. 析构函数
    ~RuleOfThree() { delete[] data; }

    // 2. 拷贝构造函数
    RuleOfThree(const RuleOfThree& other) : size(other.size), data(new int[size]) {
        std::copy(other.data, other.data + size, data);
    }

    // 3. 拷贝赋值运算符
    RuleOfThree& operator=(const RuleOfThree& other) {
        if (this != &other) {
            delete[] data;
            size = other.size;
            data = new int[size];
            std::copy(other.data, other.data + size, data);
        }
        return *this;
    }
};

// Rule of Five: C++11后，还需要考虑移动语义
class RuleOfFive {
private:
    int* data;
    size_t size;

public:
    explicit RuleOfFive(size_t n) : size(n), data(new int[size]) {}

    // 1. 析构函数
    ~RuleOfFive() { delete[] data; }

    // 2. 拷贝构造函数
    RuleOfFive(const RuleOfFive& other) : size(other.size), data(new int[size]) {
        std::copy(other.data, other.data + size, data);
    }

    // 3. 拷贝赋值运算符
    RuleOfFive& operator=(const RuleOfFive& other) {
        if (this != &other) {
            delete[] data;
            size = other.size;
            data = new int[size];
            std::copy(other.data, other.data + size, data);
        }
        return *this;
    }

    // 4. 移动构造函数
    RuleOfFive(RuleOfFive&& other) noexcept : data(other.data), size(other.size) {
        other.data = nullptr;
        other.size = 0;
    }

    // 5. 移动赋值运算符
    RuleOfFive& operator=(RuleOfFive&& other) noexcept {
        if (this != &other) {
            delete[] data;
            data = other.data;
            size = other.size;
            other.data = nullptr;
            other.size = 0;
        }
        return *this;
    }
};