C++ 静态和动态绑定行为

Question

我理解静态绑定和动态绑定之间的区别，因为方法调用是在编译时为静态绑定确定的，而方法调用则是在运行时为动态绑定确定的。

我不明白的一件事是，为什么动态绑定必须通过引用或指针传递。我试着上网查找，但还是很困惑。这是因为当你传递值时，你传递的是一个副本，这意味着它必须初始化，这意味著它被切片了吗？

例如，Pet是基类，Dog是派生类。

现在。。。

void print(Pet p) {} // Calls print from the pet class
void print(Pet &p) {} // Calls print from the type of pet object being passed. For example, Dog::print() rather than Pet::print()

如果有人能更好地向我解释这一点，那真的会让我很高兴

感谢

Answer 1

通过值调用和通过引用调用会混淆很多东西。

void print(Pet p);

这是一个声明print为返回void的函数，并通过名为p的值获取Pet的一个参数。这是按值调用。

void print(Pet &p);

这是一个声明print为返回void的函数，并通过名为p的引用获取Pet的一个参数。这是通过引用调用。

Answer 2

您的假设大致正确，不是针对print函数本身，而是针对最终在其中调用的Pet的成员函数。使用传递值的print函数采用一个基本Pet对象。因此，编译器可以自由地静态绑定调用（并且传递给它的Dog对象将被切片）。

但是对于使用传递引用的print函数，编译器必须动态地将调用绑定到eat，因为它不知道哪个确切的对象位于该地址。请查看以下代码。

#include <iostream>
struct Pet {
  virtual void eat() const { std::cout << "pet" << std::endl; }
};
struct Dog : Pet {
  void eat() const /*override*/ { std::cout << "dog" << std::endl; }
};
// Option 1: void print(Pet p) { p.eat(); }
// Option 2: void print(Pet& p) { p.eat(); }
int main() {
  Pet* p = new Dog;
  print(*p);
  delete p;
  // In c++ 11 use override and std::unique_ptr.
  return 0;
}

如果取消注释选项1，这就是生成的代码。请注意，eat的调用被静态地解析。

__Z5print3Pet: 
        .cfi_startproc
        pushq   %rbp
Ltmp2:
        .cfi_def_cfa_offset 16
Ltmp3:
        .cfi_offset %rbp, -16
        movq    %rsp, %rbp
Ltmp4:
        .cfi_def_cfa_register %rbp
        callq   __ZNK3Pet3eatEv     # HERE eat GETS CALLED.

但是，如果现在取消注释选项2，编译器必须执行间接调用，绑定在运行时。

__Z5printR3Pet:                         
        .cfi_startproc
        pushq   %rbp
Ltmp2:
        .cfi_def_cfa_offset 16
Ltmp3:
        .cfi_offset %rbp, -16
        movq    %rsp, %rbp
Ltmp4:
        .cfi_def_cfa_register %rbp
        subq    $16, %rsp
        movq    %rdi, -8(%rbp)
        movq    -8(%rbp), %rdi
        movq    (%rdi), %rax
        callq   *(%rax)           # HERE eat GETS INDIRECTLY CALLED.