c++编程风格----读书笔记(2)

二、一致性

1、一致性示例，如下程序：

#include "stdafx.h"#include "iostream"class string{public:string(){str_ = new char[80];len_ = 80;}string(int len){str_ = new char[len];len_ = len;}string(char *p){len_ = strlen(p);str_ = new char[len_];strcpy(str_, p);}string(string &str);~string(){delete[] str_;}public:void Assign(char *str){strcpy(str_, str);len_ = strlen(str);}void Print(){std::cout << str_ << std::endl;}void concat(string &a, string &b);private:char *str_;int  len_;};string::string(string &str){len_ = str.len_;str_ = new char[len_];strcpy(str_, str.str_);}void string::concat(string &a, string &b){len_ = a.len_ + b.len_;str_ = new char[len_];strcpy(str_, a.str_);strcat(str_, b.str_);}int _tmain(int argc, _TCHAR* argv[]){char *str = "The wheel that squeaks the loudest\n";string a(str);string b;string author("Josh Billings\n");string both;string quote;b.Assign("Is the one that gets the grease\n");both.concat(a, b);quote.concat(both, author);quote.Print();return 0;}

不足的地方

a、应该明确定义的状态

比如使用了string x, y(128); x.print();

那现在x的值是不确定的，输出的时候必要要等到’\0’才会停止(所有有构造函数应该使得对象处于明确的定义状态)

b、物理状态的一致性

看两段代码

string(char *p){len_ = strlen(p);str_ = new char[len_ + 1];strcpy(str_, p);}

void string::concat(string &a, string &b){len_ = a.len_ + b.len_;str_ = new char[len_];strcpy(str_, a.str_);strcat(str_, b.str_);}

在这两个函数中len_所表示的含义有两个，一个是字符串的长度，另外一个是数组的长度；显然，len_的这两种含义都是有意义的，但在所有的构造函数及其他的成员函数中，必须只能有一种(所有的成员必须只有一个明确的定义，用一致的方式来定义对象的状态，这需要识别出类不变性)

c、动态内存的一致性

看这里的三段代码：

string(){str_ = new char[80];len_ = 80;}

string(int len){str_ = new char[len];len_ = len;}

void string::concat(string &a, string &b){len_ = a.len_ + b.len_;str_ = new char[len_];strcpy(str_, a.str_);strcat(str_, b.str_);}

    可以看到，上面动态分配的内存都是不一致的；要做到一致，有两种选择，一是只能是确保一开始分配的空间足够大，二是对每个字符串值都动态地决定数组的大小以保证安全。

    这两种方法都可以用在类中，但只能使用其中的一种，以保持类的一致性，而不应该将这两种方法混合使用。否则，在使用这个类时，不得不去了解在接口中不同操作之间的不用约定(类的接口定义应该是一致的--------避免产生困惑)

d、动态内存的回收

来看字符串连接的一个问题

void string::concat(string &a, string &b){len_ = a.len_ + b.len_;str_ = new char[len_];strcpy(str_, a.str_);strcat(str_, b.str_);}

原来的空间显然被泄露掉了(对于每个new操作，都要有相应的delete操作)

看看重新设计的一个string类

#include "stdafx.h"#include "iostream"class string{public:string();string(const char *pStr);string(string& str);~string();const char *content() const;string& operator=(const char *pStr);string& operator=(const string &str);private:char *string_;int  length_;};char *Strdup(const char *pStr){char *pTemp = new char[strlen(pStr) + 1];strcpy(pTemp, pStr);return pTemp;}string::string(){string_ = 0;length_ = 0;}string::string(const char *pStr){string_ = pStr ? Strdup(pStr) : 0;length_ = pStr ? strlen(string_) : 0;}string::string(string& str){if (str.string_){string_ = Strdup(str.string_);length_ = strlen(string_);}else{string_ = 0;length_ = 0;}}string::~string(){if (string_){delete[] string_;}}const char *string::content() const{return string_ ? string_ : 0;}string& string::operator=(const char *pStr){delete[] string_;string_ = pStr ? Strdup(pStr) : 0;length_ = pStr ? strlen(string_) : 0;return *this;}string& string::operator=(const string &str){delete[] string_;string_ = str.string_ ? Strdup(str.string_) : 0;length_ = string_     ? strlen(string_) : 0;return *this;}int _tmain(int argc, _TCHAR* argv[]){string author("zengraoli");return 0;}

该类使用了动态分配的形式，这样更能有效的避免数组的溢出

但是这里还有一些不足的地方：

a、冗余

length_的引入，一开始是为了表示字符串的长度，但是在这里这个信息却从来没有使用过。在string中，当每次需要字符串长度时，这个值都将在辅助函数Strdup中重新计算，所以这个状态信息是多余的(避免对从不使用的状态信息进行计算和存储)

b、在operator=中存在的一些问题

    可以看到在operator=(const string &str)上面，先是delete，虽然不太容易写出像x=x这样的表达式，但是在程序中可能会简接地导致这种复赋值运算的发生(如果a和b碰巧都是引用了同一个string对象，纳闷呢a=b就等价于x=x)。虽然先delete就会导致操作未定义的内存。

所以最好的方式是首先处理自赋值

string& string::operator=(const string &str){if (&str == this){return *this;}delete[] string_;string_ = str.string_ ? Strdup(str.string_) : 0;length_ = string_     ? strlen(string_) : 0;return *this;}    

    对于operator=(const char *pStr)中的delete操作，可能会导致问题的情况是x=x.string()，或者虽然以a=b.string()的形式出现，但a和b的字符指针指向的是同一个地址。在执行x=s的赋值运算时，如常量字符类型指针s的值的等于x.string()，那么将会产生和上面同样的问题。解决的办法是将delete操作符推迟到字符串被复制之后在进行

string& string::operator=(const char *pStr){char *prevString = string_;string_ = pStr ? Strdup(pStr) : 0;length_ = pStr ? strlen(string_) : 0;delete[] prevString;return *this;}

c、最后一个细节的问题

关于Strdup函数，这个函数的作用是对字符串进行复制并存储在一块新分配的内存中。你会发现上面的代码，在调用该函数的时候都遵循着同样的形式：在每次调用之间，都要进行测试以保证参数指针是非空的；在从函数中返回之后，返回结果都是保存在string_中。因此可以看到简化的地方。

最终得到的修改版本：

#include "stdafx.h"#include "iostream"class string{public:string();string(const char *pStr);string(string& str);~string();const char *content() const;string& operator=(const char *pStr);string& operator=(const string &str);private:void duplicate(const char *pStr);private:char *string_;};void string::duplicate(const char *pStr){if (pStr){string_ = new char[strlen(pStr) + 1];strcpy(string_, pStr);}else{string_ = 0;}}string::string(){string_ = 0;}string::string(const char *pStr){duplicate(pStr);}string::string(string& str){duplicate(str.string_);}string::~string(){if (string_){delete[] string_;}}const char *string::content() const{return string_ ? string_ : 0;}string& string::operator=(const char *pStr){char *prevString = string_;duplicate(pStr);delete[] prevString;return *this;}string& string::operator=(const string &str){if (&str == this){return *this;}delete[] string_;duplicate(str.string_);return *this;}int _tmain(int argc, _TCHAR* argv[]){string author("zengraoli");return 0;}