（二）C++对象内存模型那些事儿：类的继承和多态

#include <iostream>

class Calculator {
public:
    int add(int a, int b) {
        return a + b;
    }

    double add(double a, double b) {
        return a + b;
    }

    int add(int a, int b, int c) {
        return a + b + c;
    }
};

int main() {
    Calculator calc;
    std::cout << calc.add(1, 2) << std::endl;        // 调用int版本
    std::cout << calc.add(1.5, 2.5) << std::endl;   // 调用double版本
    std::cout << calc.add(1, 2, 3) << std::endl;    // 调用三参数版本
    return 0;
}

#include <iostream>

template<typename T>
T getMax(T a, T b) {
    return (a > b) ? a : b;
}

template<typename T>
class Stack {
private:
    T data[100];
    int topIndex;

public:
    Stack() : topIndex(-1) {}

    void push(const T& value) {
        if (topIndex < 99) {
            data[++topIndex] = value;
        }
    }

    T pop() {
        if (topIndex >= 0) {
            return data[topIndex--];
        }
        throw std::runtime_error("Stack is empty");
    }
};

int main() {
    std::cout << getMax(10, 20) << std::endl;      // int版本
    std::cout << getMax(3.14, 2.71) << std::endl; // double版本

    Stack<int> intStack;
    intStack.push(42);
    std::cout << intStack.pop() << std::endl;
    return 0;
}

#include <iostream>
#include <memory>

class Shape {
public:
    virtual ~Shape() = default;  // 虚析构函数
    virtual void draw() const {
        std::cout << "Drawing a shape" << std::endl;
    }
    virtual double area() const = 0;  // 纯虚函数
};

class Circle : public Shape {
private:
    double radius;

public:
    Circle(double r) : radius(r) {}

    void draw() const override {
        std::cout << "Drawing a circle with radius " << radius << std::endl;
    }

    double area() const override {
        return 3.14159 * radius * radius;
    }
};

class Rectangle : public Shape {
private:
    double width, height;

public:
    Rectangle(double w, double h) : width(w), height(h) {}

    void draw() const override {
        std::cout << "Drawing a rectangle " << width << "x" << height << std::endl;
    }

    double area() const override {
        return width * height;
    }
};

void processShape(const Shape& shape) {
    shape.draw();  // 动态绑定
    std::cout << "Area: " << shape.area() << std::endl;
}

int main() {
    Circle circle(5.0);
    Rectangle rect(4.0, 6.0);

    processShape(circle);    // 调用Circle::draw()和Circle::area()
    processShape(rect);      // 调用Rectangle::draw()和Rectangle::area()

    // 通过指针的多态行为
    std::unique_ptr<Shape> shapePtr = std::make_unique<Circle>(3.0);
    shapePtr->draw();        // 调用Circle::draw()

    return 0;
}

#include <iostream>

class Animal {
public:
    Animal() { std::cout << "Animal constructor" << std::endl; }
    Animal(const Animal& other) {
        std::cout << "Animal copy constructor" << std::endl; }
    virtual void speak() { std::cout << "Animal speaks" << std::endl; }
};

class Dog : public Animal {
public:
    Dog() { std::cout << "Dog constructor" << std::endl; }
    void speak() override { std::cout << "Dog barks" << std::endl; }
};

int main() {
    // 1. 多态行为（通过指针和引用）
    Animal* animalPtr = new Dog();
    animalPtr->speak();  // 输出: Dog barks（动态绑定）

    Dog dog;
    Animal& animalRef = dog;
    animalRef.speak();   // 输出: Dog barks（动态绑定）

    // 2. 对象切片（Object Slicing）
    Animal animal = Dog();  // 发生对象切片
    animal.speak();         // 输出: Animal speaks（静态绑定）

    delete animalPtr;
    return 0;
}

/*
对象切片的原因：
1. Animal animal = Dog() 会调用Animal的拷贝构造函数
2. Dog对象被隐式转换为Animal对象，Dog特有的部分被"切掉"。
    因为dog在栈上申请内存的时候是按照Animal的大小申请的，dog的内存布局是按照Animal来的。

3. 这个过程中，包括虚函数指针也被切掉了，或者说虚函数指针也被重置为指向Animal的虚函数表（安全考虑）
4. 如果保留Dog的虚函数指针，这个时候子类的虚函数有可能是使用了子类特有的类成员变量的，可能导致访问Dog特有成员变量时出错
*/

class Base {
public:
    int baseData;
    void baseFunction() { /* ... */ }
};

class Derived : public Base {
public:
    int derivedData;
    void derivedFunction() { /* ... */ }
};

// Derived对象的内存布局：
// [baseData][derivedData]

#include <iostream>

class Animal {
public:
    virtual void makeSound() { std::cout << "Animal sound" << std::endl; }
    virtual ~Animal() = default;
};

class Dog : public Animal {
private:
    std::string breed;

public:
    Dog(const std::string& b) : breed(b) {}
    void makeSound() override {
        std::cout << "Woof! I'm a " << breed << std::endl;
    }
};

int main() {
    Dog dog("Golden Retriever");

    // 对象切片发生
    Animal animal = dog;  // Dog对象被切片为Animal对象
    animal.makeSound();   // 输出: Animal sound

    // 正确的多态调用
    Animal& animalRef = dog;
    animalRef.makeSound(); // 输出: Woof! I'm a Golden Retriever

    return 0;
}

#include <iostream>

class Flyable {
public:
    virtual void fly() { std::cout << "Flying" << std::endl; }
    virtual ~Flyable() = default;
};

class Swimmable {
public:
    virtual void swim() { std::cout << "Swimming" << std::endl; }
    virtual ~Swimmable() = default;
};

class Duck : public Flyable, public Swimmable {
public:
    void fly() override { std::cout << "Duck flying" << std::endl; }
    void swim() override { std::cout << "Duck swimming" << std::endl; }
};

int main() {
    Duck duck;

    // 多态调用，编译器能正确识别使用哪个vptr
    Flyable* flyPtr = &duck;
    flyPtr->fly();          // Duck flying

    Swimmable* swimPtr = &duck;
    swimPtr->swim();        // Duck swimming

    return 0;
}

// 不使用虚继承的菱形继承问题
class Animal {
public:
    int age;
    void eat() { /* ... */ }
};

class Mammal : public Animal {
public:
    bool warmBlooded = true;
};

class Bird : public Animal {
public:
    bool canFly = true;
};

class Bat : public Mammal, public Bird {
public:
    void echolocate() { /* ... */ }
};

int main() {
    Bat bat;
    // bat.age = 5;      // 编译错误：歧义，不知道访问哪个Animal::age
    bat.Mammal::age = 5; // 必须明确指定作用域
    bat.Bird::age = 3;   // 这是另一个Animal::age
    return 0;
}

class Animal {
public:
    int age;
    virtual void makeSound() = 0;
    virtual ~Animal() = default;
};

class Mammal : virtual public Animal {  // 虚继承
public:
    bool warmBlooded = true;
};

class Bird : virtual public Animal {    // 虚继承
public:
    bool canFly = true;
};

class Bat : public Mammal, public Bird {
public:
    void makeSound() override {
        std::cout << "Bat screeches" << std::endl;
    }
    void echolocate() { /* ... */ }
};

int main() {
    Bat bat;
    bat.age = 5;        // 正确：只有一个Animal::age
    bat.makeSound();    // 正确：调用Bat::makeSound()

    std::cout << "Age: " << bat.age << std::endl;
    std::cout << "Warm blooded: " << bat.warmBlooded << std::endl;
    std::cout << "Can fly: " << bat.canFly << std::endl;

    return 0;
}

// 性能对比示例
class TestClass {
public:
    void normalFunction() { /* 一些操作 */ }
    virtual void virtualFunction() { /* 相同的操作 */ }
};

// 典型性能差异：
// 普通函数调用：45-90ns
// 虚函数调用：90-180ns
// 额外考虑：分支预测和指令预取的影响

#include <iostream>
#include <typeinfo>

class Base {
public:
    virtual ~Base() = default;  // 多态类型
};

class NonPolymorphic {
public:
    int data;
};

int main() {
    Base* basePtr = new Base();
    NonPolymorphic nonPoly;

    // 多态类型：通过虚函数表获取类型信息
    std::cout << typeid(*basePtr).name() << std::endl;

    // 非多态类型：编译时确定类型信息
    std::cout << typeid(nonPoly).name() << std::endl;

    delete basePtr;
    return 0;
}

class A { virtual void f() {} };
class B { virtual void g() {} };
class C : public A, public B {};

int main() {
    C obj;
    C* cPtr = &obj;

    // static_cast会进行正确的指针调整
    A* aPtr = static_cast<A*>(cPtr);  // 安全转换
    B* bPtr = static_cast<B*>(cPtr);  // 需要指针调整

    // 危险的C风格转换（不推荐）
    B* bPtr2 = (B*)cPtr;  // 可能导致错误的指针值

    return 0;
}

#include <iostream>
#include <memory>
#include <vector>

// 抽象基类
class Document {
public:
    virtual ~Document() = default;
    virtual std::unique_ptr<Document> clone() const = 0;  // 虚拟拷贝构造函数
    virtual void print() const = 0;
};

// 具体文档类型
class TextDocument : public Document {
private:
    std::string content;

public:
    TextDocument(const std::string& text) : content(text) {}

    std::unique_ptr<Document> clone() const override {
        return std::make_unique<TextDocument>(*this);
    }

    void print() const override {
        std::cout << "Text: " << content << std::endl;
    }
};

class ImageDocument : public Document {
private:
    std::string filename;

public:
    ImageDocument(const std::string& file) : filename(file) {}

    std::unique_ptr<Document> clone() const override {
        return std::make_unique<ImageDocument>(*this);
    }

    void print() const override {
        std::cout << "Image: " << filename << std::endl;
    }
};

// 文档管理器
class DocumentManager {
private:
    std::vector<std::unique_ptr<Document>> documents;

public:
    void addDocument(std::unique_ptr<Document> doc) {
        documents.push_back(std::move(doc));
    }

    // 虚拟拷贝构造函数的应用
    DocumentManager(const DocumentManager& other) {
        for (const auto& doc : other.documents) {
            documents.push_back(doc->clone());  // 多态拷贝
        }
    }

    void printAll() const {
        for (const auto& doc : documents) {
            doc->print();
        }
    }
};

int main() {
    DocumentManager manager;
    manager.addDocument(std::make_unique<TextDocument>("Hello World"));
    manager.addDocument(std::make_unique<ImageDocument>("photo.jpg"));

    // 使用虚拟拷贝构造函数
    DocumentManager copy = manager;  // 调用拷贝构造函数

    std::cout << "Original:" << std::endl;
    manager.printAll();

    std::cout << "Copy:" << std::endl;
    copy.printAll();

    return 0;
}

// 内联优化的影响
class Example {
public:
    // 在头文件中定义，编译器可能内联
    inline void inlineFunction() { /* ... */ }

    // 在源文件中定义，一般不会内联
    void normalFunction();

    // 虚函数很难被内联（除非编译器能确定实际类型）
    virtual void virtualFunction() { /* ... */ }
};