一个有用的ANSI字符串类String的实现及使用演示

和C#不一样，C和C++的内部都没有字符串数据类型，但是我们可以用C++建立一个实现字符串相关操作的类型：String

并且利用重载的机制提供方便操作字符串的相关运算符集。

 

下面的程序分成两个部分：

（1）String类：类头String.h和类实现String.cpp

（2）String类使用演示程序Main.cpp

 

类头文件String.h代码如下：

1. #ifndef STRING_H
2. #define STRING_H
3. #include <iostream>
4. using namespace std;
6. class String
7. {
8.     friend ostream & operator<<(ostream & output, const String & s);
9.     friend istream & operator>>(istream & input, String & s);
11. public:
12.     String(const char* = "");
13.     String(const String &);
14.     ~String();
15.     const String & operator=(const String &);   //赋值
16.     String & operator+=(const String &);        //字符串连接
17.     int operator!() const;                      //String为空？
18.     int operator==(const String &) const;       //测试s1==s2
19.     int operator!=(const String &) const;       //测试s1!=s2
20.     int operator<(const String &) const;        //测试s1<s2
21.     int operator>(const String &) const;        //测试s1>s2
22.     int operator<=(const String &) const;       //测试s1<=s2
23.     int operator>=(const String &) const;       //测试s1>=s2
24.     char & operator[](int);                     //返回对字符的引用
25.     String & operator()(int, int);              //返回一个子字符串
26.     int GetLength() const;                      //返回字符串的长度，不包括结尾的/0
27. private:
28.     char* sPtr;                                 //指向字符串起始位置的指针
29.     int length;                                 //字符串的长度
30. };
32. #endif

类实现文件String.cpp代码如下：

1. #include <iostream>
2. #include <string.h>
3. #include <assert.h>
4. #include "String.h"
6. ostream & operator<<(ostream & output, const String & s)
7. {
8.     output<<s.sPtr;
9.     return output;
10. }
12. istream & operator>>(istream & input, String & s)
13. {
14.     static char temp[100];
15.     input>>temp;
16.     s = temp;
17.     return input;
18. }
20. String::String(const char * s)
21. {
22.     cout<<"Convention constructor:"<<s<<endl;
23.     length = strlen(s);
24.     sPtr = new char[length+1];
25.     assert(sPtr!=0);
26.     strcpy(sPtr, s);
27. }
29. String::String(const String & copy)
30. {
31.     cout<<"Copy constructor:"<<copy.sPtr<<endl;
32.     length = copy.length;
33.     sPtr = new char[length+1];
34.     assert(sPtr != 0);
35.     strcpy(sPtr, copy.sPtr);
36. }
38. String::~String()
39. {
40.     cout<<"Destructor:"<<sPtr<<endl;
41.     delete[] sPtr;
42. }
44. const String & String::operator=(const String & right)
45. {
46.     cout<<"operator = called"<<endl;
47.     if(&right != this)   //避免自我赋值
48.     {
49.         delete[] sPtr;
50.         length = right.length;
51.         sPtr = new char[length+1];
52.         assert(sPtr!=0);
53.         strcpy(sPtr, right.sPtr);
54.     }
55.     else
56.     {
57.         cout<<"Attempt assignment of a String to itself/n";
58.     }
59.     return *this;
60. }
62. String & String::operator+=(const String & right)
63. {
64.     char* tempPtr = sPtr;
65.     length += right.length;
66.     sPtr = new char[length+1];
67.     assert(sPtr!=0);
68.     strcpy(sPtr, tempPtr);
69.     strcat(sPtr, right.sPtr);
70.     delete[] tempPtr;
71.     return *this;
72. }
74. //字符串为空？
75. int String::operator !() const
76. {
77.     return length == 0;
78. }
80. int String::operator==(const String & right) const
81. {
82.     return strcmp(sPtr, right.sPtr)==0;
83. }
85. int String::operator!=(const String & right) const
86. {
87.     return strcmp(sPtr, right.sPtr)!=0;
88. }
90. int String::operator<(const String & right) const
91. {
92.     return strcmp(sPtr, right.sPtr)<0;
93. }
95. int String::operator>(const String & right) const
96. {
97.     return strcmp(sPtr, right.sPtr)>0;
98. }
100. int String::operator<=(const String & right) const
101. {
102.     return strcmp(sPtr, right.sPtr)<=0;
103. }
105. int String::operator>=(const String & right) const
106. {
107.     return strcmp(sPtr, right.sPtr)>=0;
108. }
110. //返回对String中某个字符的引用
111. char & String::operator [](int subscript)
112. {
113.     //首先测试下标是否越界
114.     assert(subscript>=0 && subscript<length);
115.     return sPtr[subscript];
116. }
118. String & String::operator()(int index, int sublength)
119. {
120.     //首先测试下标是否越界
121.     assert(index>=0 && index<length && sublength >= 0);
123.     String * subPtr = new String;
124.     assert(subPtr!=0);
126.     //计算子字符串长度
127.     int size = 0;
128.     if(sublength == 0 || (index+sublength>length))
129.     {
130.         size = length - index + 1;
131.     }
132.     else
133.     {
134.         size = sublength + 1;
135.     }
136.     //分配子字符串内存
137.     delete subPtr->sPtr;
138.     subPtr->length = size;
139.     subPtr->sPtr = new char[size];
140.     assert(subPtr->sPtr!=0);
142.     int i = index, j=0;
143.     //把子字符串拷贝到新的对象中
144.     for( ; i<index+size-1; i++, j++)
145.     {
146.         subPtr->sPtr[j] = sPtr[i];
147.     }
149.     subPtr->sPtr[j] = '/0';
150.     return *subPtr;
151. }
153. int String::GetLength() const
154. {
155.     return length;
156. }

