初学C++,在VC++6.0中写了一个简单的String类，请多批评指正

dn2010

初学C++,在VC++6.0中写了一个简单的String类，请多批评指正，谢谢！

1. #include <iostream.h>
   
2. #include <string.h>
   
3. #include <assert.h>
   
4. #include <stdlib.h>
   
5. 
   
6. class String
   
7. {
   
8. private:           // 私有数据成员:
   
9.   unsigned length; // length of string in characters(not counting null terminator)
   
10.   char *char_ptr;  // pointer to string contents,用于保存字符串
    
11. public:
    
12.   //String() { length = 0; char_ptr = NULL; };
    
13.   //取消上述默认构造函数，否则与下面的有默认参数的通用构造函数冲突：
    
14.   //  warning C4520: 'String' : multiple default constructors specified
    
15. 
    
16.   inline String(const char *pstr = NULL);  // conversion/default constructor
    
17.   // 通用构造函数,默认参数只在定义中写
    
18.   // 由于有默认参数，会与 String() 冲突
    
19. 
    
20.   String(const String &another);    // copy constructor,拷贝构造函数
    
21.   //拷贝构造函数，经常被称作X(X&)，是一种特殊的构造函数，它由编译器调用来完成
    
22.   //一些基于同一类的其他对象的构件及初始化。它的唯一的一个参数（对象的引用）
    
23.   //是不可变的（因为是const型的）。
    
24. 
    
25.   String(const unsigned count, const char ch);
    
26. 
    
27.   ~String(); // // destructor,析构函数
    
28. 
    
29.   // assignment operator,赋值运算符
    
30.   const String & operator = (const String &right);
    
31.   const String & operator = (const char *pstr);
    
32.   const String & operator = (int nNum);
    
33. 
    
34.   // 重载[], 实现数组运算
    
35.   char& operator [] (unsigned int nIdx); // subscript operator (modifiable lvalue)
    
36.   // 重载[], 实现数组运算(对象为常量)
    
37.   //const char& operator [] (unsigned int nIdx) const;
    
38.   // 重载[], 实现数组运算
    
39.   char operator[](unsigned int) const;   // subscript operator (rvalue)
    
40.   // 重载[]
    
41.   String& operator [] (const String& obj);
    
42.   // 重载(), return a substring
    
43.   String operator () (const unsigned nIdx, const unsigned count) const;
    
44. 
    
45.   // 重载+=,实现与对象相加
    
46.   String& operator += (const String& right); // concatenation operator
    
47.   // 重载+=,实现与字符串相加
    
48.   String& operator += (const char *pstr);
    
49. 
    
50.   const String operator+(const String& right) const;
    
51. 
    
52.   friend String operator+(const String  s1, const String  s2);
    
53.   // 如果写成  friend String operator+(const String &s1, const String &s2);
    
54.   // 则后面的3条语句：
    
55.   //   return s1 + String(cs2);
    
56.   //   return String(cs1) + s2;
    
57.   //   String c = a + b;
    
58.   // 报错：error C2593: 'operator +' is ambiguous
    
59. 
    
60.   friend String operator+(const String &s1, const char * cs2);
    
61.   friend String operator+(const char * cs1, const String &s2);
    
62. 
    
63.   friend String operator&(const String &s1, const String &s2);
    
64.   friend String operator&(const String &s1, const char * cs2);
    
65.   friend String operator&(const char * cs1, const String &s2);
    
66. 
    
67.   bool operator!() const; // is String empty?
    
68. 
    
69.   bool operator >  (const String &right);
    
70.   bool operator >= (const String &right);
    
71.   bool operator <  (const String &right);
    
72.   bool operator <= (const String &right);
    
73.   bool operator == (const String &right);
    
74.   // 重载比较运算符!=
    
75.   bool operator != (const String &right);
    
76. 
    
77.   friend ostream &operator  << (ostream &out, const String &s)
    
78.   {//输出
    
79.         if(&s == NULL)
    
80.           out << "<NULL>";
    
81.         else if(s.char_ptr == NULL)
    
82.           out << "{NULL}";
    
83.         else
    
84.       out << s.char_ptr;
    
85.     return out;
    
86.   }
    
87. 
    
88.   friend istream &operator  >> (istream &in, String &s)
    
89.   {//输入
    
90.     char tmp[255]; //用于存储输入流
    
91.     in >> tmp;
    
92.     s = tmp;       //使用赋值运算符
    
93.     return in;     //使用return可以支持连续使用>>运算符
    
94.   }
    
95. 
    
96.   int getLength() const { return length; };
    
97.   char *getPtr() const { return char_ptr; };
    
98. 
    
99.   String substr(unsigned st, unsigned len); // 提取子串,st为开始位置,len为提取长度
    
100.   String & append(const String &right); // 拼接
     
101.   // 如果命名为strcat则会与string.h中的strcat冲突，报错：
     
102.   //   error C2661: 'strcat' : no overloaded function takes 2 parameters
     
103.   String & append(const char *pstr);    // 拼接
     
104.   int find(const char *pstr, unsigned st);      // 查找,st开始位置,可不填,默认为0
     
105.   int find(const String &another, unsigned st); // 查找,st开始位置,可不填,默认为0
     
106.   String & replace(const char *src, const char *dst);     // 替换
     
107.   String & replace(const String &src, const String &dst); // 替换
     
108. };
     
