【C++特殊工具与技术】优化内存分配(六)：运行时类型识别

// 指针转换（失败返回nullptr）
Derived* d_ptr = dynamic_cast<Derived*>(base_ptr);

// 引用转换（失败抛出std::bad_cast）
Derived& d_ref = dynamic_cast<Derived&>(base_ref);

#include <iostream>
using namespace std;

class Base {
public:
    virtual void func() { cout << "Base::func()" << endl; } // 虚函数使类多态
};

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

int main() {
    Derived d;
    Base* base_ptr = &d;  // 隐式向上转换（安全）
    
    // dynamic_cast向上转换（等价于static_cast）
    Base* upcast_ptr = dynamic_cast<Base*>(base_ptr);
    upcast_ptr->func();  // 输出：Derived::func()（多态调用）
    return 0;
}

#include <iostream>
#include <typeinfo>
using namespace std;

class Animal {
public:
    virtual ~Animal() = default;  // 虚析构函数保证多态
    virtual void sound() const { cout << "Animal makes sound" << endl; }
};

class Dog : public Animal {
public:
    void sound() const override { cout << "Dog barks" << endl; }
    void wagTail() const { cout << "Dog wags tail" << endl; }
};

class Cat : public Animal {
public:
    void sound() const override { cout << "Cat meows" << endl; }
    void scratch() const { cout << "Cat scratches" << endl; }
};

void interactWithAnimal(Animal* animal) {
    // 尝试转换为Dog指针
    Dog* dog = dynamic_cast<Dog*>(animal);
    if (dog) {
        dog->sound();
        dog->wagTail();
        return;
    }

    // 尝试转换为Cat指针
    Cat* cat = dynamic_cast<Cat*>(animal);
    if (cat) {
        cat->sound();
        cat->scratch();
        return;
    }

    cout << "Unknown animal type" << endl;
}

int main() {
    Animal* animals[] = {new Dog(), new Cat(), new Animal()};
    
    for (auto animal : animals) {
        interactWithAnimal(animal);
        delete animal;  // 释放内存
    }
    return 0;
}

class A { public: virtual ~A() = default; };
class B : public A {};
class C : public A {};

void crosscastDemo() {
    B* b = new B();
    A* a = b;  // 向上转换
    
    // 尝试将A*转换为C*（交叉转换）
    C* c = dynamic_cast<C*>(a);  // 返回nullptr（因为a实际指向B对象）
    if (!c) {
        cout << "Crosscast from B to C failed" << endl;
    }
    delete b;
}

#include <iostream>
#include <typeinfo>
using namespace std;

void processAnimal(Animal& animal) {
    try {
        Dog& dog = dynamic_cast<Dog&>(animal);
        dog.wagTail();
    } catch (const bad_cast& e) {
        cout << "Not a Dog: " << e.what() << endl;
    }
}

int main() {
    Cat cat;
    processAnimal(cat);  // 尝试将Cat&转换为Dog&，触发异常
    return 0;
}

// 获取类型的type_info（编译时确定）
const type_info& ti1 = typeid(int);
const type_info& ti2 = typeid(Base);

// 获取表达式的type_info（运行时确定，仅当表达式是多态类型时）
const type_info& ti3 = typeid(*base_ptr);  // base_ptr是多态类型指针

#include <iostream>
#include <typeinfo>
using namespace std;

class NonPolyBase {};  // 非多态类（无虚函数）
class NonPolyDerived : public NonPolyBase {};

class PolyBase { public: virtual ~PolyBase() = default; };  // 多态类（有虚函数）
class PolyDerived : public PolyBase {};

int main() {
    // 非多态类型测试
    NonPolyBase* npb = new NonPolyDerived();
    cout << "Non-poly typeid(*npb): " << typeid(*npb).name() << endl;  // 输出NonPolyBase

    // 多态类型测试
    PolyBase* pb = new PolyDerived();
    cout << "Poly typeid(*pb): " << typeid(*pb).name() << endl;  // 输出PolyDerived

    delete npb;
    delete pb;
    return 0;
}

#include <iostream>
#include <typeinfo>
using namespace std;

void printTypeInfo(const Animal& animal) {
    const type_info& ti = typeid(animal);
    cout << "Type name: " << ti.name() << endl;
    
    if (ti == typeid(Dog)) {
        cout << "It's a Dog" << endl;
    } else if (ti == typeid(Cat)) {
        cout << "It's a Cat" << endl;
    } else {
        cout << "It's a generic Animal" << endl;
    }
}

int main() {
    Dog dog;
    Cat cat;
    Animal animal;

    printTypeInfo(dog);  // 输出Dog类型信息
    printTypeInfo(cat);  // 输出Cat类型信息
    printTypeInfo(animal);  // 输出Animal类型信息
    return 0;
}

#include <iostream>
#include <typeinfo>
#include <cxxabi.h>
#include <cstdlib>
using namespace std;

string demangle(const char* mangled_name) {
    int status;
    char* demangled = abi::__cxa_demangle(mangled_name, nullptr, nullptr, &status);
    string result = (status == 0) ? demangled : mangled_name;
    free(demangled);  // 注意释放内存
    return result;
}

int main() {
    const type_info& ti = typeid(Dog);
    cout << "Mangled name: " << ti.name() << endl;
    cout << "Demangled name: " << demangle(ti.name()) << endl;
    return 0;
}

#include <vector>
#include <memory>
using namespace std;

int main() {
    vector<unique_ptr<Animal>> zoo;
    zoo.push_back(make_unique<Dog>());
    zoo.push_back(make_unique<Cat>());
    zoo.push_back(make_unique<Animal>());

    for (const auto& animal : zoo) {
        // 使用typeid判断类型
        if (typeid(*animal) == typeid(Dog)) {
            static_cast<Dog*>(animal.get())->wagTail();
        } else if (typeid(*animal) == typeid(Cat)) {
            static_cast<Cat*>(animal.get())->scratch();
        }
    }
    return 0;
}

#include <fstream>
#include <string>

void serializeAnimal(const Animal& animal, ofstream& file) {
    // 写入类型标签（使用typeid获取类型名）
    file << typeid(animal).name() << "\n";
    // 写入对象数据（示例省略具体字段）
}

unique_ptr<Animal> deserializeAnimal(ifstream& file) {
    string type_name;
    file >> type_name;
    
    if (type_name == typeid(Dog).name()) {
        return make_unique<Dog>();
    } else if (type_name == typeid(Cat).name()) {
        return make_unique<Cat>();
    }
    return make_unique<Animal>();
}

void logObjectInfo(const void* obj, const type_info& ti) {
    cout << "Object at " << obj 
         << " is of type: " << demangle(ti.name()) << endl;
}

int main() {
    Dog dog;
    logObjectInfo(&dog, typeid(dog));  // 输出：Object at 0x7ffd... is of type: Dog
    return 0;
}

class Animal {
public:
    virtual ~Animal() = default;
    virtual void interact() const = 0;  // 纯虚函数定义交互行为
};

class Dog : public Animal {
public:
    void interact() const override { 
        cout << "Dog barks and wags tail" << endl; 
    }
};

class Cat : public Animal {
public:
    void interact() const override { 
        cout << "Cat meows and scratches" << endl; 
    }
};

int main() {
    vector<unique_ptr<Animal>> zoo = {
        make_unique<Dog>(),
        make_unique<Cat>()
    };
    
    for (const auto& animal : zoo) {
        animal->interact();  // 多态调用，无需RTTI
    }
    return 0;
}