上行转换与下行转换

本文中的概念及示例是在 C++ 11 的兼容版本中来进行介绍及演示。

1 主要概念

1.1 上行转换 upcasting

上行转换是指将派生类指针或引用转换为基类指针或引用。这是一种安全的转换,因为派生类总是包含基类的所有成员。

// 1 多态性
class Animal {
public:
    virtual void makeSound() = 0;
};

class Dog : public Animal {
public:
    void makeSound() override { std::cout << "Woof!" << std::endl; }
};

void animalSound(Animal* animal) {
    animal->makeSound();
}

int main() {
    Dog* dog = new Dog();
    animalSound(dog);  // 上行转换
    delete dog;
    return 0;
}

// 2 容器中存储不同类型的对象
std::vector<Animal*> animals;
animals.push_back(new Dog());
animals.push_back(new Cat());

1.2 下行转换 downcasting

下行转换是指将基类指针或引用转换为派生类指针或引用。这种转换可能不安全,因为基类指针可能不指向派生类对象。
C++11引入了几种安全的下行转换方式:

1. dynamic_cast

class Animal {
public:
    virtual ~Animal() {}
};

class Dog : public Animal {
public:
    void bark() { std::cout << "Woof!" << std::endl; }
};

void makeDogBark(Animal* animal) {
    Dog* dog = dynamic_cast<Dog*>(animal);
    if (dog) {
        dog->bark();
    } else {
        std::cout << "This animal is not a dog." << std::endl;
    }
}

2. static_cast (在确定类型的情况下)

Dog* dog = new Dog();
Animal* animal = dog;
Dog* sameDog = static_cast<Dog*>(animal);  // 安全,因为我们知道animal确实指向Dog对象

3. std::is_base_of

#include <type_traits>

static_assert(std::is_base_of<Animal, Dog>::value, "Dog must inherit from Animal");

2 dynamic_cast 与 static_cast

// dynamic_cast
class Base {
public:
    virtual ~Base() {}
};

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

void process(Base* b) {
    Derived* d = dynamic_cast<Derived*>(b);
    if (d) {
        d->derivedFunction();
    } else {
        std::cout << "Not a Derived object" << std::endl;
    }
}

// static_cast
class Base { };
class Derived : public Base { };

Base* b = new Derived();
Derived* d = static_cast<Derived*>(b);  // 假设我们确定 b 指向 Derived 对象

3 总结

• 使用 dynamic_cast 当你需要在运行时安全地向下转换多态类型。
• 使用 static_cast 当你确定转换是安全的，或者进行向上转换，以及在性能关键的代码中。
• dynamic_cast 提供了更多的安全性，但代价是性能损失。
• static_cast 更快，但需要程序员确保类型转换的正确性。

在实际编程中，应该根据具体情况选择合适的转换操作符。如果不确定对象的实际类型，使用 dynamic_cast 会更安全；如果确定转换是安全的，使用 static_cast 会有更好的性能。