让我们假设我使用动态数组分配来实现Stack。 我有以下课程及其功能。
Data.h
class Data
{
public:
Data(std::string fname, int age) : name(fname) , age(age) {}
private:
std::string name;
int age;
}
StackArray.h
#include "Data.h"
class StackArray
{
public:
StackArray(int sSize) : size(sSize), top(-1)
{
DataArray = new Data[size];
};
~StackArray() { delete[] DataArray; };
StackArray& operator=(StackArray& StackArrayObj) { //use copy&swap here };
Stack(const StackArray& StackArrayObj);
bool isFull();
bool isEmpty();
void push(Data& DataObj);
void pop();
private:
Data* DataArray;
int top;
int size;
}
如果我实现上述内容,它可以很好地工作。但是最近,我被要求按原样实现上述两个,然后对核心功能进行单独的实现。
现在,如果我将push
,pop
,isFull
,isEmpty
移到新的堆栈定义中,class StackArray
的目的究竟是什么? implemtation?
我尝试过的两个解决方案如下:
New class implemtation
class StackADT
{
public:
StackADT();
virtual ~StackADT() = 0;
virtual bool isFull() = 0;
virtual bool isEmpty() = 0;
virtual void push(Data& DataObj) = 0;
virtual void pop() = 0;
}
然后,通过从StackArray
类扩展该类,从而强制它实现所有纯虚函数。
我做过的第二个但不那么优雅(我的意见)的方式是:
我在StackADT
中有一个完整的Stack定义和实现,然后在StackArray
中的等效方法中调用相应的方法。像这样:
StackADT - push
bool StackADT::push(const Data& DataObj)
{
if(!isFull)
return false;
else
{
top++;
DataArray[top] = DataObj;
}
return true;
}
然后在StackArray - push
内,我会做这样的事情:
bool StackArray::push(const Data& DataObj)
{
StackADT doPush;
doPush.push(DataObj);
}
不太确定将这三个类 - 数据,容器和堆栈 - 组合在一起的两种方法都是他们想要的。
如何解决此设计问题?或至少将其与最佳实践"如果有的话。
答案 0 :(得分:7)
当我们谈论抽象时,我们应该尝试确定我们试图实现的核心方面。通常,这些方面可以表示为接口。
由于在C ++中,与Java等其他语言不同,我们没有特定的接口声明语法,我们可以使用纯虚拟类。
一般来说,堆栈是遵循LIFO访问结构的数据结构,仅此而已。
即使受到内存量的限制,我也没有看到任何理由为什么基本堆栈最初应该有一个大小限制。一种更抽象的思考大小限制的方法是验证堆栈是否接受更多元素,或者可以通过pop
调用提供和元素。
因此,我们可能会考虑如下堆栈基本接口:
class Stack {
public:
virtual ~Stack()=0;
virtual Data& pop() throw (std::out_of_range) = 0;
virtual void push(Data&) throw (std::out_of_range) = 0;
virtual bool isPoppable() = 0;
virtual bool isPushable() = 0;
}
然后现在我们可以开始考虑实现了。一个简单的实现就是使用数组:
class StackArray : public Stack {
private:
Data* mArray;
int mSize;
int mPointer;
StackArray(int size) : mSize(size), mPointer(0) {
mArray = new Data[mSize];
}
virtual ~StackArray() {
delete [] mArray;
}
public:
void push(Data& el) throw (std::out_of_range) {
if (!isPushable()) throw std::out_of_range("Cannot push to this stack");
mArray[mPointer++] = el;
}
Data& pop() throw (std::out_of_range) {
if (!isPopable()) throw std::out_of_range("Cannot pop from this stack");
return mArray[mPointer--];
}
bool isPushable() {
return mPointer < mSize;
}
bool isPoppable() {
return mPointer > 0;
}
}
更进一步,我们可以想到一个基于链表的堆栈:
class DataNode {
private:
DataNode* next;
Data* data;
public: // trivial impl. ommited
bool hasNext();
DataNode* getNext();
Data* getData();
void setNext(DataNode* next);
void setData(Data* data);
}
class StackLinkedList : public Stack {
private:
DataNode* root;
public:
StackLinkedList():pointer(0) {}
virtual ~StackLinkedList() {}
void push(Data& el) throw (std::out_of_range) {
if (!isPushable()) throw std::out_of_range("Cannot push to this stack");
DataNode* n = new DataNode();
n->setData(&el);
DataNode* pointer = root;
if (root == NULL) {
pointer = n;
} else {
while (pointer->hasNext()) {
pointer = pointer->getNext();
}
pointer->setNext(n);
}
}
Data& pop() throw (std::out_of_range) {
if (!isPoppable()) throw std::out_of_range("Cannot pop from this stack");
DataNode* pointer = root, previous = NULL;
while (pointer->hasNext()) {
previous = pointer;
pointer = pointer->getNext();
}
Data* ret = pointer->getData();
delete pointer;
if (previous != NULL) {
previous->setNext(NULL);
}
return *ret;
}
bool isPushable() {
return true;
}
bool isPoppable() {
return root != NULL;
}
}
答案 1 :(得分:4)
我理解你的练习可以让你思考什么是一般堆栈(“核心堆栈功能”)以及它的具体实现。
所以你可以选择抽象类:
class StackADT
{
public:
... // pure virtual core function
}; // <= allways ; at end of class ;-)
会导致StackArray
作为具体实现:
class StackArray : public Stack ADT {
... // you can leave the rest as it is: the functions will override the virtual ones.
};
这一切的目的是什么?好吧,你完全可以想象实现StackLinkedList
或StackReallocArray
。优点是差异仅在于创造。创建堆栈后,使用它的代码是相同的,无论使用什么实现。
另一种方法可能是使用模板来概括堆栈的内容。而另一种方法是使用<stack>
,但我认为这不是(还)你锻炼的目标。