Question

我看到一些例子在基类函数中声明为纯函数（作为虚函数），在派生类中它被声明（作为虚拟）并实现。在第二种情况下（我目前正在做），基类不声明函数，只有派生类声明（非虚拟）和实现。这两个选项有什么区别？

Answer 1

在第一种情况下（并且通过派生类中的虚拟声明是多余的 - 继承虚拟化的方式），可以使用指针Base* p = new Derived()来调用p->the function。

在第二种情况下，您无法使用p调用该函数。您只能使用Derived* pp = new Derived()然后使用pp->the function。

Answer 2

如果基类根本没有声明函数，则无法通过基类的类型调用该函数。例如：

struct Base1
{
  virtual ~Base1() {}

  virtual void foo() const = 0;
};


struct Derived1 : Base1
{
  virtual void foo() const override { std::cout << "Foo!\n"; }
};

int main()
{
  Base1 *p = new Derived1();
  p->foo();  // Works fine
  delete p;
}

Vs以上。

struct Base2
{
  virtual ~Base2() {}
};


struct Derived2 : Base2
{
  virtual void foo() const { std::cout << "Foo!\n"; }
};

int main()
{
  Base2 *p = new Derived2();
  p->foo();  // Compiler error: no foo() in Base2
  delete p;
}

Answer 3

不同之处在于，在第一种情况下，你有 polimorphism ，在第二种情况下，你没有它。

考虑以下示例

第一种情况

#include <iostream>

struct B
{
   virtual void f() const = 0;
   virtual ~B() {}
};


struct D1
{
   void f() const { std::cout << "It's me, D1!" << std::endl; }
};


struct D2
{
   void f() const { std::cout << "No, it's me, D2!" << std::endl; }
};


void g( const B &b )
{
   b.f();
}

int main()
{
   D1 d1;
   g( d1 );

   D2 d2;
   g( d2 );
}

第二种情况

#include <iostream>

struct B
{
};


struct D1
{
   void f() const { std::cout << "It's me, D1!" << std::endl; }
};


struct D2
{
   void f() const { std::cout << "No, it's me, D2!" << std::endl; }
};


void g( const B &b )
{
   // b.f(); // compilation error
}


void g1( const D1 &d1 )
{
   d1.f();
}

void g2( const D2 &d2 )
{
   d2.f();
}

int main()
{
   D1 d1;
   g1( d1 );
   g( d1 ); // function f will not be called
   //g2( d1 ); // compilation error

   D2 d2;
   g2( d2 );
   g( d2 ); // function f will not be called
   //g1( d2 ); // compilation error
}

在派生类中定义函数而不在基类中声明

3 个答案: