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

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

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

using namespace std;


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

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

    int pop()
    {
        require(top > 0, "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(0) {}

        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 = 0; i < 15; i++)
    {
        stack.push(i*3);
    }

    //----------------------
    cout << "Traverse the whole IntStack" << endl;
    
    IntStack::iterator it = stack.begin();
    int n=0;
    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 += 2; 
    end2 += 5; //在此，程序退出

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

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

    return 0;
};

 运行结果：

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

附模板化实现(cp406)：

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

StackTemplate.h

#ifndef STACKTEMPLATE_H
#define STACKTEMPLATE_H

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

    T stack[ssize];
    int top;

public:
    StackTemplate() : top(0) {}
    
    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 = 0; i < 5; i++)
    {
        intTempl.push(fibonacci(i));
    }
    for (int k = 0; k < 5; 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() > 0)
        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 0;
}

运行结果：

从运行结果可以看出，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对象。