Question

以下是静态或动态绑定的情况吗？因为我可以知道，我的指针在编译时指向的对象类是什么，我的猜测是它是静态的......

class Base 
{
void print() const;
};

class Derived : public Base 
{
void print() const;
};

int main()
{
Base base;
Base *basePtr = &base;
basePtr->print();
}

为什么我们应该使用动态绑定而不是静态？我不明白为什么我们应该使用虚函数而不是简单地以这种方式调用函数base.print()（对于上面的例子）。这个方法已经“理解”了print()函数调用对象的正确类，而不使用多态和虚函数。

更新

  // Point class definition represents an x-y coordinate pair.
  #ifndef POINT_H
  #define POINT_H

  class Point {

  public:
     Point( int = 0, int = 0 ); // default constructor

   void setX( int );  // set x in coordinate pair
   int getX() const;  // return x from coordinate pair

   void setY( int );  // set y in coordinate pair
   int getY() const;  // return y from coordinate pair

   virtual void print() const;  // output Point object

private: 
   int x;  // x part of coordinate pair
   int y;  // y part of coordinate pair

}; // end class Point

#endif

  // Circle class contains x-y coordinate pair and radius.
  #ifndef CIRCLE_H
  #define CIRCLE_H

  #include "point.h"  // Point class definition

  class Circle : public Point {

public:

   // default constructor
   Circle( int = 0, int = 0, double = 0.0 );  

   void setRadius( double );   // set radius
   double getRadius() const;   // return radius

   double getDiameter() const;       // return diameter
   double getCircumference() const;  // return circumference
   double getArea() const;           // return area

   virtual void print() const;       // output Circle object

private: 
   double radius;  // Circle's radius

}; // end class Circle

#endif

  // Introducing polymorphism, virtual functions and dynamic
  // binding.
  #include <iostream>

  using std::cout;
  using std::endl;
  using std::fixed;

#include <iomanip>

using std::setprecision;

#include "point.h"   // Point class definition
#include "circle.h"  // Circle class definition

int main()
{
   Point point( 30, 50 );
   Point *pointPtr = 0;

   Circle circle( 120, 89, 2.7 );
   Circle *circlePtr = 0; 
  // set floating-point numeric formatting
   cout << fixed << setprecision( 2 );

   // output objects point and circle using static binding
   cout << "Invoking print function on point and circle "
        << "\nobjects with static binding "
        << "\n\nPoint: ";
   point.print();         // static binding
   cout << "\nCircle: ";
   circle.print();        // static binding

   // output objects point and circle using dynamic binding
   cout << "\n\nInvoking print function on point and circle "
        << "\nobjects with dynamic binding";

   // aim base-class pointer at base-class object and print
   pointPtr = &point;                                      
   cout << "\n\nCalling virtual function print with base-class"
        << "\npointer to base-class object"
        << "\ninvokes base-class print function:\n";
   pointPtr->print();
   // aim derived-class pointer at derived-class
   // object and print                          
   circlePtr = &circle;                         
   cout << "\n\nCalling virtual function print with "
        << "\nderived-class pointer to derived-class object "
        << "\ninvokes derived-class print function:\n";
   circlePtr->print();

   // aim base-class pointer at derived-class object and print
   pointPtr = &circle;                                        
   cout << "\n\nCalling virtual function print with base-class"
        << "\npointer to derived-class object "
        << "\ninvokes derived-class print function:\n";
   pointPtr->print();  // polymorphism: invokes circle's print
   cout << endl;

   return 0;

} // end main

Answer 1

以下是静态或动态绑定的情况吗？

静态，因为该功能不是虚拟的。

如果它是虚拟的，那么将根据对象的动态类型调度该函数。

为什么我们应该使用动态绑定而不是静态？

当我们想通过公共基类与不同类型的对象进行交互时，不知道实际（动态）类型是什么。例如，

class Base 
{
    virtual void print() const;  // add "virtual" to enable dynamic dispatch
};

// This function doesn't know the real (dynamic) type of the object,
// but still calls the correct version of "print".
void print(Base const & base) {
    // If "print" is virtual, then this calls the override for the dynamic type.
    // Otherwise, this calls Base::print.
    base.print();
}

int main() {
    Base base;
    Derived derived;

    print(base);     // calls Base::print
    print(derived);  // calls Derived::print
}

此方法已经“理解”哪个print（）函数调用对象的正确类，而不使用多态和虚函数。

实际上，如果在您的示例中，您已知道动态类型，则多态性无用。这是因为你不知道动态类型，如我的例子。

Answer 2

您的示例中没有任何动态绑定。您只需定义基类类型的指针，并为其指定（相同）基类的对象的地址。所以你不清楚为什么要谈论动态绑定。

现在也使用派生类的定义。

当指针或引用的静态类型与其动态类型不同并且使用虚函数时，使用动态绑定。在您的示例中，没有第一个要求，也没有第二个要求。

以下是动态绑定的示例

#include <iostream>

class Base 
{
   virtual void print() const { std::cout << "Base" << std::endl; }
   virtual ~Base() = default;
   // or virtual ~Baae() {}
};

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

int main()
{
   Derived d;
   Base *basePtr = &d;
   basePtr->print();
}

虽然指针basePtr的静态类型为Base *，但其动态类型为Derived *，因为它是由派生类的对象的地址指定的。

引用C ++标准中的一条说明会更清楚

是有用的

[例如：如果指针（8.3.1）p的静态类型是“指向 “B类”指的是D类的一个对象，它来自B（Clause 10），表达式* p的动态类型是“D”。参考文献（8.3.2）同样对待。 - 例子]

Answer 3

使用virtual方法时会发生动态绑定。 Base::print不是virtual。动态绑定的想法是在运行时将被称为绑定的实际方法，当derived类重写基类中的virtual方法时会发生这种情况，然后取决于实际对象类（base / derived），该方法将被绑定。实际上，在与基类同名的派生类中定义方法会隐藏基类方法，这是一种不好的做法。

这是动态还是静态绑定？

更新

3 个答案: