IntStack(存放int型值，带迭代器) 附模板化实现 p406

1 该栈只用于存在int型数据

 #include "../require.h"
 #include <iostream>

 using namespace std;

 class IntStack
 {
     enum { ssize =  };
     int stack[ssize];
     int top;

 public:
     IntStack() : top() {}
     void push(int i)
     {
         require(top < ssize, "Too many push()es");
         stack[top++] = i; //int型元素，通过赋值运算符，直接存入IntStack栈内部的 int stack[]数组中
     }

     int pop()
     {
         require(top > , "Too many pop()s");
         return stack[--top];
     }

     class iterator;
     friend class iterator;

     class iterator
     {
         IntStack& intStack;
         int index;

     public:

         iterator(IntStack& is) : intStack(is), index() {}

         iterator(IntStack& is, bool) : intStack(is), index(is.top) {}

         // 返回迭代器当前位置的元素
         int current() const
         {
             return intStack.stack[index];
         }

         // ++i
         int operator++()
         {
             require(index < intStack.top, "iterator moved out of range");
             return intStack.stack[++index];
         }

         // i++
         int operator++(int)
         {
             require(index < intStack.top, "iterator moved out of range");
             return intStack.stack[index++];
         }

         // i += 2;
         iterator& operator+=(int amount)
         {
             require(index + amount < intStack.top, "IntStack::iterator::operator+=() tried to moved out of bounds");
             index += amount;
             return *this;
         }

         bool operator==(const iterator& rv) const
         {
             return index == rv.index;
         }

         bool operator!=(const iterator& rv) const
         {
             return index != rv.index;
         }

         friend ostream& operator<<(ostream& os, const iterator& it);
     };

     iterator begin()
     {
         return iterator(*this);
     }

     iterator end()
     {
         return iterator(*this, true);
     }
 };

 // 重载 << 运算符  -- 全局的
 ostream& operator<<(ostream& os, const IntStack::iterator& it)
 {
     return os << it.current();
 }

 int main()
 {
     IntStack stack;
     for (int i = ; i < ; i++)
     {
         stack.push(i*);
     }

     //----------------------
     cout << "Traverse the whole IntStack" << endl;

     IntStack::iterator it = stack.begin();
     int n=;
     while (it != stack.end())
     {
         cout << n++ << ": " << it++ << endl;
     }

     //----------------------------------
     cout << "Traverse a portion of the IntStack" << endl;

     IntStack::iterator start = stack.begin(), end2 = stack.end();
     start += ;
     end2 += ; //在此，程序退出

     cout << "start = " << start << endl;
     cout << "end = " << end2 << endl;

     while (start != end2)
     {
         cout << start++ << endl;
     }

     return ;
 };

运行结果：

----------------------------------------

附模板化实现(cp406)：

容器中放的是值对象，通过重载后的=运算符完成对象数据成员的拷贝（只做了这一层，算是浅拷贝）

StackTemplate.h

 #ifndef STACKTEMPLATE_H
 #define STACKTEMPLATE_H

 template<class T>
 class StackTemplate
 {
     enum { ssize =  };

     T stack[ssize];
     int top;

 public:
     StackTemplate() : top() {}

     void push(const T& i)
     {
         stack[top++] = i;
     }

     T pop()
     {
         return stack[--top];
     }

     int size()
     {
         return top;
     }
 };
 #endif

测试文件

 #include "fibonacci.h"
 #include "StackTemplate.h"
 #include <iostream>
 #include <fstream>
 #include <string>
 #include "Book.h"

 using namespace std;

 int main()
 {

     cout << "---------- StackTemplate<int> ------------------" << endl;
     StackTemplate<int> intTempl;
     for (int i = ; i < ; i++)
     {
         intTempl.push(fibonacci(i));
     }
     for (int k = ; k < ; k++)
     {
         cout << intTempl.pop() << endl;
     }

     cout << "---------- StackTemplate<string> ------------------" << endl;

     StackTemplate<string> stringTempl;
     ifstream in("fibonacci.h");
     string line;

     while (getline(in, line))
         stringTempl.push(line);

     while (stringTempl.size() > )
         cout << stringTempl.pop() << endl;

     cout << "---------- StackTemplate<Book> ------------------" << endl;
     {
         StackTemplate<Book> books;

         Book bk1("算法精解", "Kyle Loudon", 56.2);
         Book bk2("Qt程序设计", "Pulat", 10.2);

         books.push(bk1);
         books.push(bk2);

     }

     return ;
 }

运行结果：

从运行结果可以看出，Book bk1("算法精解", "Kyle Loudon", 56.2);拷贝给了books.stack[0](地址，0018fc2c)； Book bk2("Qt程序设计", "Pulat", 10.2);拷贝给了books.stack[1](地址，0018fc54)

从调用Book类析构函数的顺序上看，bk2 --> bk1 --> books（books.stack[9] --> books.stack[8] ...... --> books.stack[1] --> books.stack[0]）

因为push参数是 const T& i使用的是引用（引用传递），所有元素入栈时没有产生新的Book对象。StackTemplate<Book>完全拥有Book对象，所以超出其作用域后，能够自动析构Book对象。