Question

这是我课堂上的样本。老实说，我知道虚拟如何与动态内存一起工作。但这对我来说很难理解。你们可以让我知道它是如何工作的吗？在这种情况下，它正在调用a.display（）; foo（a）;我理解，但是当它直接调用马中的函数时，我无法理解它在调用动物函数时如何在马中调用函数。因此，我希望对此代码进行一般概述，并且由于两者的时间并不长，因此不会花太长时间。这是标题。

// Virtual Functions
// Animal.h

#include <iostream>

class Animal{
  public: 
   virtual void display() const;
};

class Horse : public Animal {
  public:
    void display() const;
};

这是实现文件。

// Virtual Functions
// Animal.cpp

#include "Animal.h"

void Animal::display() const {
  std::cout << "Animal" << std::endl;
}

void Horse::display() const{
  std::cout << "Horse" << std::endl;
}

这是第一个版本。

// Virtual Functions - Monomorphic
// h16.m.cpp

#include "Animal.h"

void foo(const Animal a){
  a.display();
}
void goo(const Animal& a){
  a.display();
}

int main(){
  Animal a;
  Horse h;
  
  a.display();
  foo(a);
  goo(a);

  h.display();
  foo(h);
  goo(h);
}

这是第二个。

// Virtual functions - Polymorphic
// h16.cpp

#include "Animal.h"

void foo(Animal a){
  a.display();
}

void goo(Animal& a){
  a.display();
}

void foogoo(Animal& a){
  a.Animal::display();
}

int main(){
  Animal* a; // Static typing
  a = new Animal(); // Dynamic typing
  a->display();  // ani
  foo(*a); //ani
  goo(*a);  //ani
  delete a;
  a = new Horse(); // Dynamic typing
  a->display(); //horse
  foo(*a); //ani
  goo(*a); //ani
  foogoo(*a); //ani
  delete a;
}

Answer 1

虚拟成员与动态内存无关。它们与类类型B的对象的类成员通过静态类型A的可访问性有关，而A是B的基类之一。

示例：

struct A 
{
virtual void foo();
virtual void bar();
};

struct B : A
{
void foo() override;
};

struct C : B
{
void bar() override;
};

A *ptr = new B;
A& ref = *ptr;

由ptr指向的对象的静态（编译时已知）类型为A。new B表达式在程序运行时求值。它创建类型为B的对象，因此ptr指向的对象的动态类型为B。相反，可以用相同的结果编写该对象：

B  objB;
A* ptr = &B;   // value of address of variable saved to a pointer is run-time.
A& ref = *ptr;

ref也是对具有动态类型B的对象的引用，即使该引用具有静态类型A。

如果未声明foo()，virtual将是B::foo或ptr不可访问的方法，因为它不存在于A中。但实际上，ref将调用B :: foo（）。

ptr->foo()在B中没有被覆盖，但是在C中被覆盖。通过引用A或B来调用bar()就足够了，因为它在A中被声明为虚拟的。 / p>

在您的示例中，在C::bar()之后，如果通过重写a = new Horse();访问的对类Animal的虚拟方法的任何调用，如果它们在此处被覆盖，则将分派到a类。给父母但是在功能上

Horse

参数不是指针或引用。这是类型为void foo(const Animal a){ a.display(); }的新变量，它将接收Horse的 part 的副本，该对象是Animal对象。 Animal在这里只能访问a.display();

Animal::display();

这正是调用Horse b; Animal a; a = b; // it's only a part of Horse, it behaves like an Animal时发生的情况。此类调用包括根据函数调用的定义分配的foo(h)。

如果这种“削减”是按照编译器声明的操作（复制构造函数或赋值）发生的，则称为对象切片。如果用户重新定义了这些内容，则可以更改内容的传输，但目标对象将保留其原始静态属性，包括其原始虚拟表（已声明的虚拟成员的列表）。

重要的是要记住获得基类的类包含基类的对象。据说基类是派生类的 子对象 ，就像使用派生类声明的任何成员一样。

有关虚拟功能演练工作的问题

1 个答案: