什么是C++中的早期(静态)和后期(动态)绑定？

Question

C++中的早期绑定和延迟绑定是什么样子的？你能举个例子吗？

我读到函数重载是早期绑定，而虚函数是后期绑定。我read说“早期(或静态)绑定指的是编译时绑定，而后期(或动态)绑定指的是运行时绑定”。

Answer 1

你没看错。基本的例子可以用以下方式给出：

using FuncType = int(*)(int,int); // pointer to a function
                                  // taking 2 ints and returning one.

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

静态绑定是指在编译时绑定是已知的：

int main() {
    std::cout << add(4, 5) << "\n";
}

没有为操作的动态更改留出空间，因此是静态绑定的。

int main() {
    char op = 0;
    std::cin >> op;

    FuncType const function = op == '+' ? &add : &substract;

    std::cout << function(4, 5) << "\n";
}

而在这里，根据输入，可以得到9或-1。这是动态绑定的。

此外，在面向对象的语言中，virtual函数可用于动态绑定某些内容。因此，一个更详细的示例可以是：

struct Function {
    virtual ~Function() {}
    virtual int doit(int, int) const = 0;
};
struct Add: Function {
    virtual int doit(int a, int b) const override { return a + b; } 
};
struct Substract: Function {
    virtual int doit(int a, int b) const override { return a - b; } 
};

int main() {
    char op = 0;
    std::cin >> op;

    std::unique_ptr<Function> func =
        op == '+' ? std::unique_ptr<Function>{new Add{}}
                  : std::unique_ptr<Function>{new Substract{}};

    std::cout << func->doit(4, 5) << "\n";
}

这在语义上等同于前面的示例...但是引入了面向对象程序设计中常见的virtual函数的后期绑定。

Answer 2

这适用于所有面向对象的语言，不仅仅是C++。

静态、编译时绑定很容易。没有涉及到多态性。在编写、编译和运行代码时，您可以知道对象的类型。有时狗只是一只狗。

动态的运行时绑定就是多态的来源。

如果您在编译类型时具有父类型的引用，则可以在运行时为其分配子类型。引用的行为将在运行时神奇地更改为适当的类型。将执行虚拟表查找，以使运行时确定动态类型是什么。

Answer 3

静态绑定:如果函数调用在编译时是已知的，则称为静态绑定。在对象物质的静态绑定类型中，相应地调用适当的函数。如下面的示例obj_a.fun()所示，这里的obj_a属于A类，这就是调用类的fun()的原因。

#include<iostream>
using namespace std;
class A{
public:
void fun()
{cout<<"hello world\n";}

};
class B:public A{
public:
void show()
{cout<<"how are you ?\n";}

};

int main()
{
A obj_a;           //creating objects
B obj_b;
obj_a.fun();       //it is known at compile time that it has to call fun()
obj_b.show();     //it is known at compile time that it has to call show()
return 0;
}

动态绑定:如果函数调用在运行时是已知的，则称为动态绑定。我们使用虚拟keyword.as基指针来实现后期绑定，还可以保存子指针的地址。因此，在指针的这个内容中，matter.whether指针保存着基类或子类的地址

#include<iostream>
using namespace std;

class car{
public:
    virtual void speed()
     {
      cout<<"ordinary car: Maximum speed limit  is 200kmph\n";
     }
};
class sports_car:public car{
  void speed()
     {
      cout<<"Sports car: Maximum speed is 300kmph\n";
     }
};

int main()
{
car *ptr , car_obj;      // creating object and pointer to car
sports_car   sport_car_obj;  //creating object of sport_car
ptr = &sport_car_obj;      // assigining address of sport_car to pointer 
                             //object of car 
 ptr->speed();   // it will call function of sports_car

return 0;
}

如果我们从car类中删除了virtual关键字，那么它将调用car类的函数。但是现在它调用的是sport_car类的速度函数。这是动态绑定，因为在函数调用期间，指针的内容与指针的类型无关。由于ptr是car类型，但保存的是速度的地址，这就是调用sport_car sport_car ()的原因。