堆（stack） 之 c 和 c++模板实现（空类默认成员函数 初谈引用 内联函数）

//stack 的基本操作
#include <iostream>
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 true
bool is_empty()
{
    return (top == 0);
}
// if stack is full return true
bool is_full()
{
    return (top == maxn);
}
// pop the top number if not empty
int 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 full
void 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 pop
int 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<iostream>
#include<string>
using namespace std;
//用"链表"实现栈
//入栈，出栈的时间复杂度为O(1)
//复制、清空和遍历栈的时间复杂度为O(n)
template<class DT>
//typedef struct Node// template 中不能用typedef
struct Node
{
    DT info;
    Node<DT> *next;
};

template<class DT>
class Stack
{
    public:
        Stack():top(NULL) {};// 初试化top的构造函数...初始化的默认方式
        Stack(const Stack<DT> &original);
        ~Stack();
        Stack<DT> &operator = (const Stack<DT> &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<DT> *top,*pre;// 私有成员,指向当前成员，指向链表的头
        inline void deepCopy(const Stack<DT> &original);//深复制
};

template<class DT>
Stack<DT>::Stack(const Stack<DT> &original)
{
    deepCopy(original);
}

template<class DT>
Stack<DT>::~Stack()
{
    make_empty();// 直接条用类里面的函数
}

template<class DT>
void Stack<DT>::push(const DT &element)
{
    pre = new Node<DT>;
    pre->info = element;
    pre->next = top;
    top = pre;
}// 前插入法，top指向链表的头结点

template<class DT>
Stack<DT>& Stack<DT>::operator =(const Stack<DT> &original)
{
    deepCopy(original);
    return this;
}// 运算符重载函数，返回的是引用
template<class DT>
bool Stack<DT>::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<class DT>
bool Stack<DT>::peek(DT &top_element)
{
    if(top == NULL)
        return false;
    else
    {
       top_element = top->info;
    }
    //cout << "***peek" << endl;
    return true;
}
template<class DT>
bool Stack<DT>::is_empty() const
{
    return (top == NULL);
}
template<class DT>
void Stack<DT>::make_empty()
{
    if(top == NULL)
        return;
    while(top != NULL)
    {
       pre = top;
       top = top->next;
       delete pre;
       pre = NULL;
    }
}
template<class DT>
void Stack<DT>::deepCopy(const Stack<DT> &original)
{
    Node<DT> *oriPtr = original.top;
    Node<DT> *copyPtr = top = new Node<DT>;
    copyPtr->info = oriPtr->info;
    while(oriPtr->next != NULL)
    {
        copyPtr->next = new Node<DT>;// 经典！！！
        copyPtr = copyPtr->next;
        oriPtr = oriPtr->next;
        copyPtr->info = oriPtr->info;
    }
    copyPtr->next = NULL;
}

int main()
{
	Stack<string> 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<<strTemp<<",";
	}
	cout<<endl;
	Stack<string> obj1(obj);  //測试复制构造函数
	for(size_t ix=0;ix!=5;++ix)
	{
		obj1.pop(strTemp);
		cout<<strTemp<<",";
	}
	cout<<endl;

	if(obj1.is_empty())
		cout<<"Stack is empty!"<<endl;
	Stack<string> obj2(obj); //測试复制构造函数
	obj2.make_empty();
	if(obj2.is_empty())
		cout<<"Stack is empty!"<<endl;
	Stack<string> obj3 = obj;    //測试重载“=”操作符
	for(size_t ix=0;ix!=5;++ix)
	{
		obj3.pop(strTemp);
		cout<<strTemp<<",";
	}
	cout<<endl;

	for(size_t ix=0;ix!=5;++ix)
	{
		obj.pop(strTemp);
		cout<<strTemp<<",";
	}
	cout<<endl;
	return 0;
}

/*

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

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

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

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

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

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

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

*/