Question

早期和晚期绑定在C ++中是如何形成的？你能举个例子吗？

我读到函数重载是早期绑定，虚函数是后期绑定。 I 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类，这就是调用class的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;
}

动态绑定：如果函数调用在运行时已知，那么它被称为动态绑定。我们通过使用virtual keyword来实现后期绑定。基本指针也可以保存子指针的地址。所以在指针的这个内容中。指针是否持有基类或子类的地址

#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（）的原因。

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

3 个答案: