1：尽量用new和delete而不用malloc和freexSFLinux联盟
malloc和free(及其变体)会产生问题的原因在于它们太简单：他们不知道构造函数和析构函数。假设用两种方法给一个包含10个string对象的数组分配空间，一个用malloc，另一个用new： xSFLinux联盟
string *stringarray1 =static_cast〈string*〉(malloc(10 * sizeof(string)));xSFLinux联盟
string *stringarray2 = new string[10];xSFLinux联盟
其结果是，stringarray1确实指向的是可以容纳10个string对象的足够空间，但内存里并没有创建这些对象。而且，如果你不从这种晦涩的语法怪圈里跳出来的话，你没有办法来初始化数组里的对象。换句话说，stringarray1其实一点用也没有。相反，stringarray2指向的是一个包含10个完全构造好的string对象的数组,每个对象可以在任何读取string的操作里安全使用。假设你想了个怪招对stringarray1数组里的对象进行了初始化，那么在你后面的程序里你一定会这么做：xSFLinux联盟
free(stringarray1);xSFLinux联盟
delete [] stringarray2;xSFLinux联盟
调用free将会释放stringarray1指向的内存，但内存里的string对象不会调用析构函数。如果string对象象一般情况那样，自己已经分配了内存，那这些内存将会全部丢失。相反，当对stringarray2调用delete时，数组里的每个对象都会在内存释放前调用析构函数。既然new和delete可以这么有效地与构造函数和析构函数交互，选用它们是显然的。xSFLinux联盟
2: 尽量用〈iostream〉而不用〈stdio.h〉xSFLinux联盟
〈stdio.h〉 是C语言中格式输出、输入（prinft和scanf）的头文件，大家知道，他们的输出类型是有限制的，并且不可扩充，比如 %d 对应int 型等，书写很不方便。而在C++中，我们们引入“流”，并且通过操作符的重载，使得cout和cin 有很好的扩展性，再也不用像C中“%d 对应int 型”这样，因为通过函数的重载，它能自动匹配输出。而〈iostream〉正式C++中“流”的头文件。xSFLinux联盟
在传递读和写的对象时采用的语法形式相同，所以不必象scanf那样死记一些规定，比如如果没有得到指针，必须加上地址符，而如果已经得到了指针，又要确定不要加上地址符。这些完全可以交给C++编译器去做。编译器没别的什么事好做的，而你却不一样。最后要注意的是，象int这样的固定类型和象Rational这样的自定义类型在读写时方式是一样的。而你用sacnf和printf试试看！xSFLinux联盟
你所写的表示有理数的类的代码可能象下面这样：xSFLinux联盟
class Rational {xSFLinux联盟
public:xSFLinux联盟
Rational(int numerator = 0, int denominator = 1);xSFLinux联盟
..xSFLinux联盟
private:xSFLinux联盟
int n, d;// 分子，分母xSFLinux联盟
friend ostream& operator〈〈(ostream& s, const Rational& );xSFLinux联盟
};xSFLinux联盟
ostream& operator〈〈(ostream& s, const Rational& r)xSFLinux联盟
{xSFLinux联盟
s〈〈 r.n 〈〈 ’/’ 〈〈 r.d;xSFLinux联盟
return s;xSFLinux联盟
}xSFLinux联盟
3：如果你的Class中有任何指针，请为你的类戳写拷贝构造函数和“=”操作符xSFLinux联盟
我先简单说明一下：假设你的类有指针变量，如果你不重写“＝”，那么当你把一个对象ａ附给另一个对象ｂ时，它会调用默认的“＝”操作，而这个默认的“＝”操作会逐项附值，导致的结果是两个对象的指针指向同一个区域，当你析构一个对象时，另一个对象的指针指向了一个不再存在的地址，导致错误。xSFLinux联盟
看下面一个表示string对象的类：xSFLinux联盟
// 一个很简单的string类xSFLinux联盟
class string {xSFLinux联盟
public:xSFLinux联盟
string(const char *value);xSFLinux联盟
~string();xSFLinux联盟
... // 没有拷贝构造函数和operator=xSFLinux联盟
private:xSFLinux联盟
char *data;xSFLinux联盟
};xSFLinux联盟
string::string(const char *value)xSFLinux联盟
{xSFLinux联盟
if (value) {xSFLinux联盟
data = new char[strlen(value) + 1];xSFLinux联盟
strcpy(data, value);xSFLinux联盟
}xSFLinux联盟
else {xSFLinux联盟
data = new char[1];xSFLinux联盟
*data = ’\0’;xSFLinux联盟
}xSFLinux联盟
}xSFLinux联盟
inline string::~string() { delete [] data; }xSFLinux联盟
请注意这个类里没有声明赋值操作符和拷贝构造函数。这会带来一些不良后果。xSFLinux联盟
如果这样定义两个对象：xSFLinux联盟
string a(“hello“);xSFLinux联盟
string b(“world“);xSFLinux联盟
其结果就会如下所示：xSFLinux联盟
a: data——〉 “hello\0“xSFLinux联盟
b: data——〉 “world\0“xSFLinux联盟
对象a的内部是一个指向包含字符串“hello“的内存的指针，对象b的内部是一个指向包含字符串“world“的内存的指针。如果进行下面的赋值：xSFLinux联盟
b = a;xSFLinux联盟
因为没有自定义的operator=可以调用，c++会生成并调用一个缺省的operator=操作符。这个缺省的赋值操作符会执行从a的成员到b的成员的逐个成员的赋值操作，对指针(a.data和b.data) 来说就是逐位拷贝。赋值的结果如下所示：xSFLinux联盟
a: data --------〉 “hello\0“xSFLinux联盟
/xSFLinux联盟
b: data --/ “world\0“xSFLinux联盟
这种情况下至少有两个问题。第一，b曾指向的内存永远不会被删除，因而会永远丢失。这是产生内存泄漏的典型例子。第二，现在a和b包含的指针指向同一个字符串，那么只要其中一个离开了它的生存空间，其析构函数就会删除掉另一个指针还指向的那块内存。xSFLinux联盟
４：请让你的基类拥有虚析构函数xSFLinux联盟
这种情况的错误多出现在“多态”中。在“多态”中，我们经常通过基类的指针指向其派生类的对象，并且在程序运行时，通过“动态绑定技术”调用实际对象的成员。但是，在谈到析构问题上，c++语言标准关于这个问题的阐述非常清楚：当通过基类的指针去删除派生类的对象，而基类又没有虚析构函数时，结果将是不可确定的。这意味着编译器生成的代码将会做任何它喜欢的事：重新格式化你的硬盘，给你的老板发电子邮件，把你的程序源代码传真给你的对手，无论什么事都可能发生。xSFLinux联盟
不要问为什么，just do it, please!xSFLinux联盟
另外，给大家一个技巧：有时，一个类想跟踪它有多少个对象存在。一个简单的方法是创建一个静态类成员来统计对象的个数。这个成员被初始化为0，在构造函数里加1，析构函数里减1。设想在一个军事应用程序里，有一个表示敌人目标的类：xSFLinux联盟
class enemytarget {xSFLinux联盟
public:xSFLinux联盟
enemytarget() { ++numtargets; }xSFLinux联盟
enemytarget(const enemytarget&) { ++numtargets; }xSFLinux联盟
~enemytarget() { --numtargets; }xSFLinux联盟
static size_t numberoftargets()xSFLinux联盟
{ return numtargets; }xSFLinux联盟
virtual bool destroy(); // 摧毁enemytarget对象后xSFLinux联盟
// 返回成功xSFLinux联盟
private:xSFLinux联盟
static size_t numtargets; // 对象计数器xSFLinux联盟
};xSFLinux联盟
５：在operator=中检查给自己赋值的情况xSFLinux联盟
偶废话不多说，给你个例子：xSFLinux联盟
看看下面string对象的赋值，赋值运算符没有对给自己赋值的情况进行检查：xSFLinux联盟
class string {xSFLinux联盟
public:xSFLinux联盟
string(const char *value);xSFLinux联盟
~string();xSFLinux联盟
...xSFLinux联盟
string& operator=(const string& rhs);xSFLinux联盟
private:xSFLinux联盟
char *data;xSFLinux联盟
};xSFLinux联盟
// 忽略了给自己赋值的情况xSFLinux联盟
// 的赋值运算符xSFLinux联盟
string& string::operator=(const string& rhs)xSFLinux联盟
{xSFLinux联盟
delete [] data; // delete old memoryxSFLinux联盟
data = new char[strlen(rhs.data) + 1]; // 分配新内存，将rhs的值拷贝xSFLinux联盟
strcpy(data, rhs.data);xSFLinux联盟
return *this; // see item 15xSFLinux联盟
}xSFLinux联盟
看看下面这种情况将会发生什么：xSFLinux联盟
string a = “hello“;xSFLinux联盟
a = a; // same as a.operator=(a)xSFLinux联盟
赋值运算符内部，*this和rhs好象是不同的对象，但在现在这种情况下它们却恰巧xSFLinux联盟
是同一个对象的不同名字。可以这样来表示这种情况：xSFLinux联盟
*this data ------------〉 “hello\0“xSFLinux联盟
/xSFLinux联盟
/xSFLinux联盟
rhs data -----xSFLinux联盟
赋值运算符做的第一件事是用delete删除data，其结果将如下所示：xSFLinux联盟
*this data ------------〉 ???xSFLinux联盟
/xSFLinux联盟
/xSFLinux联盟
rhs data -----xSFLinux联盟
６：尽量用“传引用”而不用“传值”xSFLinux联盟
大家知道，引用又称为“别名”，它其实是一个对象的两个名字。比如把“人”当作一个“类”，我本科时候的宿舍老大“闫书磊”（呵呵，现在在成都电子）当作由“人”派生出来的特定对象，那么他的外号“闫秃”就是“闫书磊”的引用。但传值就有所不同，需要在内存重新开辟空间，然后将被传得对象复制一份，这就涉及到类型的定义，进而有可能继续调用“拷贝构造函数”。xSFLinux联盟
总而言之，从效率方面考虑，请用“传引用”。xSFLinux联盟
７：必须返回一个对象时不要试图返回一个引用xSFLinux联盟
据说爱因斯坦曾提出过这样的建议：尽可能地让事情简单，但不要过于简单。在c++语言中相似的说法应该是：尽可能地使程序高效，但不要过于高效。xSFLinux联盟
一旦程序员抓住了“传值”在效率上的把柄，他们会变得十分极端，恨不得挖出每一个隐藏在程序中的传值操作。岂不知，在他们不懈地追求纯粹的“传引用”的过程中，他们会不可避免地犯另一个严重的错误：传递一个并不存在的对象的引用。这就不是好事了。xSFLinux联盟
看一个表示有理数的类，其中包含一个友元函数，用于两个有理数相乘：xSFLinux联盟
class rational {xSFLinux联盟
public:xSFLinux联盟
rational(int numerator = 0, int denominator = 1);xSFLinux联盟
...xSFLinux联盟
private:xSFLinux联盟
int n, d; // 分子和分母xSFLinux联盟
friendxSFLinux联盟
const rational //xSFLinux联盟
operator*(const rational& lhs, // 返回值是constxSFLinux联盟
const rational& rhs)xSFLinux联盟
};xSFLinux联盟
inline const rational operator*(const rational& lhs,xSFLinux联盟
const rational& rhs)xSFLinux联盟
{xSFLinux联盟
return rational(lhs.n * rhs.n, lhs.d * rhs.d);xSFLinux联盟
}xSFLinux联盟
很明显，这个版本的operator*是通过传值返回对象结果，如果不去考虑对象构造和析构时的开销，你就是在逃避作为一个程序员的责任。另外一件很明显的事实是，除非确实有必要，否则谁都不愿意承担这样一个临时对象的开销。那么，问题就归结于：确实有必要吗？xSFLinux联盟
答案是，如果能返回一个引用，当然就没有必要。但请记住，引用只是一个名字，一个其它某个已经存在的对象的名字。无论何时看到一个引用的声明，就要立即问自己：它的另一个名字是什么呢？因为它必然还有另外一个什么名字。拿operator*来说，如果函数要返回一个引用，那它返回的必须是其它某个已经存在的rational对象的引用，这个对象包含了两个对象相乘的结果。但，期望在调用operator*之前有这样一个对象存在是没道理的。也就是说，如果有下面的代码：xSFLinux联盟
rational a(1, 2); // a = 1/2xSFLinux联盟
rational b(3, 5); // b = 3/5xSFLinux联盟
rational c = a * b; // c 为 3/10xSFLinux联盟
期望已经存在一个值为3/10的有理数是不现实的。如果operator* 一定要返回这样一个数的引用，就必须自己创建这个数的对象。xSFLinux联盟
一个函数只能有两种方法创建一个新对象：在堆栈里或在堆上。在堆栈里创建对象时伴随着一个局部变量的定义，采用这种方法，就要这样写operator*：xSFLinux联盟
// 写此函数的第一个错误方法xSFLinux联盟
inline const rational& operator*(const rational& lhs,xSFLinux联盟
const rational& rhs)xSFLinux联盟
{xSFLinux联盟
rational result(lhs.n * rhs.n, lhs.d * rhs.d);xSFLinux联盟
return result;xSFLinux联盟
}xSFLinux联盟
这个方法应该被否决，因为我们的目标是避免构造函数被调用，但result必须要象其它对象一样被构造。另外，这个函数还有另外一个更严重的问题，它返回的是一个局部对象的引用，那么，在堆上创建一个对象然后返回它的引用呢？基于堆的对象是通过使用new产生的，所以应该这样写operator*：xSFLinux联盟
// 写此函数的第二个错误方法xSFLinux联盟
inline const rational& operator*(const rational& lhs,xSFLinux联盟
const rational& rhs)xSFLinux联盟
{xSFLinux联盟
rational *result =xSFLinux联盟
new rational(lhs.n * rhs.n, lhs.d * rhs.d);xSFLinux联盟
return *result;xSFLinux联盟
}xSFLinux联盟
首先，你还是得负担构造函数调用的开销，因为new分配的内存是通过调用一个适当的构造函数来初始化的。另外，还有一个问题：谁将负责用delete来删除掉new生成的对象呢？实际上，这绝对是一个内存泄漏xSFLinux联盟
８：有关Const的相关知识xSFLinux联盟
对指针来说，可以指定指针本身为const，也可以指定指针所指的数据为const，或二者同时指定为const，还有，两者都不指定为const：xSFLinux联盟
char *p = “hello“; // 非const指针, 非const数据const char *p = “hello“; // 非const指针, const数据char * const p = “hello“; // const指针, 非const数据const char * const p = “hello“; // const指针, const数据xSFLinux联盟
语法并非看起来那么变化多端。一般来说，你可以在头脑里画一条垂直线穿过指针声明中的星号（*）位置，如果const出现在线的左边，指针指向的数据为常量；如果const出现在线的右边，指针本身为常量；如果const在线的两边都出现，二者都是常量。xSFLinux联盟
在指针所指为常量的情况下，有些程序员喜欢把const放在类型名之前，有些程序员则喜欢把const放在类型名之后、星号之前。所以，下面的函数取的是同种参数类型：xSFLinux联盟
class widget { ... };xSFLinux联盟
void f1(const widget *pw); // f1取的是指向 widget常量对象的指针void f2(widget const *pw); // 同f2xSFLinux联盟
因为两种表示形式在实际代码中都存在，所以要使自己对这两种形式都习惯。xSFLinux联盟
const的一些强大的功能基于它在函数声明中的应用。在一个函数声明中，const可以指的是函数的返回值，或某个参数；对于成员函数，还可以指的是整个函数。xSFLinux联盟
让函数返回一个常量值经常可以在不降低安全性和效率的情况下减少用户出错的几率。例如，看这个有理数的operator*函数的声明：xSFLinux联盟
const rational operator*(const rational& lhs,const rational& rhs);xSFLinux联盟
很多程序员第一眼看到它会纳闷：为什么operator*的返回结果是一个const对象？因为如果不是这样，用户就可以做下面这样的坏事：xSFLinux联盟
rational a, b, c;xSFLinux联盟
...xSFLinux联盟
(a * b) = c; // 对a*b的结果赋值xSFLinux联盟
我不知道为什么有些程序员会想到对两个数的运算结果直接赋值，但我却知道：如果a，b和c是固定类型，这样做显然是不合法的。一个好的用户自定义类型的特征是，它会避免那种没道理的与固定类型不兼容的行为。对我来说，对两个数的运算结果赋值是非常没道理的。声明operator*的返回值为const可以防止这种情况，所以这样做才是正确的。xSFLinux联盟
还有一种情况下，通过类型转换消除const会既有用又安全。这就是：将一个const对象传递到一个取非const参数的函数中，同时你又知道参数不会在函数内部被修改的情况时。第二个条件很重要，因为对一个只会被读的对象（不会被写）消除const永远是安全的，即使那个对象最初曾被定义为const。xSFLinux联盟
例如，已经知道有些库不正确地声明了象下面这样的strlen函数：xSFLinux联盟
size_t strlen(char *s);xSFLinux联盟
strlen当然不会去修改s所指的数据——至少我一辈子没看见过。但因为有了这个声明，对一个const char *类型的指针调用这个函数时就会不合法。为解决这个问题，可以在给strlen传参数时安全地把这个指针的const强制转换掉：xSFLinux联盟
const char *klingongreeting = “nuqneh“; // “nuqneh“即“hello“xSFLinux联盟
size_t length =strlen(const_cast〈char*〉(klingongreeting));xSFLinux联盟
但不要滥用这个方法。只有在被调用的函数（比如本例中的strlen）不会修改它的参数所指的数据时，才能保证它可以正常工作。xSFLinux联盟
我下面说一下有关const指针的用法（这一部分大家可参考C++Primer(3)）xSFLinux联盟
当我们写下下面的代码xSFLinux联盟
Const double value=3.0;xSFLinux联盟
Double *ptr=&value; (error)xSFLinux联盟
编译器会报错，因为它把“试图通过该指针间接地改变对象值”的动作标记为错误。但是这并不意味着我们不能间接的指向一个const对象，只标明我们必须声明一个指向常量的指针来做这件事情。例如xSFLinux联盟
Const double *cptr=&value; ( right)xSFLinux联盟
此时，类似于*cptr=3.8等的改变原值的附值操作是错的，因为我们不能改变常量指针所指对象的值。xSFLinux联盟
但是，常量指针也可以指向一个非常量对象，例如xSFLinux联盟
Double meng=23.3; cptr=&meng; (right)xSFLinux联盟
虽然meng 不是常量，但是，试图通过cptr改变它的值仍然会导致编译错误。xSFLinux联盟
在实际的程序中，指向const 的指针经常用来做函数参数，它作为一个月定：被传给函数的实际对象在函数种不能被修改。例如xSFLinux联盟
Int strcmp(const char *str1,const char *str2);xSFLinux联盟
这样的好处是，我们可以把常量或者非常量传递给此函数，而且次函数保证不会对它做修改。xSFLinux联盟
|
