String是C++中的重要类型，程序员在C++面试中经常会遇到关于String的细节问题，甚至要求当场实现这个类。只是由于时间关系，可能只要求实现构造函数、析构函数、拷贝构造函数等关键部分。

String的实现涉及很多C++的基础知识、内存控制及异常处理等问题，仔细研究起来非常复杂，本文主要做一个简单的总结和归纳。

一 整体框架

面试时由于时间关系，面试官一般不会要求很详尽的String的功能，一般是要求实现构造函数、拷贝构造函数、赋值函数、析构函数这几个非常重要的部分。因为String里涉及动态内存的管理，默认的拷贝构造函数在运行时只会进行浅复制，即只复制内存区域的指针，会造成两个对象指向同一块内存区域的现象。如果一个对象销毁或改变了该内存区域，会造成另一个对象运行或者逻辑上出错。这时就要求程序员自己实现这些函数进行深复制，即不止复制指针，需要连同内存的内容一起复制。

除了以上四个必须的函数，这里还实现了一些附加的内容。

若干个运算符重载，这里的几个是常见的运算符，可以加深对String的认识和运算符重载的理解。

两个常用的函数，包括取字符串长度和取C类型的字符串。

两个处理输入输出的运算符重载，为了使用的方便，这里把这两个运算符定义为友元函数。

整体的类的框架如下所示。

class String

{

public:

String(const char *str = NULL); //通用构造函数

String(const String &str); //拷贝构造函数

~String(); //析构函数

String operator+(const String &str) const; //重载+

String& operator=(const String &str); //重载=

String& operator+=(const String &str); //重载+=

bool operator==(const String &str) const; //重载==

char& operator[](int n) const; //重载[]

size_t size() const; //获取长度

const char* c_str() const; //获取C字符串

friend istream& operator>>(istream &is, String &str);//输入

friend ostream& operator<<(ostream &os, String &str);//输出

private:

char *data; //字符串

size_t length; //长度

};

注意，类的成员函数中，有一些是加了const修饰的，表示这个函数不会对类的成员进行任何修改。一些函数的输入参数也加了const修饰，表示该函数不会对改变这个参数的值。

二 具体实现

下面逐个进行成员函数的实现。

同样构造函数适用一个字符串数组进行String的初始化，默认的字符串数组为空。这里的函数定义中不需要再定义参数的默认值，因为在类中已经声明过了。

另外，适用C函数strlen的时候需要注意字符串参数是否为空，对空指针调用strlen会引发内存错误。

String::String(const char *str)//通用构造函数

{

if (!str)

{

length = 0;

data = new char[1];

*data = '\0';

}

else

{

length = strlen(str);

data = new char[length + 1];

strcpy(data, str);

}

}

拷贝构造函数需要进行深复制。

String::String(const String &str)//拷贝构造函数

{

length = str.size();

data = new char[length + 1];

strcpy(data, str.c_str());

}

析构函数需要进行内存的释放及长度的归零。

String::~String()//析构函数

{

delete []data;

length = 0;

}

重载字符串连接运算，这个运算会返回一个新的字符串。

String String::operator+(const String &str) const//重载+

{

String newString;

newString.length = length + str.size();

newString.data = new char[newString.length + 1];

strcpy(newString.data, data);

strcat(newString.data, str.data);

return newString;

}

重载字符串赋值运算，这个运算会改变原有字符串的值，为了避免内存泄露，这里释放了原先申请的内存再重新申请一块适当大小的内存存放新的字符串。

String& String::operator=(const String &str)//重载=

{

if (this == &str) return *this;

delete []data;

length = str.length;

data = new char[length + 1];

strcpy(data, str.c_str());

return *this;

}

重载字符串+=操作，总体上是以上两个操作的结合。

String& String::operator+=(const String &str)//重载+=

{

length += str.length;

char *newData = new char[length + 1];

strcpy(newData, data);

strcat(newData, str.data);

delete []data;

data = newData;

return *this;

}

重载相等关系运算，这里定义为内联函数加快运行速度。

inline bool String::operator==(const String &str) const//重载==

{

if (length != str.length) return false;

return strcmp(data, str.data) ? false : true;

}

重载字符串索引运算符，进行了一个简单的错误处理，当长度太大时自动读取最后一个字符。

inline char& String::operator[](int n) const//重载[]

{

if (n >= length) return data[length-1]; //错误处理

else return data[n];

}

重载两个读取私有成员的函数，分别读取长度和C字符串。

inline size_t String::size() const//获取长度

{

return length;

}

重载输入运算符，先申请一块足够大的内存用来存放输入字符串，再进行新字符串的生成。这是一个比较简单朴素的实现，网上很多直接is>>str.data的方法是错误的，因为不能确定str.data的大小和即将输入的字符串的大小关系。

istream& operator>>(istream &is, String &str)//输入

{

char tem[1000]; //简单的申请一块内存

is >> tem;

str.length = strlen(tem);

str.data = new char[str.length + 1];

strcpy(str.data, tem);

return is;

}