109. 
     
110. inline String::String(const char *pstr /* = NULL */) // 通用构造函数
     
111. // 声明为inline函数，则该函数在程序中被执行时是语句直接替换，而不是被调用
     
112. {
     
113.   if(pstr == NULL)
     
114.     cout << "--- 通用构造函数调用之初,pstr=(NULL)\n";
     
115.   else
     
116.     cout << "--- 通用构造函数调用之初,pstr=[" << pstr << "]\n";
     
117.   if(pstr == NULL) { length = 0; char_ptr = NULL; return; }
     
118.   length = strlen(pstr);
     
119.   char_ptr = new char[length + 1];
     
120.   strcpy(char_ptr, pstr);
     
121. }
     
122. 
     
123. String::String(const String &another) // 拷贝构造函数
     
124. // 类String拷贝构造函数与普通构造函数的区别是：
     
125. // 在函数入口处无需与NULL进行比较，这是因为“引用”不可能是NULL，
     
126. // 而“指针”可以为NULL。
     
127. {
     
128.   cout << "--- 拷贝构造函数调用之初,another=[" << another << "]\n";
     
129.   // if(*this != another) // 这种写法会调用下面重载的操作符 !=
     
130.   if(this != &another)
     
131.   {
     
132.     if(another.length == 0) { length = 0; char_ptr = NULL; return; }
     
133.     // 在类的成员函数内可以访问同种类对象的私有成员（同种类肯定是友元关系）
     
134. 
     
135.     length = another.length;
     
136.     char_ptr = new char[length + 1];
     
137.     strcpy(char_ptr, another.char_ptr);
     
138.   }
     
139. }
     
140. 
     
141. String::String(const unsigned count, const char ch)
     
142. {
     
143.   cout << "--- 另一个构造函数调用之初,count=" << count << ", ch=" << ch << endl;
     
144.   if(count <= 0) { length = 0; char_ptr = NULL; return; }
     
145.   length = count;
     
146.   char_ptr = new char[length + 1];
     
147.   memset(char_ptr, ch, length);
     
148.   char_ptr[length] = 0x00;
     
149. }
     
150. 
     
151. String::~String() // 析构函数
     
152. {
     
153.   cout << "--- 执行析构函数, length=" << length;
     
154.   if(length > 0)
     
155.         cout << ", char_ptr:" << char_ptr << endl; // endl 等效于 "\n"
     
156.   else
     
157.         cout << endl; // endl 等效于 "\n"
     
158.   if(length > 0 && !char_ptr) delete []char_ptr;
     
159.   // 由于 char_ptr是内部数据类型，也可以写成 delete char_ptr;
     
160.   char_ptr = NULL;
     
161.   length = 0;
     
162. }
     
