深拷贝 —— String类的实现

首先我们先来看看深浅拷贝的区别：浅拷贝是指将对象中的数值类型的字段拷贝到新的对象中，而对象中的引用型字段则指复制它的一个引用到目标对象。如果改变目标对象 中引用型字段的值他将反映在原是对象中，也就是说原始对象中对应的字段也会发生变化。深拷贝与浅拷贝不同的是对于引用的处理，深拷贝将会在新对象中创建一 个新的和原是对象中对应字段相同（内容相同）的字段，也就是说这个引用和原是对象的引用是不同的，我们在改变新对象中的这个字段的时候是不会影响到原始对 象中对应字段的内容。

代码如下：

[cpp] view plain copy

1. <strong><span style="font-size:18px;">#include<iostream>  
2. #include<cstring>  
3. using namespace std;  
4.   
5. class String  
6. {  
7.     friend ostream& operator<<(ostream& os, const String& s);  
8.       
9. public:  
10.     String (char* str="")  
11.         :_str(new char[strlen(str)+1+4]),_sz(strlen(str)),_capacity(strlen(str)+1)  
12.     {  
13.         strcpy(_str, str);  
14.     }  
15.     ~String()      //析构  
16.     {    
17.         if (_str != NULL)    
18.         {    
19.             delete[] _str;    
20.             _sz= 0;    
21.             _capacity= 0;    
22.         }    
23.     }  
24.     String(const String &s)  //拷贝构造  
25.         :_str(new char[strlen(s._str) + 1])    
26.     {    
27.         _sz = s._sz;    
28.         _capacity = s._capacity;    
29.         strcpy(_str, s._str);    
30.     }  
31.     const char *c_str() const  //获取c风格的字符指针  
32.     {    
33.         return _str;    
34.     }  
35.     String& operator=(String s)     //赋值运算符重载    
36.     {    
37.         _sz = s._sz;    
38.         _capacity = s._capacity;    
39.         std::swap(s._str, _str);    
40.         return *this;    
41.     }  
42.     char operator[](int sz)  //[]的重载  
43.     {    
44.         return _str[sz];    
45.     }    
46.     String& operator+=(const String& s)  //+=重载  
47.     {    
48.         CheckCapacity(strlen(s._str));    
49.         strcat(_str, s._str);    
50.         return *this;    
51.     }  
52.     size_t  size()const   
53.     {  
54.         return strlen(_str);  
55.     }  
56.   
57.     void  PushBack(char c)  //尾插  
58.     {  
59.         CheckCapacity(1);  
60.         _str[_sz++]=c;  
61.         _str[_sz]='\0';  
62.     }  
63.   
64.      String& Insert(size_t pos,const char *str)//指定位置插入  
65.      {  
66.          char*tmp = new char[strlen(_str+pos)];  
67.          strcpy(tmp,_str+pos);  
68.          CheckCapacity(strlen(str));  
69.          while (*str)  
70.          {  
71.              _str[pos++]= *str;  
72.              str++;  
73.          }  
74.          strcpy(_str+pos,tmp);  
75.          return *this;  
76.      }  
77.        
78.       
79.   
80.     void CheckCapacity(int sz)   //检测容量是否够用，不够则重新开辟    
81.     {    
82.         int tmp = 0;  
83.         if (_capacity<(sz + _sz + 1))    
84.         {    
85.             tmp = (2 * _capacity > _capacity + sz) ? 2 * _capacity : _capacity + sz;    
86.             char *str = new char[_capacity];    
87.             strcpy(str, _str);    
88.             delete[] _str;    
89.             _str = new char[tmp];    
90.             strcpy(_str, str);    
91.             _capacity = tmp;    
92.         }    
93.     }  
94.   
95. private:  
96.     char* _str;  
97.     int _sz;  
98.     int _capacity;  
99. };  
100. ostream& operator<<(ostream& os, const String& s)  //输出运算符重载  
101. {    
102.     os << s._str;    
103.     return os;    
104. }   
105.   
106. void test()  
107. {  
108.     String s1("abc");    
109.     String s2(s1);  
110.     cout<<s2<<endl;  
111.     String s3;  
112.     s3=s1;  
113.     cout<<s3<<endl;  
114.     String s4("def");  
115.     s1+=s4;  
116.     cout<<s1<<endl;  
117.     cout<<s1[2]<<endl;  
118.     cout<<s1.size()<<endl;  
119.     s1.PushBack('p');  
120.     s1.PushBack('p');  
121.     cout<<s1<<endl;  
122.     s1.Insert(3," ooooo ");  
123.     cout<<s1<<endl;  
124.   
125. }  
126.   
127. int main()  
128. {  
129.     test();  
130.     getchar();  
131.     return 0;  
132. }</span></strong>