重载输出运算符，只需简单地输出字符串的内容即可。注意为了实现形如cout<<a<<b的连续输出，这里需要返回输出流。上面的输入也是类似。

ostream& operator<<(ostream &os, String &str)//输出

{

os << str.data;

return os;

}

inline const char* String::c_str() const//获取C字符串

{

return data;

}

三 功能测试

编码完成后需要对代码进行测试，以下是一个简单但不够严谨的测试。

int main()

{

String s;

cin >> s;

cout << s << ": " << s.size() << endl;

char a[] = "Hello", b[] = "World!";

String s1(a), s2(b);

cout << s1 << " + " << s2 << " = " << s1 + s2 << endl;

String s3 = s1 + s2;

if (s1 == s3) cout << "First: s1 == s3" << endl;

s1 += s2;

if (s1 == s3) cout << "Second: s1 == s3" << endl;

/*程序输入输出为：

123456789

123456789: 9

Hello + World! = HelloWorld!

Second: s1 == s3

Press any key to continue . . .

*/

}

运算符重载函数可以是类的成员函数，也可以是类的友元函数，还可以是既非类的成员函数也不是友元函数的普通函数。现在分别讨论这3种情况。

首先，只有在极少的情况下才使用既不是类的成员函数也不是友元函数的普通函数，普遍的原因是: 普通函数不能直接访问类的私有成员。

在剩下的两种方式中，什么时候应该用成员函数方式，什么时候应该用友元函数方式？二者有何区别呢？如果将运算符重载函数作为成员函数，它可以通过this指针自由地访问本类的数据成员，因此可以少写一个函数的参数。但必须要求运算表达式第一个参数(即运算符左侧的操作数)是一个类对象，而且与运算符函数的类型相同。因为必须通过类的对象去调用该类的成员函数，而且只有运算符重载函数返回值与该对象同类型，运算结果才有意义。表达式c1+c2中第一个参数c1是Complex类对象，运算符函数返回值的类型也是Complex，这是正确的。如果c1不是Complex类，它就无法通过隐式this指针访问Complex类的成员了。

如想将一个复数和一个整数相加，如c1+i，可以将运算符重载函数作为成员函数，如下面的形式：

Complex Complex∷operator+(int &i) //运算符重载函数作为Complex类的成员函数

{

return Complex(real+i，imag);

}

注意在表达式中重载的运算符“+”左侧应为Complex类的对象，如：

c3=c2+i;

不能写成

c3=i+c2; //运算符“+”的左侧不是类对象，编译出错

如果出于某种考虑，要求在使用重载运算符时运算符左侧的操作数是整型量(如表达式i+c2，运算符左侧的操作数i是整数)，这时是无法利用前面定义的重载运算符的，因为无法调用i.operator+函数。可想而知，如果运算符左侧的操作数属于C++标准类型(如int)或是一个其他类的对象，则运算符重载函数不能作为成员函数，只能作为非成员函数。如果函数需要访问类的私有成员，则必须声明为友元函数。可以在Complex类中声明：

friend Complex operator+(int &i，Complex &c); //第一个参数可以不是类对象

在类外定义友元函数：

Complex operator+(int &i, Complex &c) //运算符重载函数不是成员函数

{

return Complex(i+c.real, c.imag);

}

将双目运算符重载为友元函数时，在函数的形参表列中必须有两个参数，不能省略，形参的顺序任意，不要求第一个参数必须为类对象。但在使用运算符的表达式中，要求运算符左侧的操作数与函数第一个参数对应，运算符右侧的操作数与函数的第二个参数对应。如：

c3=i+c2; //正确，类型匹配

c3=c2+i; //错误，类型不匹配

请注意，数学上的交换律在此不适用。如果希望适用交换律，则应再重载一次运算符“+”。如

Complex operator+(Complex &c， int &i) //此时第一个参数为类对象

{

return Complex(i+c.real, c.imag);

}

这样，使用表达式i+c2和c2+i都合法，编译系统会根据表达式的形式选择调用与之匹配的运算符重载函数。可以将以上两个运算符重载函数都作为友元函数，也可以将一个运算符重载函数(运算符左侧为对象名的) 作为成员函数，另一个(运算符左侧不是对象名的)作为友元函数。但不可能将两个都作为成员函数，原因是显然的。

C++规定，有的运算符(如赋值运算符、下标运算符、函数调用运算符)必须定义为类的成员函数，有的运算符则不能定义为类的成员函数(如流插入“<<”和流提取运算符“>>”、类型转换运算符)。

由于友元的使用会破坏类的封装，因此从原则上说，要尽量将运算符函数作为成员函数。但考虑到各方面的因素，一般将单目运算符重载为成员函数，将双目运算符重载为友元函数,当同时符合友元和非友元重载时,优先选择非友元重载的函数

发布时间: 9年前【代码相关】123人已围观【返回】【回到顶端】

转载：个人转载请注明文章出处 "www.itarticle.cc-IT技术类文章收集&分享"。

很赞哦！ (1)