163. 
     
164. 
     
165. const String & String::operator = (const String &right) // 赋值运算符
     
166. {
     
167.   cout << "--- 执行赋值运算, right=" << right << endl;
     
168.   // 检查自赋值, 注意不要将检查自赋值的if语句“if(this == &right)”
     
169.   //   错写成为“if(*this == right)”
     
170.   if(this == &right) return *this;
     
171. 
     
172.   // 释放原有资源。如果现在不释放，以后就没机会了，将造成内存泄露。
     
173.   if(!char_ptr) delete []char_ptr;
     
174. 
     
175.   if(right.length == 0) { length = 0; char_ptr = NULL; return *this; }
     
176. 
     
177.   // 分配新的内存资源，并复制内容
     
178.   length = right.length;
     
179.   char_ptr = new char[length + 1];
     
180.   strcpy(char_ptr, right.char_ptr); // 函数strcpy则连'\0'一起复制。
     
181.   // 返回本对象的引用，目的是为了实现象 a = b = c 这样的链式表达。
     
182.   // 注意不要将 return *this 错写成 return this
     
183.   return *this;
     
184. }
     
185. 
     
186. const String & String::operator = (const char *pstr) // 赋值运算符
     
187. {
     
188.   cout << "--- 执行赋值运算, pstr=" << pstr << endl;
     
189.   if(pstr == NULL) { length = 0; char_ptr = NULL; return *this; }
     
190. 
     
191.   // 释放原有资源
     
192.   if(!char_ptr) delete []char_ptr;
     
193.   // 如果不加 if(!char_ptr) 判断将可能导致下述错误：
     
194.   //   Debug Error!
     
195.   //   DAMAGE：after Normal block(#53)at 0x00441940.
     
196. 
     
197.   length = strlen(pstr);
     
198.   char_ptr = new char[length + 1];
     
199.   strcpy(char_ptr, pstr);
     
200.   // 返回本对象的引用
     
201.   return *this;
     
202. }
     
203. 
     
204. const String& String::operator = (int nNum) // 赋值运算符
     
205. {
     
206.   cout << "--- 执行赋值运算, nNum=" << nNum << endl;
     
207.   char szNum[24];
     
208.   itoa(nNum, szNum, 10);
     
209.   if(!char_ptr) delete []char_ptr;
     
210.   char_ptr = new char[strlen(szNum) + 1];
     
211.   strcpy(char_ptr, szNum);
     
212.   return *this;
     
213. }
     
214. 
     
215. // 重载[], 实现数组运算,return reference to character in String as a modifiable lvalue
     
216. char& String::operator [] (unsigned int nIdx)
     
217. {
     
218.   cout << "--- 执行[]运算, modifiable lvalue" << endl;
     
219.   // test for subscript out of range
     
220.   if(nIdx < 0 || nIdx >= length )
     
221.   {
     
222.     cerr << "Error: Subscript " << nIdx
     
223.          << " out of range" << endl;
     
224.     exit(1); // terminate program
     
225.   }
     
226.   return char_ptr[nIdx]; // non-const return; modifiable lvalue
     
227. }
     
228. /*
     
229. // 重载[], 实现数组运算(对象为常量)
     
230. const char& String::operator [] (unsigned int nIdx) const
     
231. {
     
232.   assert(nIdx <= length);
     
233.   return char_ptr[nIdx];
     
234. }
     
235. */
     
236. 
     
237. // return reference to character in String as rvalue
     
238. char String::operator[](unsigned int nIdx) const   // subscript operator (rvalue)
     
239. {
     
240.   cout << "--- 执行[]运算, subscript operator (rvalue)" << endl;
     
241.   assert(nIdx <= length);
     
242.   return char_ptr[nIdx]; // returns copy of this element
     
243. }
     
244. 
     
245. // 重载[]
     
246. String& String::operator [] (const String& obj)
     
247. {
     
248.   if(obj.char_ptr == NULL)
     
249.   {
     
250.     return *this;
     
251.   }
     
252.   char *pTmp = new char[length + obj.length + 1];
     
253.   strcpy(pTmp, char_ptr);
     
254.   strcat(pTmp, obj.char_ptr);
     
255.   if(!char_ptr) delete []char_ptr;
     
256.   char_ptr = pTmp;
     
257.   return *this;
     
258. }
     
259. 
     
260. // 重载()
     
261. String String::operator () (const unsigned nIdx, const unsigned count) const
     
262. {
     
263.   if(nIdx < 0 || count <= 0 || nIdx >= length) return NULL;
     
264.   String result;
     
265.   if(nIdx + count > length)
     
266.     result.length = length - nIdx;
     
267.   else
     
268.     result.length = count;
     
269.   result.char_ptr = new char[result.length + 1];
     
270.   strncpy(result.char_ptr, char_ptr + nIdx, result.length);
     
271.   result.char_ptr[result.length] = 0x00;
     
272.   return result;
     
273. }
     
274. 
     
275. // 重载+=,实现与对象相加.
     
276. // Concatenate right operand to this object and store in this object.
     
277. String &String::operator+=(const String &right)
     
278. {
     
279.   cout << "--- 执行+=运算, right=" << right << endl;
     
280.   if(&right == NULL)
     
281.   {
     
282.     return *this;
     
283.   }
     
284.   char *tempPtr = char_ptr;         // hold to be able to delete
     
285.   length += right.length;           // new String length
     
286.   char_ptr = new char[length + 1];  // create space
     
287.   assert(char_ptr != 0);            // terminate if memory not allocated
     
288.   strcpy(char_ptr, tempPtr);        // left part of new String
     
289.   strcat(char_ptr, right.char_ptr); // right part of new String
     
290.   delete [] tempPtr;                // reclaim old space
     
291.   return *this;                     // enables concatenated calls
     
292. }
     
293. 
     
294. // 重载+=,实现与字符串相加
     
295. String& String::operator += (const char *pstr)
     
296. {
     
297.   cout << "--- 执行+=运算, pstr=" << pstr << endl;
     
298.   if(pstr == NULL)
     
299.   {
     
300.     return *this;
     
301.   }
     
302.   char *pTmp = new char[length + strlen(pstr) + 1];
     
303.   strcpy(pTmp, char_ptr);
     
304.   strcat(pTmp, pstr);
     
305.   if(!char_ptr) delete []char_ptr;
     
306.   char_ptr = pTmp;
     
307.   return *this;
     
308. }
     
309. 
     
310. const String String::operator+(const String& right) const
     
311. {
     
312.   cout << "--- 执行 + 运算, right=" << right << endl;
     
313.   if(&right == NULL)
     
314.   {
     
315.     return *this;
     
316.   }
     
317.   char* r = new char [length + right.length + 1];  // temporary
     
318.   assert(r != 0);
     
319.   strcpy(r, char_ptr);                  // init with left string
     
320.   strcpy(r + length, right.char_ptr);   // add right string
     
321.   String result(r);                     // construct String object
     
322.   delete [] r;                          // free temporary
     
323.   return result;
     
324. }
     
325. 
     
326. String operator+(const String  s1, const String  s2)
     
327. {
     
328.   cout << "--- 执行 + 运算, s1=" << s1 << ", s2=" << s2 << endl;
     
329.   String s3;
     
330.   s3.length = s1.length + s2.length;
     
331.   s3.char_ptr = new char[s3.length + 1];
     
332.   if(s1.length > 0)
     
333.     strcpy(s3.char_ptr, s1.char_ptr);
     
334.   else
     
335.     strcpy(s3.char_ptr, "");
     
336. 
     
337.   if(s2.length > 0)
     
338.     strcat(s3.char_ptr, s2.char_ptr);
     
339.   s3.char_ptr[s3.length] = 0x00;
     
340.   return s3;
     
341. }
     
