从只有纯虚拟函数的基类继承

Inheritance from base class with only pure virtual functions

本文关键字：基类 继承 函数 虚拟      更新时间：2023-10-16

我有一个名为fstackbase.h的类接口，我正在制作一个从fstackbase继承的简单堆栈fstack1。fstackbase.h中的所有函数都是纯虚拟的，我必须在fstack1.h中实现它们。我的问题是，这怎么能被认为是继承呢？我在fstackbase.h中重写了每个函数声明，然后在fstack1.cpp中实现它们。如果我一起跳过fstackbbase.h，我不会得到同样的结果吗？

我对c++完全陌生，我所做的这个实现是一项家庭作业，我很难让它发挥作用，当我最终做到这一点时，我甚至不确定我做得对，因为我看不出在这种情况下使用继承与否有什么区别。

欢迎任何关于我的代码的一般性评论或指针，以及c++知识的良好链接或其他来源。我也为代码注释使用冰岛语提前道歉：P。

这是基类fstackbase:

// fstackbase.h
#ifndef _FSTACKBASE_H
#define _FSTACKBASE_H
class fstackbase {
public:
// Notkun: delete p;
// Eftir:  Búið er að eyða hlaðanum *p.
virtual ~fstackbase() {};
// Notkun: x.Push(r);
// Fyrir:  fjöldi talna á hlaða x er minni en 1000.
// Eftir:  Búið er að setja r ofan á hlaðann x.
virtual void Push(double)=0;
// Notkun: r = x.Pop();
// Fyrir:  Hlaðinn x er ekki tómur.
// Eftir:  Búið er að fjarlægja efstu tölu af hlaðanum x,
//         og er hún í r.
virtual double Pop()=0;
// Notkun: n = x.Count();
// Eftir:  n inniheldur fjölda talna á hlaðanum x.
virtual long Count() const=0;
};
#endif

这是我的堆栈接口fstack1.h:

// fstack1.h    
#include "fstackbase.h"
#ifndef _FSTACK1_H
#define _FSTACK1_H
class fstack1 : public fstackbase {
private:
double *hladi;
long count;
// Fastyrðing gagna:
//   hladi bendir á array sem inniheldur tölurnar á hlaðanum.
//   count er fjöldi talna sem eru á hlaðanum.
public:
// Notkun: fstack1 f;
// Eftir:  f er nýr tómur hlaði, með
//         minnisrými fyrir 1000 double tölur.
fstack1();
// Notkun: fstack f = x;
// Fyrir:  x er gildi af tagi fstack1.
// Eftir:  f er nýtt eintak af fstack1 sem er
//         frumstillt sem afrit af x.
fstack1(const fstack1& x);
// Notkun: f = x;
// Fyrir:  f er breyta af tagi fstack1,
//         x er gildi af tagi fstack1.
// Eftir:  f hefur fengið nýtt gildi og inniheldur
//         nú afrit af gildinu x.
// virtual const fstack1& operator=(const fstack1& x);
// Erft frá fstackbase.h
~fstack1();
// Erft frá fstackbase.h
void Push(double d);
// Erft frá fstackbase.h
double Pop();
// Erft frá stackbase.h
long Count() const;
};
#endif

最后，这是我的堆栈在fstack1.cpp中的实现：

// fstack1.cpp
#include "fstackbase.h"
#include <iostream>    
using std::cout;
using std::endl;
fstack1::fstack1()
{
hladi = new double[1000];
count = 0;
}
fstack1::~fstack1()
{
delete[] hladi;
hladi = 0;
}
fstack1::fstack1(const fstack1& x)
{
delete[] hladi;
hladi = x.hladi;
count = x.count;
}
// const fstack1& fstack1::operator=(const fstack1& x)
// {
//  delete[] hladi;
//  hladi = x.hladi;
//  count = x.count;
//  return *this;
// }
void fstack1::Push(double d)
{
if (count < 1000) hladi[count++] = d;
else cout << "Hladi er fullur!" << endl;
}
double fstack1::Pop()
{
double temp = 0;
if (count) temp = hladi[--count];
else cout << "Hladi er tomur!" << endl;
return temp;
}
long fstack1::Count() const
{
return count;
}

他们让你做的就是实现一个接口。

这似乎是多余的，而就目前而言，在作业中，它或多或少是多余的。下面的一个例子向你展示了它可能是如何有用的。

您开始在代码中使用此堆栈；但是，由于您制作了一个接口，所以您需要传递一个指向fstackbase的指针，该指针拥有您所需要的所有方法。

现在，您意识到，有时您想要一个基于1000数组的堆栈，就像您所拥有的那样。没关系。然而，在代码的其他部分，您需要一个基于std:：vector的堆栈。您可以创建另一个派生自fstackbase的类。它被迫实施同样的方法。在剩下的代码中，只需要将实例化fstack1的一行更改为新类fstack2。由于您定义并坚持使用接口，因此其余代码将正确编译并工作。

多布斯博士关于接口的文章

我的问题是，如何将其视为继承？

好吧，您是从基类继承来创建一个子类。这就是继承的定义。您通常使用继承有两个主要原因：

  • 多态性
  • 继承功能

在这种情况下，由于您没有继承基类中的任何功能，因此您这样做可能是为了多态性。

如果你只有一个基类和一个子类，你就看不到它的好处。但考虑一下：

class os {
public:
virtual void start() = 0;
virtual void turn_off() = 0;
};
class mac : public os {
public:
virtual void start() { ... }
virtual void turn_off() { ... }
};
class windows : public os {
public:
virtual void start() { ... }
virtual void turn_off() { ... }
};

现在，您可以创建算法来处理继承自os:的任何操作系统

void mess_with(os& victim) {
while (42) {
victim.start();
victim.turn_off();
}
}

因此，您可以拨打：

mac x;
windows y;
mess_with(x);
mess_with(y);

这当然只是一个例子，但您很容易在这里阅读到很多关于继承的内容。

您实现了一个抽象基类，该基类定义了一个接口，该接口将由所有使用它的人继承，因此他们在实现中都必须遵循相同的接口。

如果你没有在派生类中使用继承，堆栈类的不同实现——所有代码都有不同的成员、类型等。

相关文章：