27

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

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

4

3 回答 3

27

你没看错。可以通过以下方式给出基本示例：

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在面向对象编程中常见的函数后期绑定。

于 2013-08-03T17:17:09.370 回答
5

所有面向对象的语言都是如此，而不仅仅是 C++。

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

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

如果您在编译类型中有一个父类型的引用，您可以在运行时为其分配一个子类型。引用的行为将在运行时神奇地更改为适当的类型。将进行虚拟表查找以让运行时找出动态类型是什么。

于 2013-08-03T17:20:42.067 回答
0

静态绑定：如果函数调用在编译时已知，则称为静态绑定。在对象的静态绑定类型中，相应地调用合适的函数。如下例所示 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;
}

动态绑定：如果函数调用在运行时已知，则称为动态绑定。我们通过使用虚拟关键字实现后期绑定。因为基指针也可以保存子指针的地址。所以在指针的这个内容中，指针是持有基类地址还是子类地址

#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;
}

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

于 2017-05-21T03:57:56.513 回答