面试题：C++多态实现中的动态绑定与静态绑定

动态绑定和静态绑定的概念

动态绑定：
- 动态绑定是指在运行时根据对象的实际类型来确定调用哪个虚函数的版本。在C++中，当通过基类指针或引用调用虚函数时，会发生动态绑定。编译器在编译时无法确定到底调用哪个函数版本，而是在运行时根据指针或引用所指向的实际对象类型来决定。
- 例如：

#include <iostream>
class Animal {
public:
    virtual void speak() {
        std::cout << "Animal speaks" << std::endl;
    }
};
class Dog : public Animal {
public:
    void speak() override {
        std::cout << "Dog barks" << std::endl;
    }
};
int main() {
    Animal* animalPtr = new Dog();
    animalPtr->speak();// 动态绑定，运行时根据animalPtr实际指向的Dog对象，调用Dog::speak
    delete animalPtr;
    return 0;
}

静态绑定：
- 静态绑定是指在编译时就确定调用哪个函数的版本。对于非虚函数，包括普通函数和被final修饰的虚函数（一旦被final修饰，就不能在子类中重写，也就不会发生动态绑定），编译器根据对象的声明类型来确定调用的函数。
- 例如：

#include <iostream>
class Shape {
public:
    void draw() {
        std::cout << "Drawing a shape" << std::endl;
    }
};
class Circle : public Shape {
public:
    void draw() {
        std::cout << "Drawing a circle" << std::endl;
    }
};
int main() {
    Shape shapeObj;
    Circle circleObj;
    Shape* shapePtr = &circleObj;
    shapePtr->draw();// 静态绑定，根据shapePtr的声明类型Shape，调用Shape::draw
    return 0;
}

动态绑定和静态绑定的区别

绑定时间：
- 动态绑定发生在运行时，而静态绑定发生在编译时。
确定函数版本依据：
- 动态绑定根据对象的实际类型（运行时确定）来确定调用的虚函数版本。
- 静态绑定根据对象的声明类型（编译时已知）来确定调用的函数版本。

发生静态绑定而非期望的动态绑定的情况

通过对象调用虚函数：
- 当通过对象（而不是指针或引用）调用虚函数时，会发生静态绑定。
- 例如：

#include <iostream>
class Base {
public:
    virtual void print() {
        std::cout << "Base" << std::endl;
    }
};
class Derived : public Base {
public:
    void print() override {
        std::cout << "Derived" << std::endl;
    }
};
int main() {
    Derived derivedObj;
    Base baseObj = derivedObj;
    baseObj.print();// 静态绑定，根据baseObj的声明类型Base，调用Base::print
    return 0;
}

这里baseObj是Base类型的对象，虽然它被初始化为derivedObj的值，但发生了切片，baseObj内部只有Base部分的数据，调用print函数时，根据声明类型Base进行静态绑定，调用Base::print。 2. 使用static_cast将子类指针转换为父类指针并调用虚函数：

如果使用static_cast将子类指针转换为父类指针，并且该转换可能导致丢失动态类型信息时，可能出现意外的静态绑定。
例如：

#include <iostream>
class Base {
public:
    virtual void print() {
        std::cout << "Base" << std::endl;
    }
};
class Derived : public Base {
public:
    void print() override {
        std::cout << "Derived" << std::endl;
    }
};
int main() {
    Derived* derivedPtr = new Derived();
    Base* basePtr = static_cast<Base*>(derivedPtr);
    basePtr->print();// 这里正常是动态绑定，但如果static_cast使用不当导致丢失动态类型信息，可能出现问题
    delete derivedPtr;
    return 0;
}

虽然这里正常情况下能正确动态绑定，但在一些复杂的类型转换场景中，如果static_cast用错，可能破坏动态类型信息。

避免静态绑定确保多态正确实现的方法

通过指针或引用调用虚函数：
- 始终使用基类指针或引用调用虚函数，而不是通过对象调用。
- 例如：

#include <iostream>
class Base {
public:
    virtual void print() {
        std::cout << "Base" << std::endl;
    }
};
class Derived : public Base {
public:
    void print() override {
        std::cout << "Derived" << std::endl;
    }
};
int main() {
    Derived derivedObj;
    Base* basePtr = &derivedObj;
    basePtr->print();// 通过指针调用，确保动态绑定
    Base& baseRef = derivedObj;
    baseRef.print();// 通过引用调用，确保动态绑定
    return 0;
}

避免对象切片：
- 当传递对象时，尽量传递指针或引用，避免对象按值传递导致切片。
- 例如：

#include <iostream>
class Base {
public:
    virtual void print() {
        std::cout << "Base" << std::endl;
    }
};
class Derived : public Base {
public:
    void print() override {
        std::cout << "Derived" << std::endl;
    }
};
void printObj(Base& obj) {
    obj.print();// 传递引用，避免切片，确保动态绑定
}
int main() {
    Derived derivedObj;
    printObj(derivedObj);
    return 0;
}

正确使用类型转换：
- 如果需要进行类型转换，优先使用dynamic_cast，它在运行时进行安全的类型转换，并且能保留动态类型信息。
- 例如：

#include <iostream>
class Base {
public:
    virtual void print() {
        std::cout << "Base" << std::endl;
    }
};
class Derived : public Base {
public:
    void print() override {
        std::cout << "Derived" << std::endl;
    }
};
int main() {
    Base* basePtr = new Derived();
    Derived* derivedPtr = dynamic_cast<Derived*>(basePtr);
    if (derivedPtr) {
        derivedPtr->print();// 通过dynamic_cast转换后，能确保调用正确的虚函数版本
    }
    delete basePtr;
    return 0;
}

星途面试题库

面试题：C++多态实现中的动态绑定与静态绑定

知识考点

面试题答案

动态绑定和静态绑定的概念

动态绑定和静态绑定的区别

发生静态绑定而非期望的动态绑定的情况

避免静态绑定确保多态正确实现的方法