模板类的正确使用

用的string实例化,但是为了达到这个目的,不能随便用模板的内容.

比如:

Stack st;

如果想达到字符串的效果,若把模板类中的string po;更换为char * po,是绝对错误的,因为没有给po分配空间,无法达到字符串的效果.

更换为char po[40],也不行,po是char型,是数组名,是不能被赋值的,pop(char & item),从容器中弹出的内容是不能赋值给数组名.

换成动态分配char * po = new char [40],每次都是指同一快内存,根本就没有保存字符串内容,没有意义.

正确使用指针栈

是用指针栈必须让程序调用一个指针数组,每一个指针都指向各自的字符串,这些放在指针栈中是有意义的.

例如,假设模拟一个那文件的情况.

一个人从车中拿文件,如果收取蓝(in - basket)是空的,就放入收取蓝(in - basket),如果收取蓝是满的,将取出收取蓝中最上面的文件放入发出蓝(out - basket),如果收取蓝既不是空又不是满,随机选择,可能从车中拿文件放入收取蓝(in - basket),可能从收取蓝(in - basket)放入发出蓝(out - basket).

解决方法:

用指针指向车中文件(用字符串表达),车上文件是一个指针数组,栈当成收取蓝(in - basket),使用第二个指针数组当成发出蓝(out - basket).假设栈大小是可变的.

类模板及实现如下:

template <typename Type>
	class Stack
	{
	private:
	    enum {SIZE = 10};    // 默认栈大小
	    int stacksize;
	    Type * items;       // 用动态分配的方式
	    int top;            // 栈顶元素的位置
	public:
	    explicit Stack(int ss = SIZE);		// 防止隐式转换
	    Stack(const Stack & st);		// 重写复制构造函数,深度复制
	    ~Stack() { delete [] items; }
	    bool isempty() { return top == 0; }
	    bool isfull() { return top == stacksize; }
	    bool push(const Type & item);   // 进栈
	    bool pop(Type & item);          // 出栈
	    Stack & operator=(const Stack & st);	// 重写赋值运算符,深度复制
	};

	template <typename Type>
	Stack<Type>::Stack(int ss) : stacksize(ss), top(0)
	{
	    items = new Type [stacksize];
	}

	template <typename Type>
	Stack<Type>::Stack(const Stack & st)
	{
	    stacksize = st.stacksize;
	    top = st.top;
	    items = new Type [stacksize];
	    for (int i = 0; i < top; i++)
		items[i] = st.items[i];
	}

	template <typenameType>
	bool Stack<Type>::push(const Type & item)
	{
	    if (top < stacksize)
	    {
		items[top++] = item;
		return true;
	    }
	    else
		return false;
	}

	template <typename Type>
	bool Stack<Type>::pop(Type & item)
	{
	    if (top > 0)
	    {
		item = items[--top];
		return true;
	    }
	    else
		return false;
	}

	template <typenameType>
	Stack<Type> & Stack<Type>::operator=(const Stack<Type> & st)
	{
	    if (this == &st)
		return *this;
	    delete [] items;
	    stacksize = st.stacksize;
	    top = st.top;
	    items = new Type [stacksize];
	    for (int i = 0; i < top; i++)
		items[i] = st.items[i];
	    return *this;
	}

测试函数如下:

const int Num = 10;
	int main()
	{
	    std::srand(std::time(0)); 		// 使随机数真正随机
	    std::cout << "Please enter stack size: ";
	    int stacksize;
	    std::cin >> stacksize;
	// 创造一个指针栈的容器类,类中存放char*
	    Stack<const char *>  st(stacksize);		// 收取篮(in-basket)

	    const char * in[Num] = {
		    " 1: Hank Gilgamesh", " 2: Kiki Ishtar",
		    " 3: Betty Rocker", " 4: Ian Flagranti",
		    " 5: Wolfgang Kibble", " 6: Portia Koop",
		    " 7: Joy Almondo", " 8: Xaverie Paprika",
		    " 9: Juan Moore", "10: Misha Mache"
		    };		// 指针数组的各个字符串表示车中文件
	 
	    const char * out[Num];		// 发送篮(out basket)

	    int processed = 0;		 // 发送篮文件位序
	    int nextin = 0;		// 车上文件位序
	    while (processed < Num)
	    {
		if (st.isempty())
		    st.push(in[nextin++]);		// 空收取篮,从车中拿出文件放入发出篮
		else if (st.isfull())
		    st.pop(out[processed++]);		// 满收取篮,从收取篮最上面拿出文件给发送篮
		else if (std::rand() % 2  && nextin < Num)   // %2表示随机取0或1,1代表从车中拿文件放入收取上面,0代表从收取篮拿出文件放入发送篮
		    st.push(in[nextin++]);
		else
		    st.pop(out[processed++]);
	    }
	    for (int i = 0; i < Num; i++)
		std::cout << out[i] << std::endl;
	    std::cout << "Bye\n";
	    return 0;
	}

测试结果如下:

3. 默认类型参数

template ,若T2没有指明是那种类型,默认是int

例如:

template <typename T1 , typename T2 = int>
class Test
{...}

Test<double> 	test1;