342. 
     
343. String operator+(const String &s1, const char * cs2)
     
344. {
     
345.   cout << "--- 执行 + 运算, s1=" << s1 << ", cs2=" << cs2 << endl;
     
346.   return s1 + String(cs2);
     
347. }
     
348. 
     
349. String operator+(const char * cs1, const String &s2)
     
350. {
     
351.   cout << "--- 执行 + 运算, cs1=" << cs1 << ", s2=" << s2 << endl;
     
352.   return String(cs1) + s2;
     
353. }
     
354. 
     
355. String operator&(const String &s1, const String &s2)
     
356. {
     
357.   cout << "--- 执行 & 运算, s1=" << s1 << ", s2=" << s2 << endl;
     
358.   String s3;
     
359.   s3.length = s1.length + s2.length;
     
360.   s3.char_ptr = new char[s3.length + 1];
     
361.   strcpy(s3.char_ptr, s1.char_ptr);
     
362.   strcat(s3.char_ptr, s2.char_ptr);
     
363.   return s3;
     
364. }
     
365. 
     
366. String operator&(const String &s1, const char * cs2)
     
367. {
     
368.   cout << "--- 执行 & 运算, s1=" << s1 << ", cs2=" << cs2 << endl;
     
369.   return s1 + String(cs2);
     
370. }
     
371. 
     
372. String operator&(const char * cs1, const String &s2)
     
373. {
     
374.   cout << "--- 执行 & 运算, cs1=" << cs1 << ", s2=" << s2 << endl;
     
375.   return String(cs1) + s2;
     
376. }
     
377. 
     
378. bool String::operator!() const // is String empty?
     
379. {
     
380.   cout << "--- 执行 !() 运算, length=" << length << endl;
     
381.   return length == 0;
     
382. }
     
383. 
     
384. bool String::operator > (const String &right)
     
385. {
     
386.   if(length > 0 && right.length == 0) return true;
     
387.   if(length == 0 && right.length > 0) return false;
     
388.   int pos = 0;
     
389.   while(char_ptr[pos] == right.char_ptr[pos] && char_ptr[pos] != '\0') pos++;
     
390.   if(char_ptr[pos] > right.char_ptr[pos]) return true;
     
391.   else return false;
     
392. }
     
393. 
     
394. bool String::operator >= (const String &right)
     
395. {
     
396.   if(length > 0 && right.length == 0) return true;
     
397.   if(length == 0 && right.length > 0) return false;
     
398.   int pos = 0;
     
399.   while(char_ptr[pos] == right.char_ptr[pos] && char_ptr[pos] != '\0') pos++;
     
400.   if(char_ptr[pos]  > right.char_ptr[pos] ||
     
401.     (char_ptr[pos] == right.char_ptr[pos] && char_ptr[pos] == '\0'))
     
402.     return true;
     
403.   else return false;
     
404. }
     
405. 
     
406. bool String::operator < (const String &right)
     
407. {
     
408.   return !((*this) >= right);
     
409. }
     
410. 
     
411. bool String::operator <= (const String &right)
     
412. {
     
413.   return !((*this) > right);
     
414. }
     
415. 
     
416. bool String::operator == (const String &right)
     
417. {
     
418.   //return !((*this) > right) && !((*this) < right);
     
419.   return !strcmp(char_ptr, right.char_ptr);
     
420. }
     
421. 
     
422. bool String::operator != (const String &right)
     
423. {
     
424.   return !((*this) == right);
     
425. }
     
426. 
     
427. String String::substr(unsigned st, unsigned n)
     
428. {
     
429.   if(st < 0 || n <= 0 || st + n > length) return NULL;
     
430.   char *tmp = new char[n+1];
     
431.   for(unsigned i = 0; i < n; i++)
     
432.   {
     
433.     tmp[i] = char_ptr[st + i];
     
434.   }
     
435.   tmp[n] = '\0';
     
436.   return String(tmp);
     
437. }
     
438. 
     
439. String &String::append(const String &right)
     
