/*

 * stacktp.h

 *

 *  Created on: 2014年3月29日

 *      Author:

 */

/**

 *    - 模板类的概念，与使用

 *        -# export template <class Type>

 *          <li> export 关键字表示导出这个模板类,使用此关键，使得可以把

 *                 模板类的声明放在头文件中，而定义分开放在.cpp的文件中.

 *               有些编译器没有实现此关键字，因此必须把定义与声明放在头文件中

 *               否则编译通不过

 *          </li>

 *          <li> template 关键字，表示声明一个模板类</li>

 *          <li> <class Type> 表示要传给这个模板类的参数

 *               class 这个关键字，表示参数的类型,这个关键字可以用 Typename这个关键字替代

 *               Type 是参数的名字，也即变量名.C++习惯上用T表示

 *               关键理解:

 *                我们要抓住："模板"和"模板类"这两个概念. 有句话叫:依葫芦画飘瓢。意思是说按照葫芦的样子画瓢。

 *                用来类比的话就是说"模板"对应那个葫芦，"类"对应那个瓢.同理，模板类的意思是告诉C++编译器按

 *               照模板类来生成具体的类代码。具体的类代码的函数和算法是相同的，不同的部分就是 <class Type>

 *              指定的那部分,这部分是编译器要按照我们使用时指定的参数的不同，编译时生成相应的代码，不再需要

 *              手写和粘贴复制了.编译器在帮程序员偷懒(从小的角度来看)，提高一个层次来看，就叫通用编程.就是说

 *        编写一段通用的代码，传入什么的样的参数，就生成相应用的具体代码。从数学的角度来说，就是写了一个

 *        公式或者说函数;不同的取值范围和具体的量化，产生不同的结果。比如y=a+k(x),假如a,k是常量，根据x

 *        的取值不同，相应的y也不同。从这里来理解,用模板写一些算法性质的代码，那简值太妙了，特别是一些常用的

 *        算法,可以少死很多脑细胞.

 *          </li>

 *   -此类来自于C++ primer Plus(第五版)第14章

 *          -# 模拟实现一个堆栈,栈空间最大为10

 *

 *

 */

#ifndef STACKTP_H_

#define STACKTP_H_

// export template <class Type>

template <class Type>

class Stack

{

private:

    enum{MAX =};

    Type items[MAX];

    int top;

public:

    Stack();

    bool isempty();

    bool isfull();

    bool push (const Type & item);

    bool pop (Type & item);

};

 /**

  *下面的书写形式，要讲一下

  *template <class Type> //这一部分参考头文件的说明

  *    Stack<Type>::Stack()//这里要说一下

  *    Stack :表示模板类的类名

  *    <Type>:表示传给这个模板类的类型类参数,

  *           编译器根据它的意思来生成具体的代码.如终强调一点，我们写的是

  *           模板代码。注意"模板"两字。

  *    ::Stack():表示是Stack<Type>这个模板类的构造方法.

  *    回固一下知识。如果我们自己写了构造函数。那么C++编译器，就不会在编译时偷偷的生成默认构造函数了.

  *

  */

 template <class Type>

 Stack<Type>::Stack()

 {

     top =;

 }

 template <class Type>

 bool Stack<Type>::isempty()

 {

     return top == ;

 }

 template <class Type>

 bool Stack<Type>::isfull()

 {

     return top == MAX;

 }

 template <class Type>

 bool Stack<Type>::push(const Type &item)

 {

     if(top < MAX){

         items[top++] = item;

         return true;

     }

     else{

         return false;

     }

 }

 template <class Type>

 bool Stack<Type>::pop(Type & item)

 {

     if(top>){

         item = items[--top];

         return true;

     }

     else{

         return false;

     }

 }

#endif /* STACKTP_H_ */

//============================================================================

// Name        : TemplateClass_1.cpp

// Author      :

// Version     :

// Copyright   : Free

// Description : Hello World in C++, Ansi-style

//============================================================================

#include <iostream>

#include <cstring>

#include <cctype>

using namespace std;

#include "stacktp.h"

int main() {

    /**

     *    注意:[1]

     *    我们传了std::string这个类型给Stack模板类

     *    编译器是如何知道Stack是个模板类呢，或者说我们是如何确

     *    Stack是个模板类呢，而不是普通的类呢。注意"<>"这对尖括号

     *    它表示类Stack还要接受一个类型参数，所以我们从这里确定的。

     *    编译器也是通过<>来识别的。我们其实可以想象普通的非模板类，

     *    也有一对尖括号的，也接受了一个参数，只是这个参数在非模板类

     *    的定义里面没有用到，没有使用这个参数，所以传了也没有用。

     *    这样一想，可以在概念上把非模板类和模板类统一认为是模板类了。

     *    非模板类，是模板类的一个子集。

     *    注意:[2]

     *    Stack<std::string> st; //这里虽然只写了一句，但实际编译后不只是这句话，

     *    而是如下一段代码:

     *  Stack<std::string> st = new Stack();

     *  但是这里有个前提条件，我们必须有一个默认构造函数，否则C++编译器不知道，怎样

     *  初始化这个st对象。而报语法错误.

     *  而在Java中，定义的对象都是引用。必须要new才会初始化.

     *  因此我们要记住一点，在面向对象的世界里，所有的对象都要有初值，要有一个确定的状态.

     *  如果允许，对象有不确定的状态，那么就没有那么了...

     *

     */

    Stack<std::string> st;

    char ch;

    std::string po;

    cout <<"Please enter A to add a purchase order,\n"

         << "P to process a PO,or Q to quit.\n";

    while(cin >> ch && std::toupper(ch)!= 'Q')

    {

        while(cin.get()!='\n')

            continue;

        if(!std::isalpha(ch))

        {

            cout<< '\a';

            continue;

        }

        switch(ch)

        {

        case 'A':

        case 'a':

            cout <<"Please Enter a PO number to add:";

            cin>>po;

            if(st.isfull())

            {

                cout << "stack already full\n";

            }

            else

            {

                st.push(po);

            }

            break;

        case 'P':

        case 'p':

            if(st.isempty())

            {

                cout << "stack already empty\n";

            }

            else

            {

                st.pop(po);

                cout << "PO # "<<po<<" popped\n";

            }

            break;

        }

        cout <<"Please enter A to add a purchase order,\n"

                 << "P to process a PO,or Q to quit.\n";

    }

    cout<< "Bye\n";

    return ;

}