用一维数组实现栈（C++编程思想 p120）

1 实现思路

向栈中插入4个元素后的状态

执行过程分析：

2 代码实现

clib.h 接口定义

 typedef struct CStashTag
 {
     int ele_size;                    //栈中每个元素的占用的字节数
     int capacity;                    //栈的容量，栈当前（不扩展）可容纳的元素的个数
     int next;                        //相当于栈指针(标记下一个空位索引)，栈中当前元素的个数
     unsigned char* storage;            //栈存储空间字符指针，动态分配的字节数组
 } CStash;

 void initalize(CStash* s, int size);
 void cleanup(CStash* s);
 int add(CStash* s, const void* element);
 void* fetch(CStash* s, int index);
 int count(CStash* s);
 void inflate(CStash* s, int increase = );

2 Clib.cpp 函数实现

 #include <string>
 #include <iostream>
 #include <cassert>
 #include "clib.h"

 using namespace std;

 void initalize(CStash* s, int sz)
 {
     s->ele_size = sz;
     s->capacity = ;
     s->next = ;
     s->storage = ;
 }

 int add(CStash* s, const void* element)
 {
     if (s->next  >=  s->capacity)
     {
         inflate(s);
     }
     int startBytes = s->next * s->ele_size;
     unsigned char* e = (unsigned char*)element;

     for (int i=; i<s->ele_size; i++)
         s->storage[startBytes + i] = e[i];
     s->next++;

     return s->next - ;
 }

 //取出索引index处的栈元素
 void* fetch(CStash* s, int index)
 {
     assert( <= index);
     if (index >= s->next)
     {
         return ;
     }
     return &(s->storage[index * s->ele_size]);
 }

 //返回栈中元素的个数
 int count(CStash* s)
 {
     return s->next;
 }

 //扩展栈空间，增加increase个元素空间
 void inflate(CStash* s, int increase)
 {
     printf("inflate increase %d\n", increase);

     assert(increase > );

     //原栈长 + 增加的栈元素个数
     int newCapacity = s->capacity + increase;
     int newBytes = newCapacity * s->ele_size;   //新的栈空间字节数
     int oldBytes = s->capacity * s->ele_size;        //旧的栈空间字节数

     unsigned char* b = new unsigned char[newBytes]; //在堆上分配新的栈空间

     if (oldBytes)
     {
         //拷贝旧的栈空间的内容到新的栈空间，并释放旧的栈空间
         //把旧内存块中的数据拷贝到新分配的内存块
         for (int i=; i<oldBytes; i++)
             b[i] = s->storage[i];
         delete [] (s->storage); //释放旧的内存块
     }

     s->storage = b; //使栈存储空间字符指针s->storage指向新分配的内存块
     s->capacity = newCapacity; //更新栈的容量
 }

 //清理栈存储空间字符指针
 void cleanup(CStash* s)
 {
     if (s->storage != )
     {
         cout<<"freeing storage"<<endl;
         delete []s->storage;
     }
 }

 int main(int argc, char* argv[])
 {

     CStash stash;

     char str1[] = "d1111";
     char str2[] = "d2222";
     char str3[] = "d3333";
     char str4[] = "d4444";

     initalize(&stash, );

     add(&stash, str1);
     add(&stash, str2);
     add(&stash, str3);
     add(&stash, str4);

     unsigned char* result = (unsigned char*)fetch(&stash, );
     printf("fetch result %s\n", result);
　　　　
　　　　 cleanup(&stash);

     return ;
 };

输出：

inflate increase 10
fetch result d3333

freeing storage

向栈中存放int型数据测试：

 void intTest()
 {
     CStash intStash;

     initalize(&intStash, sizeof(int)); //栈中存放int型数据，所以栈元素占用int--4个字节

     int i;
     for (i=; i<; i++)
         add(&intStash, &i);

     for (i=; i<count(&intStash); i++)
         cout<< "fetch(&intStash, " << i << ") = " << *(int *) fetch(&intStash, i) <<endl;
     cleanup(&intStash);
 }

输出：

inflate increase 10
inflate increase 10
fetch(&intStash, 0) = 0
fetch(&intStash, 1) = 1
fetch(&intStash, 2) = 2
fetch(&intStash, 3) = 3
fetch(&intStash, 4) = 4
fetch(&intStash, 5) = 5
fetch(&intStash, 6) = 6
fetch(&intStash, 7) = 7
fetch(&intStash, 8) = 8
fetch(&intStash, 9) = 9
fetch(&intStash, 10) = 10
fetch(&intStash, 11) = 11
fetch(&intStash, 12) = 12
fetch(&intStash, 13) = 13
fetch(&intStash, 14) = 14
fetch(&intStash, 15) = 15
fetch(&intStash, 16) = 16
fetch(&intStash, 17) = 17
fetch(&intStash, 18) = 18
fetch(&intStash, 19) = 19
freeing storage