440. {
     
441.   if(&right == NULL || right.length == 0) return *this;
     
442.   char* r = new char [length + right.length + 1]; // temporary
     
443.   assert(r != 0);
     
444.   strcpy(r, char_ptr);                  // init with left string
     
445.   strcpy(r + length, right.char_ptr);   // add right string
     
446.   if(!char_ptr) delete []char_ptr;
     
447.   char_ptr = r;
     
448.   return *this;
     
449. }
     
450. 
     
451. String &String::append(const char *pstr)
     
452. {
     
453.   if(NULL == pstr) return *this;
     
454.   char *tmp = new char[length + strlen(pstr) + 1];
     
455.   assert(tmp != 0);
     
456.   strcpy(tmp, char_ptr);
     
457.   strcat(tmp, pstr);
     
458.   if(!char_ptr) delete []char_ptr;
     
459.   char_ptr = tmp;
     
460.   return *this;
     
461. }
     
462. 
     
463. int String::find(const char *pstr, unsigned st = 0)
     
464. {
     
465.   if(st < 0 || st >= length) return -1;
     
466.   int strPos = st;
     
467.   while(char_ptr[strPos] != '\0')
     
468.   {
     
469.     int curPos = strPos;
     
470.     int pPos = 0;
     
471.     if(char_ptr[strPos] != pstr[pPos])
     
472.     {
     
473.       strPos++;
     
474.       continue; //如果当前字符不相等，继续下一个字符
     
475.     }
     
476.     while(char_ptr[curPos] == pstr[pPos] && pstr[pPos] != '\0')
     
477.     {
     
478.       curPos++;
     
479.       pPos++; //相等的部分跳过
     
480.     }
     
481.     if(pstr[pPos] == '\0') return strPos;
     
482.     else
     
483.     {
     
484.       strPos++;
     
485.       continue;//如果当前字符不相等，继续下一个字符
     
486.     }
     
487.   }
     
488.   return -1;
     
489. }
     
490. 
     
491. int String::find(const String &another, unsigned st)
     
492. {
     
493.   return find(another.char_ptr, st);
     
494. }
     
495. 
     
496. String &String::replace(const char *src, const char *dst)
     
497. {
     
498.   if(src == NULL || dst == NULL) return *this;
     
499.   int pos = find(src);
     
500.   if(pos < 0) return *this; //没有源串就退出函数
     
501.   int lenSrc = 0, lenDst = 0;
     
502.   while(src[lenSrc++]);
     
503.   while(dst[lenDst++]);
     
504.   lenSrc -= 1;
     
505.   lenDst -= 1;
     
506.   char *tmp = new char[length + lenDst - lenSrc + 1];
     
507.   int curChar = 0;
     
508.   while(curChar < pos)
     
509.   {
     
510.     tmp[curChar] = char_ptr[curChar];
     
511.     curChar++;
     
512.   }
     
513.   int i = 0;
     
514.   while(i < lenDst)
     
515.   {
     
516.     tmp[curChar] = dst[i];
     
517.     curChar++;
     
518.     i++;
     
519.   }
     
520.   pos += lenSrc;
     
521.   while(pos < (int)length)
     
522.   {
     
523.     tmp[curChar] = char_ptr[pos];
     
524.     curChar++;
     
525.     pos++;
     
526.   }
     
527.   tmp[curChar] = '\0';
     
528.   if(!char_ptr) delete []char_ptr;
     
529.   char_ptr = tmp;
     
530.   return replace(src, dst); //递归调用替换所有串
     
531. }
     
532. 
     
533. String &String::replace(const String &src, const String &dst)
     
534. {
     
535.   return replace(src.char_ptr, dst.char_ptr);
     
536. }
     
537. 
     
538. void main()
     
