//stack 的基本操作#include 
     
      using namespace std;const int maxn = 3;typedef struct Stack{    //NumType num;    int num;}Stack;int top = 0;//当前元素位置的上一个元素Stack stack[maxn];bool is_empty();bool is_full();int pop();void push(const int &key);int get_top();bool make_empty();int main(){    int tmp;    cout << get_top() << " " << pop() << endl;// 这句话和以下存在相同的错误    cout << "Input a set of integers:(-1 is over)" << endl;    while(cin >> tmp)    {        if(tmp == -1) break;        push(tmp);    }    tmp = get_top();    cout << tmp << endl;    tmp = pop();    cout << tmp << endl;    //cout << pop() << " " << get_top() << endl;    //cout << get_top() << " " << pop() << endl;// 这样输出会发生很奇异的事情的    return 0;}// if stack is empty return truebool is_empty(){    return (top == 0);}// if stack is full return truebool is_full(){    return (top == maxn);}// pop the top number if not emptyint pop(){    if(is_empty())    {        cout << "The Stack is empty,Cannot pop..." << endl;        return -1;    }    else    {        top --;        return stack[top].num;    }}// push one number,if not fullvoid push(const int &key){    if(is_full())    {        cout << "The Stack is full,Cannot push..." << endl;        return;    }    else    {        stack[top].num = key;        top ++;    }}// get the top number,not popint get_top(){    if(is_empty())    {        cout << "The Stack is empty,Cannot get top..." << endl;        return -1;    }    else    {        return stack[top-1].num;    }}bool make_empty(){    top = 0;}
     

/*

    学习心得：

    1、 此栈用链表实现，与上面的用数组实现不一样；用到了模板类Stack<DT>

    2、 此类用到了复制构造函数 Stack(const Stack<DT> &original),运算符重载函数

        Stack<DT>& operator = (const Stack<DT> &original)

    3、 初始化的默认构造方式Stack():top(NULL) {},记住类中声明的函数不能够有函数体的，

        可是空函数体（仅仅有{}）是能够的（即默认构造函数；全部的成员变量是不能够初试化的，

        可是能够通过默认构造函数初始化，如Stack():top(NULL) {}，或者定义为static。

    4、 &element引用作为參数时：（1）const Stack<DT> &original 作为不可变的变量的

        引用传递 （2）DT &top_element 函数的引用型參数作为返回值（能够实现多个返回值）

    5、 内联函数的引入，内联扩展是用来消除函数调用时的时间开销。它通经常使用于频繁

运行的函数。 一个小内存空间的函数非常受益，类似与宏定义，可是宏也有非常多的不尽人意的地方：

（1）宏不能訪问对象的私有成员。（2）宏的定义非常easy产生二义性。

    6、 template 和 typedef 不能同一时候使用的问题：模板不是类型！typedef仅仅能给

类型取别名。单独的Node是模板，而Node<int>是一个实实在在的类型。

usingkeyword能够给模板取别名！如:template<class T>

using Test = Node<T>;Test<int> t;

等价于:Node<int> t;

   7、 仅仅要定义了不论什么一种构造函数，就不会自己主动定义默认构造函数。假设此时要用到默认构造函数，

就必须手动定义默认构造函数。所谓默认构造函数，就是调用构造函数时，不必给出实參的构造函数。

   8、 假设一个类中定义了不论什么一种构造函数，而没有定义默认构造函数，是不可以定义类的对象的如：class A{}； A  aa;(这是错误的)

可是A *pa;(这是合法的，由于只定义了一个指针，没有调用不论什么构造函数，不分配类对象的内存)

9：写一个空类;class a(){}  编译的时候会生成哪些函数?

默认构造函数

析构函数

拷贝构造函数

赋值运算符（operator=）

取址运算符（operator&）（一对，一个非const的，一个const的）

当然，全部这些仅仅有当被须要才会产生。比方你定义了一个类，但从来定义过该类的对象，也没使用过该类型的函数參数，那么基本啥也不会产生。在比方你从来没有进行过该类型对象之间的赋值，那么operator=不会被产生。

最后那一对取址运算符是用争议的, 我记得曾经是有一个贴讨论这个的,据说跟详细的编译器相关, 有的生成, 有的不生成, 仅仅有前四个

*/

class Empty{public:               Empty();                  //   缺省构造函数               Empty(const   Empty&);    //   拷贝构造函数               ~Empty();                 //   析构函数               Empty&  perator=(const Empty&);  //   赋值运算符               Empty*  operator&();              //   取值运算符               const  Empty*  operator&()  const;   //   取值运算符};

以下是模板类：

#include
     
      #include
      
       using namespace std;//用"链表"实现栈//入栈，出栈的时间复杂度为O(1)//复制、清空和遍历栈的时间复杂度为O(n)template
       
        //typedef struct Node// template 中不能用typedefstruct Node{    DT info;    Node
        
          *next;};template
         
          class Stack{    public:        Stack():top(NULL) {};// 初试化top的构造函数...初始化的默认方式        Stack(const Stack
         
        
        
          &original);        ~Stack();        Stack
        
        
          &operator = (const Stack
        
        
          &original);        void push(const DT &element);        bool pop(DT &element);        bool peek(DT &top_element);// 得到栈顶的数据        bool is_empty() const;// is empty 没有满        void make_empty();    private:        Node
        
        
          *top,*pre;// 私有成员,指向当前成员，指向链表的头        inline void deepCopy(const Stack
        
        
          &original);//深复制};template
         
          Stack
         
        
        
         ::Stack(const Stack
        
        
          &original){    deepCopy(original);}template
         
          Stack
         
        
        
         ::~Stack(){    make_empty();// 直接条用类里面的函数}template
         
          void Stack
         
        
        
         ::push(const DT &element){    pre = new Node
        
        
         ;    pre->info = element;    pre->next = top;    top = pre;}// 前插入法，top指向链表的头结点template
         
          Stack
         
        
        
         & Stack
        
        
         ::operator =(const Stack
        
        
          &original){    deepCopy(original);    return this;}// 运算符重载函数，返回的是引用template
         
          bool Stack
         
        
        
         ::pop(DT &element){    if(top == NULL)        return false;    else    {       element = top->info;       pre = top;       top = top->next;       delete pre;       pre = NULL;    }    //cout << "*****pop" << endl;    return true;}template
         
          bool Stack
         
        
        
         ::peek(DT &top_element){    if(top == NULL)        return false;    else    {       top_element = top->info;    }    //cout << "***peek" << endl;    return true;}template
         
          bool Stack
         
        
        
         ::is_empty() const{    return (top == NULL);}template
         
          void Stack
         
        
        
         ::make_empty(){    if(top == NULL)        return;    while(top != NULL)    {       pre = top;       top = top->next;       delete pre;       pre = NULL;    }}template
         
          void Stack
         
        
        
         ::deepCopy(const Stack
        
        
          &original){    Node
        
        
          *oriPtr = original.top;    Node
        
        
          *copyPtr = top = new Node
        
        
         ;    copyPtr->info = oriPtr->info;    while(oriPtr->next != NULL)    {        copyPtr->next = new Node
        
        
         ;// 经典！！！        copyPtr = copyPtr->next;        oriPtr = oriPtr->next;        copyPtr->info = oriPtr->info;    }    copyPtr->next = NULL;}int main(){	Stack
         
           obj;// 模板类的构造函数	string str[5] = {"hello","the","world","welcome","to"};	string strTemp;	for(size_t ix=0;ix!=5;++ix)	{		obj.push(str[ix]);		obj.peek(strTemp);		cout<
          
           <<","; } cout<
           
             obj1(obj); //測试复制构造函数 for(size_t ix=0;ix!=5;++ix) { obj1.pop(strTemp); cout<
            
             <<","; } cout<
             
               obj2(obj); //測试复制构造函数 obj2.make_empty(); if(obj2.is_empty()) cout<<"Stack is empty!"<
              
                obj3 = obj; //測试重载“=”操作符 for(size_t ix=0;ix!=5;++ix) { obj3.pop(strTemp); cout<
               
                <<","; } cout<
               
              
             
            
           
          
         
        
       
      
     

/*

内联函数是使用inlinekeyword声明的函数，也成内嵌函数，它基本的作用是解决程序的执行

效率。使用内联函数的时候要注意：

1.递归函数不能定义为内联函数

2.内联函数一般适合于不存在while和switch等复杂的结构且仅仅有1~5条语句的小函数上，

否则编译系统将该函数视为普通函数。

3.内联函数仅仅能先定义后使用，否则编译系统也会把它觉得是普通函数。

4.对内联函数不能进行异常的接口声明。

*/