Question

我有一个名为fstackbase.h的类接口，我正在创建一个简单的堆栈fstack1，它继承自fstackbase。 fstackbase.h中的所有函数都是纯虚函数，我必须在我的fstack1.h中实现它们。我的问题是，如何将其视为继承？我在fstackbase.h中重写每个函数声明，然后在fstack1.cpp中实现它们。如果我一起跳过fstackbase.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;
}

Answer 1

他们所做的就是实现一个界面。

这似乎是多余的，目前，在任务中，它或多或少都是。这是一个示例，向您展示它可能有用。

您开始在代码中使用此堆栈;但是由于你创建了一个接口，你传递一个指向fstackbase的指针，它具有你需要的所有方法。

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

Dr Dobbs article on interfaces

Answer 2

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

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

多态性
继承功能

在这种情况下，由于您没有继承基类中的任何功能，因此您可能正在为多态进行此操作。

如果您只有1个基类和1个子类，那么您无法真正看到它的好处。但请考虑一下：

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);

这当然只是一个例子，但你可以在这里轻松阅读很多关于继承的内容。

Answer 3

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

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

仅使用纯虚函数从基类继承

3 个答案: