代码之家  ›  专栏  ›  技术社区  ›  Vlad the Impala

基类指针和继承类指针?

  •  5
  • Vlad the Impala  · 技术社区  · 16 年前

    假设我有课 Dog 从类继承的 Animal . 这两行代码有什么区别?

        Animal *a = new Dog();
        Dog *d = new Dog();
    

    8 回复  |  直到 16 年前
        1
  •  11
  •   Steve Jessop    16 年前

    对于所有类型检查的目的,编译器都将 a 好像它可以指向任何动物,即使你知道它指向狗:

    • 一 Dog* .
    • a->fetchStick() ,在哪里 fetchStick Dog 但不是 Animal
    • Dog *d2 = dynamic_cast<Dog*>(d) 可能只是编译器上的指针副本。 Dog *d3 = dynamic_cast<Dog*>(a) 可能不是(我在这里猜测,我不打算费心检查任何编译器。关键是:编译器可能会对 和 d

    您可以通过任意一个调用动物的虚拟函数(即定义的多态接口),效果相同。假设 狗

    对于在动物中定义的非虚函数,以及在狗中定义的(重载),通过 一 不同于通过 .

        2
  •  5
  •   mauris    8 年前

    这个问题的答案是巨大的:视情况而定

    class Animal {
    public:
      virtual void MakeSound(const char* pNoise) { ... }
      virtual void MakeSound() { ... }
    };
    
    class Dog : public Animal {
    public:
      virtual void MakeSound() {... }
    };
    
    int main() {
      Animal* a = new Dog();
      Dog* d = new Dog();
      a->MakeSound("bark");
      d->MakeSound("bark"); // Does not compile
      return 0;
    }
    

    这是为什么C++进行名称查找的一个怪癖。简而言之:当寻找调用C++的方法时,将使用类型层次结构来寻找具有匹配名称的方法的第一种类型。然后,它将从在该类型上声明了该名称的方法中查找正确的重载。自 Dog 只声明一个 MakeSound 方法没有参数,没有重载匹配,并且无法编译。

        3
  •  2
  •   Klaim    16 年前

    第一行允许您仅调用动物类的成员:

    Animal *a = new Dog();
    a->eat(); // assuming all Animal can eat(), here we will call Dog::eat() implementation.
    a->bark(); // COMPILATION ERROR : bark() is not a member of Animal! Even if it's available in Dog, here we manipulate an Animal.
    

    a 仍然是动物,你不能提供 作为函数的一个参数,请求一个更具体的子类Dog:

    void toy( Dog* dog );
    
    toy( a ); // COMPILATION ERROR : we want a Dog!
    

    第二行允许您使用子类的特定函数:

    Dog *a = new Dog();
    a->bark(); // works, but only because we're manipulating a Dog
    

    因此,使用基类作为类层次结构的“泛型”接口(允许您让所有动物都吃东西(),而不必考虑如何吃)。

        4
  •  2
  •   indiv Olivier Poulin    16 年前

    1. 如果Animal::do\u stuff()声明为virtual,则在Animal指针上调用do\u stuff()将调用Dog::do\u stuff()。

    2. 如果Animal::do\u stuff()未声明为virtual,则在Animal指针上调用do\u stuff()将调用Animal::do\u stuff()。

    下面是一个完整的工作程序来演示:

    #include <iostream>
    
    class Animal {
    public:
            void do_stuff() { std::cout << "Animal::do_stuff\n"; }
            virtual void virt_stuff() { std::cout << "Animal::virt_stuff\n"; }
    };
    
    class Dog : public Animal {
    public:
            void do_stuff() { std::cout << "Dog::do_stuff\n"; }
            void virt_stuff() { std::cout << "Dog::virt_stuff\n"; }
    };
    
    int main(int argc, char *argv[])
    {
            Animal *a = new Dog();
            Dog *b = new Dog();
    
            a->do_stuff();
            b->do_stuff();
            a->virt_stuff();
            b->virt_stuff();
    }
    

    Animal::do_stuff
    Dog::do_stuff
    Dog::virt_stuff
    Dog::virt_stuff
    

    这只是一个例子。其他答案列出了其他重要的区别。

        5
  •  1
  •   duffymo    16 年前

    不,他们不一样。

    狗的指针不像动物那样具有多态性。它在运行时只能指向一只狗或狗的一个子类。如果没有Dog的子类,那么Dog运行时类型和编译时类型是相同的。

    动物指针可以指动物的任何子类:狗、猫、角马等。

        6
  •  0
  •   a1ex07    16 年前

    当你试图调用狗的方法而不是动物的方法时,这种差异是很重要的。在第一种情况下(指针指向动物),你必须先将指针指向狗。另一个区别是,如果您碰巧重载了非虚方法。然后将调用Animal::non\u virtual\u method()(指向动物的指针)或Dog::non\u virtual\u method(指向狗的指针)。

        7
  •  0
  •   ruralcoder    16 年前

    您必须始终记住,每个类中有两个部分:数据和接口。

    这个对象的大小是所有数据成员Dog+Animal+vtable指针的总和。

    从接口的角度来看,ponters a和d(左值)是不同的。这就决定了你如何用代码来处理它们。因此,即使动物*a实际上是一只狗,您也无法访问a->Bark(),即使Dog::Bark()存在。d->那就行了。

    将vtable添加回图片中,假设Animal的接口有Animal::Move a generic Move(),并且该狗确实被Dog::Move(){像狗一样}覆盖。

        8
  •  -1
  •   Shtong    16 年前

    它在运行时没有实际的区别,因为这两个实例是相同的。唯一的区别是在编译时,您可以调用例如d->树皮(),但不是a->吠叫(),即使一只狗实际上有一只狗。编译器将变量视为动物,仅此而已。