String类使用演示程序Main.cpp代码如下：

1. #include <iostream>
2. #include "String.h"
4. int main()
5. {
6.     cout<<"---------------------------------------------------------------------------------------------------------/n"; 
7.     cout<<"                   一个有用的ANSI字符串类String的实现及使用演示程序                    /n"; 
8.     cout<<"by 一剑(Loomman),QQ:28077188,MSN: [email protected] QQ裙：30515563/n"; 
9.     cout<<"---------------------------------------------------------------------------------------------------------/n/n"; 
11.     String s1(" happy"), s2(" birthday"), s3;
13.     cout<<"s1 is /""<<s1<<"/"; s2 is /""<<s2
14.         <<"/"; s3 is empty /n"
15.         <<"The results of comparing s2 and s1:"
16.         <<"/ns2==s1 yields "<<(s2==s1)
17.         <<"/ns2!=s1 yields "<<(s2!=s1)
18.         <<"/ns2>s1 yields "<<(s2>s1)
19.         <<"/ns2<s1 yields "<<(s2<s1)
20.         <<"/ns2>=s1 yields "<<(s2>=s1)
21.         <<"/ns2<=s1 yields "<<(s2<=s1)<<"/n/n";
23.     cout<<"Testing! s3:/n";
24.     if(!s3)
25.     {
26.         cout<<"s3 is empty; assigning s1 to s3; /n";
27.         s3 = s1;
28.         cout<<"s3 is /""<<s3<<"/"/n/n";
29.     }
31.     cout<<"s1+=s2 yields s1=";
32.     s1+=s2;
33.     cout<<s1<<"/n/n";
35.     cout<<"s1+=/" to you/" yields/n";
36.     s1+=" to you";
37.     cout<<"s1="<<s1<<"/n/n";
39.     cout<<"The substring of s1 starting at /n"
40.         <<"location 0 for 14 characters, s1(0, 14), is:"
41.         <<s1(0, 14)<<"/n/n";
43.     cout<<"The substring of s1 starting at /n"
44.         <<"location 15, s1(15, 0) is:"
45.         <<s1(15, 0)<<"/n/n";
47.     String * s4Ptr = new String(s1);
48.     cout<<"*s4Ptr="<<*s4Ptr<<"/n/n";
50.     cout<<"assigning *s4Ptr to *s4Ptr/n";
51.     *s4Ptr = *s4Ptr;
52.     cout<<"*s4Ptr="<<*s4Ptr<<endl;
54.     delete s4Ptr;
56.     s1[0] = 'H';
57.     s1[6] = 'B';
59.     int a;
60.     cin>>a;
61.     return a;
63. }

程序运行效果：

----------------------------------------------------------------------------------------------------------
      一个有用的ANSI字符串类String的实现及使用演示程序
      by 一剑(Loomman),QQ:28077188,MSN: [email protected] QQ裙：30515563
      ----------------------------------------------------------------------------------------------------------

Convention constructor: happy
Convention constructor: birthday
Convention constructor:
s1 is " happy"; s2 is " birthday"; s3 is empty
The results of comparing s2 and s1:
s2==s1 yields 0
s2!=s1 yields 1
s2>s1 yields 0
s2<s1 yields 1
s2>=s1 yields 0
s2<=s1 yields 1

Testing! s3:
s3 is empty; assigning s1 to s3;
operator = called
s3 is " happy"

s1+=s2 yields s1= happy birthday

s1+=" to you" yields
Convention constructor: to you
Destructor: to you
s1= happy birthday to you

Convention constructor:
The substring of s1 starting at
location 0 for 14 characters, s1(0, 14), is: happy birthda

Convention constructor:
The substring of s1 starting at
location 15, s1(15, 0) is: to you

Copy constructor: happy birthday to you
*s4Ptr= happy birthday to you

assigning *s4Ptr to *s4Ptr
operator = called
Attempt assignment of a String to itself
*s4Ptr= happy birthday to you
Destructor: happy birthday to you