(1)参数明确定义
- 构造函数应该使得对象处于明确定义的状态。
-
string() { s = new char[80]; } string( int n) { s = new char[n]; } //以上两个函数中,s没有被明确定义,如果只调用函数而没有给s赋值,则指针s指向空 //我们首先对s进行初始化,以确保s被明确定义。 //函数中我们将两个函数通过默认参数的形式,代替了函数重载以对上述函数进行精简。 string(int n = 80) { s = new char[n]; s[0] = '\0'; //初始化s的值 }
- 我们应该考虑使用默认参数的形式来代替函数重载的形式。
(2)物理状态一致
- 在同一个类里,同一参数在所有函数中的表示含义应该相同,以保证物理状态的一致性。
-
string::string(string& str) { len = str.len; s = new char[len]; } //从上面个函数可以看出,len表示s数组的大小,而下方个函数表示的是字符串的大小。如果len是数组长度,则分配的数组长度就会比所需数组长度大1. woid assign(char& str) { len = strlen(str); }
(3)类不变性
在C++语言中没有提供正式的语言机制来支持类不变性,而是由程序员自己决定如何实现类不变性。通常程序员会有一下两种实现类不变性的方式:
- 将不变性作为代码的注释,自己始终记住不变性。(最常用方法)例如:
-
char* s; int len; //len == strlen(s)
- 将不变性作为一个断言整合到代码中(通过在标准头文件assert.h中定义的assert宏 ,我们可以很容易地在代码中增加断言)。(没有尝试过)
(4)动态内存一致性
数组分配方式有两种:
- 静态分配:一种高效的方法。数组内存分配好后,在后续的操作中再不会去调用内存分配函数。
- 动态分配:更为安全的方法。每个字符串值都是动态的分配其内存,杜绝了数组“越界”的行为。
在同一个类中,我们应该保证所有的方法都使用同一种内存分配方式,不能混合使用。即
-
类的接口定义应该是一致的——避免产生困惑。
例如,程序员使用类中的A方法,并知道了A方法是使用的动态内存分配方式,则程序员会假定B方法也是使用的动态内存分配方式。因此,当在B中产生了数组内存越界问题时,估计他会像吃了X一样难受。
(5)动态内存的回收
class string1 {
char *s;
int len; // len == strlen(s)
public:
string1(int n = 80)
{
s = new char[n];
s[0] = '\0';
len = 0;
}
~string1() { delete [] s; }
void concat(string1& a, string1& b);
};
void string1::concat(string1& a, string1& b)
{
len = a.len + b.len;
s = new char[len + 1];
strcpy(s, a.s);
strcat(s, b.s);
}
当调用concat函数时,首先通过string1(int n = 80) 函数对数组进行了初始化,并将数组的指针保存到s中。在执行concat中的s = new char[len + 1];语句时,s马上被一个新的指针值覆盖,而前一个指针值被抛弃了,并且在执行析构函数时,无法对这块无指针的字符串进行内存释放,这块内存就成了一块垃圾内存。这就导致了内存的泄露。
这种情况一般采用,谁调用谁删除的原则,调用者在更改指针之前将原内存先进行释放。如下代码:
void string1::concat(string1& a, string1& b)
{
len = a.len + b.len;
char* new_s = new char[len+1];
strcpy(new_s, a.s);
strcat(new_s, b.s);
delete [] s;
s = new_s;
}
通过重新声明一个数组new_s去保存之前的操作,然后释放s,再将s指向数组new_s。
(6)其余
- 避免对从不使用的状态信息进行计算和存储。
- 用一个通用的函数来代替重复的表达式序列。
突然发现自己基础有点差,补基础去了。