标签：
模拟如下情况：
某人将一车文件交给plodson，如果plodson的收取蓝是空的，他将取出车中最上面的文件，将它放入收
取蓝，如果收取蓝是满的，他将取出栏中最上面的文件，并进行处理，然后放入发出蓝，如果收取蓝不空不满
plodson将采用抛硬币的方式来决定采取措施。1 #ifndef STACK_H_ 2 #define STACK_H_ 3 4 //定义类模板 5 template 6 class Stack 7 { 8 private: 9 enum{SIZE=10}; 10 int stacksize; 11 //新增的成员 12 Type* items; 13 int top; 14 public: 15 //explicit构造函数是用来防止隐式转换的 16 explicit Stack(int ss=SIZE); 17 Stack(const Stack& st); 18 ~Stack(){delete [] items;} 19 bool isempty() {return top==0;} 20 bool isfull() {return top==stacksize;} 21 bool push(const Type& item); 22 bool pop(Type& item); 23 //重载赋值运算符_返回对象的引用 24 Stack & operator=(const Stack& st); 25 }; 26 template < typename Type> 27 Stack< Type>::Stack(int ss):stacksize(ss),top(0) 28 { 29 items=new Type[stacksize]; 30 }； 31 template < typename Type > 32 Stack< Type>::Stack(const Stack& st) 33 { 34 stacksize=st.stacksize; 35 top=st.top; 36 //重要代码 37 items = new Type [stacksize]; 38 for(int i=0;i< typename Type> 39 bool Stack< Type>::push(const Type& item) 40 { 41 if(top< typename Type> 42 bool Stack< Type>::pop(Type& item) 43 { 44 if(top>0) 45 { 46 item = items[--top]; 47 return true; 48 } 49 else 50 return false; 51 } 52 53 template< typename Type> 54 Stack< Type>& Stack< Type>::operator =(const Stack< Type>& st) 55 { 56 if(this==&st) 57 return *this; 58 delete [] items; 59 stacksize=st.stacksize; 60 top=st.top； 61 items=new Type [stacksize]; 62 for(int i=0;i< top;i++) 63 { 64 items[i]=st.items[i]; 65 } 66 return *this; 67 } 68 #endif
问题一：
explicit只对构造函数起作用是用来防止隐式转换的,这里引用(博客园中总结好的笔记
按照默认规定，带有一个参数的构造函数也定义了一个隐式转换，将该构造函数对应数据类型的数据转换为该类对象，如下面所示
1 class String { 2 String ( const char* p ); // 用C风格的字符串p作为初始化值 3 //… 4 } 5 String s1 = “hello”; //OK 隐式转换，等价于String s1 = String（“hello”）;
但是有的时候可能会不需要这种隐式转换，如下：
1 如下代码： 2 class String { 3 String ( int n ); //本意是预先分配n个字节给字符串 4 String ( const char* p ); // 用C风格的字符串p作为初始化值 5 //… 6 } 7 8 下面两种写法比较正常： 9 String s2 ( 10 ); //OK 分配10个字节的空字符串 10 String s3 = String ( 10 ); //OK 分配10个字节的空字符串 11 12 13 下面两种写法就比较疑惑了： String s4 = 10; //编译通过，也是分配10个字节的空字符串 14 String s5 = ‘a’; //编译通过，分配int（‘a’）个字节的空字符串
s4 和s5 分别把一个int型和char型，隐式转换成了分配若干字节的空字符串，容易令人误解。 为了避免这种错误的发生，我们可以声明显示的转换，使用explicit 关键字：
1 class String { 2 explicit String ( int n ); //本意是预先分配n个字节给字符串 3 String ( const char* p ); // 用C风格的字符串p作为初始化值 4 //… 5 } 6 加上explicit，就抑制了String ( int n )的隐式转换， 7 8 下面两种写法仍然正确： 9 String s2 ( 10 ); //OK 分配10个字节的空字符串 10 String s3 = String ( 10 ); //OK 分配10个字节的空字符串 11 12 下面两种写法就不允许了： 13 String s4 = 10; //编译不通过，不允许隐式的转换 14 String s5 = ‘a’; //编译不通过，不允许隐式的转换
问题二：
1 重载赋值运算符函数原型如下： 2 Stack & operator=(const Stack& st); 3 重载赋值运算符函数实现如下： 4 template< typename Type> 5 Stack< Type>& Stack< Type>::operator =(const Stack< Type>& st) 6 { 7 //判断 8 if(this==&st) 9 return *this; 10 //清楚内存区域 11 delete [] items; 12 stacksize=st.stacksize; 13 top=st.top； 14 items=new Type [stacksize]; 15 for(int i=0;i< top;i++) 16 { 17 items[i]=st.items[i]; 18 } 19 return *this; 20 } 21 类型为什么不同？
主函数
1 #include< iostream> 2 //随机数的处理 3 #include< stdlib.h> 4 #include< time.h> 5 #include"stack.h" 6 7 8 const int NUM=10; 9 10 int main() 11 { 12 //随机数 13 srand(time(0)); 14 std::cout<< "请输入篮子的大小: "; 15 int stacksize; 16 std::cin>>stacksize; 17 //使用构造函数进行初始化, 18 //实例化模板 19 Stack< const char*> st(stacksize); 20 21 //文件车 22 //指针数组的初始化 23 const char * in[NUM]={ 24 "1:ru pengkun","2:haung weijun", 25 "3:liu xinxiang","4:yang dongpeng", 26 "5:mule","6:liudanqing", 27 "7:du zhuoheng","8:wang mingqin", 28 "9:shang yanan","10:ru jie" 29 }; 30 31 //发出篮 32 const char* out[NUM]; 33 int processed=0;//#include 34 //随机数的处理 35 #include 36 #include 37 #include"stack.h" 38 39 40 //限定收取篮和发出篮的大小 41 const int NUM=10; 42 43 int main() 44 { 45 //随机数 46 srand(time(0)); 47 std::cout<<"请输入篮子的大小: "; 48 int stacksize; 49 std::cin>>stacksize; 50 //使用构造函数进行初始化, 51 //实例化模板 52 Stack st(stacksize); 53 54 //初始化数组 55 //确保常量不被修改 56 //记住指针数组的初始化方法 57 const char * in[NUM]={ 58 "1:ru pengkun","2:haung weijun", 59 "3:liu xinxiang","4:yang dongpeng", 60 "5:mule","6:liudanqing", 61 "7:du zhuoheng","8:wang mingqin", 62 "9:shang yanan","10:ru jie" 63 }; 64 65 //发出篮 66 const char* out[NUM]; 67 int processed=0;//用来记录发出篮的文件数量 68 int nextin=0;//索引文件车的文件 69 while(processed < NUM)//如果发出篮的文件数小于发出篮的容量，就会继续循环 70 { 71 if(st.isempty())//取出篮为空 72 st.push(in[nextin++]); 73 //从文件车拿取索引号为0的文件存入取出篮，索引号+1； 74 else if(st.isfull())//取出篮已满 75 st.pop(out[processed++])； 76 //对取出篮(栈)执行出栈操作，并存入发出篮，用来记录发出篮的文件数量的变量+1； 77 else if(rand()%2 && nextin< NUM) 78 st.push(in[nextin++]); 79 else 80 st.pop(out[processed++]); 81 } 82 for(int i=0;i< NUM;i++) 83 { 84 std::cout << out[i] << std::endl; 85 } 86 87 return 0; 88 }
注意深拷贝和重载赋值符概念
标签：
原文地址：http://www.cnblogs.com/rupengkun/p/4575544.html