向栈中存放字符串（字符数组指针）测试：

 void stringTest()
 {
     CStash  stringStash;

     ifstream in;

     const int bufsize = ;
     initalize(&stringStash, sizeof(char) * bufsize);
     in.open("clib.h");
     assert(in);

     string line;
     while (getline(in, line))
     {
         add(&stringStash, line.c_str());
     }

     char *cp;
     int i = ;
     while ((cp = (char *) fetch(&stringStash, i++)) != )
     {
         cout<< "fetch(&stringStash, " << i << ") = " << cp << endl;
     }

     cleanup(&stringStash);
 }

输出：

inflate increase 10
inflate increase 10
fetch(&stringStash, 1) = typedef struct CStashTag
fetch(&stringStash, 2) = {
fetch(&stringStash, 3) = int ele_size; 　　　　　　//栈中每个元素的占用的字节数
fetch(&stringStash, 4) = int capacity; 　　　　　　//栈的容量，栈当前（不扩展）可容纳的元素的个数
fetch(&stringStash, 5) = int next; 　　　　　　　　//相当于栈指针(标记下一个空位索引)，栈中当前元素的个数
fetch(&stringStash, 6) = unsigned char* storage; //栈存储空间字符指针，动态分配的字节数组
fetch(&stringStash, 7) = } CStash;
fetch(&stringStash, 8) =
fetch(&stringStash, 9) = void initalize(CStash* s, int size);
fetch(&stringStash, 10) = void cleanup(CStash* s);
fetch(&stringStash, 11) = int add(CStash* s, const void* element);
fetch(&stringStash, 12) = void* fetch(CStash* s, int index);
fetch(&stringStash, 13) = int count(CStash* s);
fetch(&stringStash, 14) = void inflate(CStash* s, int increase = 10);
freeing storage

附C++实现：

1）Stash.h头文件

 #ifndef STASH_H_INCLUDED
 #define STASH_H_INCLUDED

 class Stash
 {
     int ele_size;                    //栈中每个元素的占用的字节数
     int capacity;                    //栈的容量，栈当前（不扩展）可容纳的元素的个数
     int next;                        //相当于栈指针(标记下一个空位索引)，栈中当前元素的个数
     unsigned char* storage;            //栈存储空间字符指针，动态分配的字节数组
     void inflate(int increase = );

 public:
     void initalize(int sz);
     int add(const void* element);
     void* fetch(int index);
     int count();
     void cleanup();
 };

 #endif // STASH_H_INCLUDED

2）Stash.cpp实现文件

 #include "Stash.h"
 #include <iostream>
 #include <cassert>

 using namespace std;

 void Stash::initalize(int sz)
 {
     ele_size = sz;
     capacity = ;
     next = ;
     storage = ;
 }

 int Stash::add(const void *element)
 {
     if (next >= capacity)
     {
         inflate();
     }

     int startBytes = next * ele_size;
     unsigned char *e = (unsigned char *) element;

     for (int i=; i<ele_size; i++)
     {
         storage[startBytes + i] = e[i];
     }
     next++;

     return next-;
 }

 void Stash::inflate(int increase)
 {
     cout << "inflate increase: " << increase << endl;

     assert(increase > );

     int newCapacity = capacity + increase;
     int newBytes = newCapacity * ele_size;
     int oldBytes = capacity * ele_size;

     unsigned char *b = new unsigned char[newBytes];

     if (oldBytes)
     {
         for (int i=; i<oldBytes; i++)
             b[i] = storage[i];
         delete []storage;
     }

     storage = b;
     capacity = newCapacity;
 }

 void* Stash::fetch(int index)
 {
     assert(index >= );
     if (index > next)
         return ;
     return &(storage[index * ele_size]);
 }

 int Stash::count()
 {
     return next;
 }

 void Stash::cleanup()
 {
     if (storage != )
     {
         cout << "freeing storage .... " << endl;
         delete []storage;
     }
 }

3）main.cpp测试类

 #include <iostream>
 #include <string>
 #include <fstream>
 #include "Stash.h"

 using namespace std;

 void intTest()
 {
     Stash intStash;

     intStash.initalize(sizeof(int)); //栈中存放int型数据，所以栈元素占用int--4个字节

     int i;
     for (i=; i<; i++)
         intStash.add(&i);

     for (i=; i<intStash.count(); i++)
         cout<< "intStash.fetch(" << i << ") = " << *(int *) intStash.fetch(i) <<endl;
     intStash.cleanup();
 }

 void stringTest()
 {
     Stash  stringStash;
     ifstream in;
     const int bufsize = ;

     stringStash.initalize(sizeof(char) * bufsize);
     in.open("Stash.h");

     string line;
     while (getline(in, line))
     {
         stringStash.add(line.c_str());
     }

     char *cp;
     int i = ;
     while ((cp = (char *) stringStash.fetch(i++)) != )
     {
         cout<< "stringStash.fetch(" << i << ") = " << cp << endl;
     }

     stringStash.cleanup();
 }

 int main()
 {

     //intTest();
     stringTest();

     return ;
 }