虚函数 C#

Question

我了解什么是虚函数。但我不明白它们是如何在内部工作的？

class Animal
{
    virtual string Eat()
    {
        return @"Eat undefined";
    }
}

class Human : Animal
{
    override string Eat()
    {
         return @"Eat like a Human";
    }
}


class Dog : Animal
{
    new string Eat()
    {
         return @"Eat like a Dog";
    }
}

static void Main()
{
    Animal _animal = new Human();
    Console.WriteLine(_animal.Eat());
    _animal = new Dog();
    Console.WriteLine(_animal.Eat());
}

上述输出给出：

Eat like a Human
Eat undefined

在上面的代码中，_animal 是 Animal 类型，它引用了 Human 对象或 Dog 对象。 这是什么意思？我知道在内存中 _animal 包含一个指向 Human 或 Dog 对象的地址。它如何决定调用哪个函数。在第一种情况下，我覆盖并因此调用子级的实现，但在第二种情况下，我使用 new 并因此调用父级的实现。你能解释一下幕后发生了什么吗？

提前致谢 尼克

Answer 1

它是这样工作的。想象一下编译器把你的类改写成这样：

class VTable
{
    public VTable(Func<Animal, string> eat)
    {
        this.AnimalEat = eat;
    }
    public readonly Func<Animal, string> AnimalEat;
}

class Animal
{
    private static AnimalVTable = new VTable(Animal.AnimalEat);
    private static string AnimalEat(Animal _this)
    { 
        return "undefined"; 
    }
    public VTable VTable;
    public static Animal CreateAnimal() 
    { 
        return new Animal() 
            { VTable = AnimalVTable }; 
    }
}

class Human : Animal
{
    private static HumanVTable = new VTable(Human.HumanEat); 
    private static string HumanEat(Animal _this)
    {
        return "human"; 
    }
    public static Human CreateHuman()
    {
        return new Human() 
            { VTable = HumanVTable };
    }
}

class Dog : Animal
{
    public static string DogEat(Dog _this) { return "dog"; }
    public static Dog CreateDog()
    {
        return new Dog() 
            { VTable = AnimalVTable } ;
    }
}

现在考虑这些调用：

Animal animal;
Dog dog;
animal = new Human();
animal.Eat();
animal = new Animal();
animal.Eat();
dog = new Dog();
dog.Eat();
animal = dog;
animal.Eat();

编译器的原因如下：如果接收者的类型是Animal，那么Eat的调用必须是animal.VTable.AnimalEat。如果接收者的类型是 Dog，那么调用必须是 DogEat。所以编译器把这些写成：

Animal animal;
Dog dog;
animal = Human.CreateHuman(); // sets the VTable field to HumanVTable
animal.VTable.AnimalEat(animal); // calls HumanVTable.AnimalEat
animal = Animal.CreateAnimal(); // sets the VTable field to AnimalVTable
animal.VTable.AnimalEat(animal); // calls AnimalVTable.AnimalEat
dog = Dog.CreateDog(); // sets the VTable field to AnimalVTable
Dog.DogEat(dog); // calls DogEat, obviously
animal = dog;
animal.VTable.AnimalEat(animal); // calls AnimalVTable.AnimalEat

正是它的工作原理。编译器会在后台为你生成 vtable，并在编译时根据重载解析的规则决定是否通过 vtable 调用。

vtables 是在创建对象时由内存分配器设置的。 （我的草图在这方面是一个谎言，因为 vtable 是在调用 ctor 之前 设置的，而不是之后。）

虚方法的“this”实际上是作为不可见的形参偷偷传递给方法的。

有意义吗？

Answer 2

我知道内存中的_animal 包含一个指向Human 或Dog 对象的地址。它如何决定调用哪个函数。

和数据一样，代码也有地址。

因此，解决此问题的典型方法是让Human 或Dog 对象包含其方法的代码地址。这有时被称为使用vtable。在像 C 或 C++ 这样的语言中，这个概念也直接暴露为所谓的function pointer。

现在，您提到了 C#，它有一个相当高级的类型系统，其中对象的类型在运行时也是可辨别的……因此，实现细节可能在某些方面与传统方法不同。但是，至于您的问题，函数指针/v-table 概念是一种方法，如果 .NET 偏离这一点太多，我会感到惊讶。

Answer 3

在 C# 中，派生类必须为从基类继承的任何重写方法提供 override 修饰符。

Animal _animal = new Human();

这不仅仅是Human 对象的构造。它们是两个子对象。一个是Animal 子对象，另一个是Human 子对象。

Console.WriteLine(_animal.Eat());

当调用_animal.Eat(); 时，运行时检查派生类中是否覆盖了基类方法（即Eat()）。因为，它被覆盖，相应的派生类方法被调用。因此输出 -

Eat like a Human

但是，如果是-

_animal = new Dog();
Console.WriteLine(_animal.Eat());

在Dog中，派生类Dog中没有Eat()重写方法。因此，基类方法本身被调用。这种检查方法也被完成，因为在基类中，Eat() 被提及为虚拟并且调用机制在运行时决定。综上所述，虚拟调用机制是一种运行时机制。