c++ - 从只有纯虚函数的基类继承

Question

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

我对 C++ 完全陌生，我做的这个实现是一项家庭作业，我很难让它工作，当我终于做到时，我什至不确定我做对了，因为我不知道在这种情况下，看不出是否使用继承有什么区别。

欢迎任何关于我的代码的一般性评论或指示，以及良好的链接或其他 C++ 知识来源。我也提前为代码注释使用 Icelandic: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

...这是我的堆栈接口(interface) 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;
}

Answer 1

他们让你做的是实现一个接口(interface)。

这似乎是多余的，目前，在作业中，它或多或少是多余的。下面是一个示例，向您展示了它的用处。

您开始在您的代码中使用这个堆栈；但是因为你创建了一个接口(interface)，你传递了一个指向 fstackbase 的指针，它有你需要的所有方法。

现在，您意识到有时您需要一个基于 1000 数组的堆栈。没关系。然而，在代码的其他部分，您需要一个基于 std::vector 的堆栈。您创建另一个派生自 fstackbase 的类。它被迫实现那些相同的方法。在其余代码中，只需将实例化 fstack1 的一行更改为新类 fstack2。由于您定义并坚持使用您的界面，其余代码将编译并正常工作。

Dr Dobbs article on interfaces