539. {
     
540.   String s("12345"); // 测试
     
541.   cout << "=== @main(), s=[" << s << "]\n";
     
542.   String o = s;
     
543.   cout << "=== @main(), after o=s, o:" << o << endl;
     
544.   o = "12345678";
     
545.   cout << "=== @main(), after o='12345678', o:" << o << endl;
     
546.   cout << "=== @main(), o.substr(2,2):" << o.substr(2,2) << endl;
     
547.   o.append(String("ABC"));
     
548.   cout << "=== @main(), after o.strcat(ABC), o:" << o << endl;
     
549.   o.append("DEF");
     
550.   cout << "=== @main(), after o.strcat(DEF), o:" << o << endl;
     
551.   s = "123435333336";
     
552.   o = "123435333336";
     
553.   cout << "=== @main(), s 和 o 重新赋值, s=[" << s << "], o=[" << o << "]\n";
     
554.   cout << "=== @main(), true=" << true << ", false=" << false << endl;
     
555.   cout << "=== @main(), 检测 s == o 结果: " << (s == o) << endl;
     
556.   cout << "=== @main(), 检测 s != o 结果: " << (s != o) << endl;
     
557.   cout << "=== @main(), 检测 s  > o 结果: " << (s > o) << endl;
     
558.   cout << "=== @main(), 检测 s >= o 结果: " << (s >= o) << endl;
     
559.   cout << "=== @main(), 检测 s  < o 结果: " << (s < o) << endl;
     
560.   cout << "=== @main(), 检测 s <= o 结果: " << (s <= o) << endl;
     
561.   String ss = s(3, 4);
     
562.   cout << "=== @main(), ss=s(3,4): " << ss << endl;
     
563.   cout << "=== @main(), after s.replace(...), result=[" << s.replace(String("3"),String("A")) << "]\n\n";
     
564.   String a="aaa";
     
565.   String b="bbb";
     
566.   String c = a + b;
     
567.   cout << "=== @main(), c=a+b=[" << c << "]\n";
     
568.   String d = a + "!!!ddd";
     
569.   cout << "=== @main(), d=[" << d << "]\n";
     
570.   String e = "eee " + b;
     
571.   cout << "=== @main(), e=[" << e << "]\n";
     
572.   String f = a & b;
     
573.   cout << "=== @main(), f=a&b=[" << f << "]\n";
     
574.   String r(10, 'x');
     
575.   cout << "=== @main(), r=[" << r << "]\n";
     
576.   r += a;
     
577.   cout << "=== @main(), r+=a, =[" << r << "]\n";
     
578.   r += "Hello";
     
579.   cout << "=== @main(), r+=\"Hello\", =[" << r << "]\n";
     
580.   String s1, s2, s3, s4, s5, s6;
     
581.   s1 = s2 = s3 = s4 = "Hello!";
     
582.   s6 = s5 + "666";
     
583.   cout << "=== @main(), s6=[" << s6 << "]\n";
     
584.   cout << "=== @main(), !s5=" << (!s5) << "\n";
     
585.   cout << "=== @main(), !s6=" << (!s6) << "\n";
     
586.   char c1 = s6[2];
     
587.   cout << "=== @main(), c1 = s6[2]=" << c1 << "\n";
     
588.   s6[2] = '2';
     
589.   cout << "=== @main(), s6[2]=" << s6[2] << "\n";
     
590. }
     

复制代码

dn2010

自己顶。

unistd

为了实现i一个 string类，C++就这么复杂，，，，

hellioncu

判断new成功与否不能用assert

在C++中，new失败缺省会抛出异常（当然VC6是个例外）

留痕之雁

{:3_189:}{:3_189:}一说到重载new，delete之类的，建议在前面加static ，这是经验！不说了。

Cu_fans

不错，支持

dn2010

判断new成功与否不能用assert

在C++中，new失败缺省会抛出异常（当然VC6是个例外）
hellioncu 发表于 2011-07-06 09:47

    谢谢！

dn2010

一说到重载new，delete之类的，建议在前面加static ，这是经验！不说了。
留痕之雁 发表于 2011-07-06 11:48

还请多说说。

dn2010

不错，支持
Cu_fans 发表于 2011-07-06 13:05

谢谢！