高质量C++/C编程指南

作者: Mr希灵 | 来源:发表于2016-04-17 20:39 被阅读241次

1 文件结构

每个C++/C程序通常分为两个文件。一个文件用于保存程序的声明（declaration），称为头文件。另一个文件用于保存程序的实现（implementation），称为定义（definition）文件。C++/C程序的头文件以“.h”为后缀，C程序的定义文件以“.c”为后缀，C++程序的定义文件通常以“.cpp”为后缀。

头文件的结构与作用

头文件主要有两个作用：

通过头文件来调用库功能。在很多场合，源代码不便（或不准）向用户公布，只要向用户提供头文件和二进制的库即可。用户只需要按照头文件中的接口声明来调用库功能，而不必关心接口怎么实现的。编译器会从库中提取相应的代码。
头文件能加强类型安全检查。如果某个接口被实现或被使用时，其方式与头文件中的声明不一致，编译器就会指出错误，这一简单的规则能大大减轻程序员调试、改错的负担。

头文件由三部分组成：头文件开头处的版权和版本声明，预处理块，函数和类结构声明等。

为了防止头文件被重复引用，应当用ifndef/define/endif结构产生预处理块。
用 #include <filename.h> 格式来引用标准库的头文件（编译器将从标准库目录开始搜索）。
用 #include “filename.h” 格式来引用非标准库的头文件（编译器将从用户的工作目录开始搜索）。
头文件中只存放“声明”而不存放“定义”。在C++ 语法中，类的成员函数可以在声明的同时被定义，并且自动成为内联函数。这虽然会带来书写上的方便，但却造成了风格不一致，弊大于利。建议将成员函数的定义与声明分开，不论该函数体有多么小。
不提倡使用全局变量，尽量不要在头文件中出现象extern int value 这类声明。

假设头文件名称为 graphics.h，头文件的结构参见示例1.1

/*
* Copyright (c) 2001,上海贝尔有限公司网络应用事业部
* All rights reserved.
* 
* 文件名称：filename.h
* 文件标识：见配置管理计划书
* 摘    要：简要描述本文件的内容
* 
* 当前版本：1.1
* 作    者：输入作者（或修改者）名字
* 完成日期：2001年7月20日
*
* 取代版本：1.0 
* 原作者  ：输入原作者（或修改者）名字
* 完成日期：2001年5月10日
*/

#ifndef GRAPHICS_H  // 防止graphics.h被重复引用
#define GRAPHICS_H
 
#include <math.h>       // 引用标准库的头文件
…
#include “myheader.h”   // 引用非标准库的头文件
…
void Function1(…);  // 全局函数声明
…
class Box               // 类结构声明
{
…
};
#endif

定义文件的结构

定义文件有三部分内容：定义文件开头处的版权和版本声明，对一些头文件的引用，程序的实现体（包括数据和代码）。

假设定义文件的名称为 graphics.cpp，定义文件的结构参见示例1.2

// 版权和版本声明见示例1-1，此处省略。
 
#include “graphics.h”   // 引用头文件
…
 
// 全局函数的实现体
void Function1(…)
{
…
}
 
// 类成员函数的实现体
void Box::Draw(…)
{
…
}

目录结构

如果一个软件的头文件数目比较多（如超过十个），通常应将头文件和定义文件分别保存于不同的目录，以便于维护。例如可将头文件保存于include目录，将定义文件保存于source目录（可以是多级目录）。
如果某些头文件是私有的，它不会被用户的程序直接引用，则没有必要公开其“声明”。为了加强信息隐藏，这些私有的头文件可以和定义文件存放于同一个目录。

2 程序的版式

版式虽然不会影响程序的功能，但会影响可读性。程序的版式追求清晰、美观，是程序风格的重要构成因素。

尽可能在定义变量的同时初始化该变量。如果变量的引用处和其定义处相隔比较远，变量的初始化很容易被忘记。如果引用了未被初始化的变量，可能会导致程序错误。本建议可以减少隐患。
代码行内的空格。关键字之后要留空格，象const、virtual、inline、case 等关键字之后至少要留一个空格，以突出关键字；函数名之后不要留空格，紧跟左括号‘（’，以与关键字区别；赋值操作符、比较操作符、算术操作符、逻辑操作符、位域操作符，如“=”、“+=” “>=”、“<=”、“+”、“*”、“%”、“&&”、“||”、“<<”,“^”等二元操作符的前后应当加空格；一元操作符如“!”、“~”、“++”、“--”、“&”（地址运算符）等前后不加空格。
类的版式。建议采用“以行为为中心”的书写方式，即将public类型的函数写在前面，而将private类型的数据写在后面，重点关注的是类应该提供什么样的接口（或服务）。

3 命名规则

标识符应当直观且可以拼读，可望文知意。标识符最好采用英文单词或其组合，便于记忆和阅读。切忌使用汉语拼音来命名。程序中的英文单词一般不会太复杂，用词应当准确。例如不要把CurrentValue写成NowValue。
标识符的长度应当符合“min-length && max-information”原则。单字符的名字也是有用的，常见的如i,j,k,m,n,x,y,z等，它们通常可用作函数内的局部变量。
命名规则尽量与所采用的操作系统或开发工具的风格保持一致。例如Windows应用程序的标识符通常采用“大小写”混排的方式，如AddChild。而Unix应用程序的标识符通常采用“小写加下划线”的方式，如add_child。别把这两类风格混在一起用。
变量的名字应当使用“名词”或者“形容词＋名词”。float value;``float oldValue;
全局函数的名字应当使用“动词”或者“动词＋名词”（动宾词组）。类的成员函数应当只使用“动词”，被省略掉的名词就是对象本身。

DrawBox();      // 全局函数
box->Draw();        // 类的成员函数

尽量避免名字中出现数字编号，如Value1,Value2等，除非逻辑上的确需要编号。

简单的Windows应用程序命名规则

类名和函数名用大写字母开头的单词组合而成。

class Node;                 // 类名
class LeafNode;             // 类名
void  Draw(void);           // 函数名
void  SetValue(int value);  // 函数名

变量和参数用小写字母开头的单词组合而成。
常量全用大写的字母，用下划线分割单词。const int MAX_LENGTH = 100;
静态变量加前缀s_（表示static）。static int s_initValue;
如果不得已需要全局变量，则使全局变量加前缀g_（表示global）。
类的数据成员加前缀m_（表示member），这样可以避免数据成员与成员函数的参数同名。

void Object::SetValue(int width, int height)
{
    m_width = width;
    m_height = height;
}

为了防止某一软件库中的一些标识符和其它软件库中的冲突，可以为各种标识符加上能反映软件性质的前缀。例如三维图形标准OpenGL的所有库函数均以gl开头，所有常量（或宏定义）均以GL开头。

4 表达式和基本语句

运算符的优先级

C++/C语言的运算符有数十个，运算符的优先级与结合律如图所示。注意一元运算符 + - * 的优先级高于对应的二元运算符。如果代码行中的运算符比较多，用括号确定表达式的操作顺序，避免使用默认的优先级。

if语句

布尔变量与零值比较：不可将布尔变量直接与TRUE、FALSE或者1、0进行比较。根据布尔类型的语义，零值为“假”（记为FALSE），任何非零值都是“真”（记为TRUE）。TRUE的值究竟是什么并没有统一的标准。例如Visual C++ 将TRUE定义为1，而Visual Basic则将TRUE定义为-1。假设布尔变量名字为flag，它与零值比较的标准if语句如下：

if (flag)   // 表示flag为真
if (!flag)  // 表示flag为假

整型变量与零值比较：应当将整型变量用“==”或“！=”直接与0比较。假设整型变量的名字为value，它与零值比较的标准if语句如下：

if (value == 0)  
if (value != 0)

浮点变量与零值比较：不可将浮点变量用“==”或“！=”与任何数字比较。千万要留意，无论是float还是double类型的变量，都有精度限制。所以一定要避免将浮点变量用“==”或“！=”与数字比较，应该设法转化成“>=”或“<=”形式。

if ((x>=-EPSINON) && (x<=EPSINON))  //EPSINON是允许的误差（即精度）。

指针变量与零值比较：应当将指针变量用“==”或“！=”与NULL比较。指针变量的零值是“空”（记为NULL）。尽管NULL的值与0相同，但是两者意义不同。假设指针变量的名字为p，它与零值比较的标准if语句如下：

if (p == NULL)  // p与NULL显式比较，强调p是指针变量
if (p != NULL)

有时候我们可能会看到 if (NULL == p) 这样古怪的格式。不是程序写错了，是程序员为了防止将 if (p == NULL) 误写成 if (p = NULL)，而有意把p和NULL颠倒。编译器认为 if (p = NULL) 是合法的，但是会指出 if (NULL = p)是错误的，因为NULL不能被赋值。

循环语句

C++/C循环语句中，for语句使用频率最高，while语句其次，do语句很少用。本节重点论述循环体的效率。提高循环体效率的基本办法是降低循环体的复杂性。

在多重循环中，如果有可能，应当将最长的循环放在最内层，最短的循环放在最外层，以减少CPU跨切循环层的次数。
不可在for 循环体内修改循环变量，防止for 循环失去控制。

switch语句

switch是多分支选择语句，而if语句只有两个分支可供选择。虽然可以用嵌套的if语句来实现多分支选择，但那样的程序冗长难读。这是switch语句存在的理由。switch语句的基本格式是：

switch (variable)
{
    case value1 :   … 
        break;
    case value2 :   … 
        break;
        …
    default :   … 
        break;
}

每个case语句的结尾不要忘了加break，否则将导致多个分支重叠（除非有意使多个分支重叠）。
不要忘记最后那个default分支。即使程序真的不需要default处理，也应该保留语句 default : break; 这样做并非多此一举，而是为了防止别人误以为你忘了default处理。

5 常量

常量是一种标识符，它的值在运行期间恒定不变。C++ 语言可以用const来定义常量，也可以用 #define来定义常量。但是前者比后者有更多的优点，建议用const常量完全取代宏常量。

const常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意料不到的错误（边际效应）。
有些集成化的调试工具可以对const常量进行调试，但是不能对宏常量进行调试。

常量定义规则：需要对外公开的常量放在头文件中，不需要对外公开的常量放在定义文件的头部。为便于管理，可以把不同模块的常量集中存放在一个公共的头文件中。如果某一常量与其它常量密切相关，应在定义中包含这种关系，而不应给出一些孤立的值。

类中的常量

有时我们希望某些常量只在类中有效。由于#define定义的宏常量是全局的，不能达到目的，于是想当然地觉得应该用const修饰数据成员来实现。const数据成员的确是存在的，但其含义却不是我们所期望的。const数据成员只在某个对象生存期内是常量，而对于整个类而言却是可变的，因为类可以创建多个对象，不同的对象其const数据成员的值可以不同。

const数据成员的初始化只能在类构造函数的初始化表中进行，不能在类声明中初始化。（这里是否可以考虑将其定义为静态类型？）

怎样才能建立在整个类中都恒定的常量呢？别指望const数据成员了，应该用类中的枚举常量来实现。枚举常量不会占用对象的存储空间，它们在编译时被全部求值。枚举常量的缺点是：它的隐含数据类型是整数，其最大值有限，且不能表示浮点数（如PI=3.14159）。

class A
{…
    enum { SIZE1 = 100, SIZE2 = 200}; // 枚举常量
    int array1[SIZE1];  
    int array2[SIZE2];
};

6 函数设计

函数接口的两个要素是参数和返回值。C语言中，函数的参数和返回值的传递方式有两种：值传递（pass by value）和指针传递（pass by pointer）。C++ 语言中多了引用传递（pass by reference）。

如果参数是指针，且仅作输入用，则应在类型前加const，以防止该指针在函数体内被意外修改。
如果输入参数以值传递的方式传递对象，则宜改用“const &”方式来传递，这样可以省去临时对象的构造和析构过程，从而提高效率。
避免函数有太多的参数，参数个数尽量控制在5个以内。如果参数太多，在使用时容易将参数类型或顺序搞错。
不要将正常值和错误标志混在一起返回。正常值用输出参数获得，而错误标志用return语句返回。
有时候函数原本不需要返回值，但为了增加灵活性如支持链式表达，可以附加返回值。例如字符串拷贝函数strcpy的原型：

char *strcpy(char *strDest，const char *strSrc);

strcpy函数将strSrc拷贝至输出参数strDest中，同时函数的返回值又是strDest。这样做并非多此一举，可以获得如下灵活性：

char str[20];
int  length = strlen( strcpy(str, “Hello World”) );

如果函数的返回值是一个对象，有些场合用“引用传递”替换“值传递”可以提高效率。而有些场合只能用“值传递”而不能用“引用传递”，否则会出错。

函数内部实现的规则

在函数体的“入口处”，对参数的有效性进行检查。很多程序错误是由非法参数引起的，我们应该充分理解并正确使用“断言”（assert）来防止此类错误。
在函数体的“出口处”，对return语句的正确性和效率进行检查。如果函数有返回值，那么函数的“出口处”是return语句。我们不要轻视return语句。如果return语句写得不好，函数要么出错，要么效率低下。
return语句不可返回指向“栈内存”的“指针”或者“引用”，因为该内存在函数体结束时被自动销毁。
要搞清楚返回的究竟是“值”、“指针”还是“引用”。

使用断言

程序一般分为Debug版本和Release版本，Debug版本用于内部调试，Release版本发行给用户使用。断言assert是仅在Debug版本起作用的宏，它用于检查“不应该”发生的情况。在运行过程中，如果assert的参数为假，那么程序就会中止（一般地还会出现提示对话，说明在什么地方引发了assert）。

//复制不重叠的内存块
void  *memcpy(void *pvTo, const void *pvFrom, size_t size)
{
    assert((pvTo != NULL) && (pvFrom != NULL));     // 使用断言
    byte *pbTo = (byte *) pvTo;     // 防止改变pvTo的地址
    byte *pbFrom = (byte *) pvFrom; // 防止改变pvFrom的地址
    while(size -- > 0 )
        *pbTo ++ = *pbFrom ++ ;
    return pvTo;
}

assert不是一个仓促拼凑起来的宏。为了不在程序的Debug版本和Release版本引起差别，assert不应该产生任何副作用。所以assert不是函数，而是宏。程序员可以把assert看成一个在任何系统状态下都可以安全使用的无害测试手段。如果程序在assert处终止了，并不是说含有该assert的函数有错误，而是调用者出了差错，assert可以帮助我们找到发生错误的原因。

使用断言捕捉不应该发生的非法情况。不要混淆非法情况与错误情况之间的区别，后者是必然存在的并且是一定要作出处理的。
在函数的入口处，使用断言检查参数的有效性（合法性）。
在编写函数时，要进行反复的考查，并且自问：“我打算做哪些假定？”一旦确定了的假定，就要使用断言对假定进行检查。

引用与指针的比较

n相当于m的别名，对n的任何操作就是对m的操作。引用被创建的同时必须被初始化（指针则可以在任何时候被初始化）。不能有NULL引用，引用必须与合法的存储单元关联（指针则可以是NULL）。一旦引用被初始化，就不能改变引用的关系（指针则可以随时改变所指的对象）。

引用的主要功能是传递函数的参数和返回值。C++语言中，函数的参数和返回值的传递方式有三种：值传递、指针传递和引用传递。指针能够毫无约束地操作内存中的如何东西，尽管指针功能强大，但是非常危险。

7 内存管理

内存分配方式

内存分配方式有三种：

从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static变量。
从栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
从堆上创建。亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。动态内存的生存期由我们决定，使用非常灵活，但问题也最多。

常见的内存错误及其策略

发生内存错误是件非常麻烦的事情。编译器不能自动发现这些错误，通常是在程序运行时才能捕捉到。而这些错误大多没有明显的症状，时隐时现，增加了改错的难度。常见的内存错误及其对策如下：

内存分配未成功，却使用了它。常用解决办法是，在使用内存之前检查指针是否为NULL。如果指针p是函数的参数，那么在函数的入口处用assert(p!=NULL)进行检查。如果是用malloc或new来申请内存，应该用if(p==NULL) 或if(p!=NULL)进行防错处理。
内存分配虽然成功，但是尚未初始化就引用它。犯这种错误主要有两个起因：一是没有初始化的观念；二是误以为内存的缺省初值全为零，导致引用初值错误（例如数组）。内存的缺省初值究竟是什么并没有统一的标准，尽管有些时候为零值，我们宁可信其无不可信其有。所以无论用何种方式创建数组，都别忘了赋初值，即便是赋零值也不可省略。
内存分配成功并且已经初始化，但操作越过了内存的边界。例如在使用数组时经常发生下标“多1”或者“少1”的操作。特别是在for循环语句中，循环次数很容易搞错，导致数组操作越界。
忘记了释放内存，造成内存泄露。含有这种错误的函数每被调用一次就丢失一块内存。刚开始时系统的内存充足，你看不到错误。终有一次程序突然死掉，系统出现提示：内存耗尽。动态内存的申请与释放必须配对，程序中malloc与free的使用次数一定要相同，否则肯定有错误（new/delete同理）。
释放了内存却继续使用它。函数的return语句写错了，注意不要返回指向“栈内存”的“指针”或者“引用”，因为该内存在函数体结束时被自动销毁；使用free或delete释放了内存后，没有将指针设置为NULL。导致产生“野指针”。

遵守以下规则：

用malloc或new申请内存之后，应该立即检查指针值是否为NULL。防止使用指针值为NULL的内存。
不要忘记为数组和动态内存赋初值。防止将未被初始化的内存作为右值使用。
避免数组或指针的下标越界，特别要当心发生“多1”或者“少1”操作。
动态内存的申请与释放必须配对，防止内存泄漏。
用free或delete释放了内存之后，立即将指针设置为NULL，防止产生“野指针”。

指针与数组的对比

C/C++程序中，指针和数组在不少地方可以相互替换着用，让人产生一种错觉，以为两者是等价的。数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。数组名对应着（而不是指向）一块内存，其地址与容量在生命期内保持不变，只有数组的内容可以改变。指针可以随时指向任意类型的内存块，它的特征是“可变”，所以我们常用指针来操作动态内存。指针远比数组灵活，但也更危险。

不能对数组名进行直接复制与比较。若想把数组a的内容复制给数组b，不能用语句 b = a ，否则将产生编译错误。应该用标准库函数strcpy进行复制。同理，比较b和a的内容是否相同，不能用if(b==a) 来判断，应该用标准库函数strcmp进行比较。

// 数组…
char a[] = "hello";
char b[10];
strcpy(b, a);           // 不能用  b = a;
if(strcmp(b, a) == 0)   // 不能用  if (b == a)
…
// 指针…
int len = strlen(a);
char *p = (char *)malloc(sizeof(char)*(len+1));
strcpy(p,a);            // 不要用 p = a;
if(strcmp(p, a) == 0)   // 不要用 if (p == a)
…

用运算符sizeof可以计算出数组的容量（字节数），sizeof(a)的值是12（注意别忘了’\0’）。指针p指向a，但是sizeof(p)的值却是4。这是因为sizeof(p)得到的是一个指针变量的字节数，相当于sizeof(char*)，而不是p所指的内存容量。C++/C语言没有办法知道指针所指的内存容量，除非在申请内存时记住它。

注意当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。

char a[] = "hello world";
char *p  = a;
cout<< sizeof(a) << endl;   // 12字节
cout<< sizeof(p) << endl;   // 4字节
void Func(char a[100])
{
    cout<< sizeof(a) << endl;   // 4字节而不是100字节
}

指针参数是如何传递内存的？

如果函数的参数是一个指针，不要指望用该指针去申请动态内存。下例中main函数中的语句GetMemory(str, 200)并没有使str获得期望的内存，str依旧是NULL。这个问题出在函数GetMemory中。编译器总是要为函数的每个参数制作临时副本，指针参数p的副本是 _p，编译器使 _p = p。如果函数体内的程序修改了_p的内容，就导致参数p的内容作相应的修改。这就是指针可以用作输出参数的原因。在本例中，_p申请了新的内存，只是把_p所指的内存地址改变了，但是p丝毫未变。所以函数GetMemory并不能输出任何东西。事实上，每执行一次GetMemory就会泄露一块内存，因为没有用free释放内存。

void GetMemory(char *p, int num)
{
    p = (char *)malloc(sizeof(char) * num);
}
int main(void)
{
    char *str = NULL;
    GetMemory(str, 100);    // str 仍然为 NULL 
    strcpy(str, "hello");   // 运行错误
}

如果非得要用指针参数去申请内存，那么应该改用“指向指针的指针”。

void GetMemory2(char **p, int num)
{
    *p = (char *)malloc(sizeof(char) * num);
}
int main(void)
{
    char *str = NULL;
    GetMemory2(&str, 100);  // 注意参数是 &str，而不是str
    strcpy(str, "hello");   
    cout<< str << endl;
    free(str);  
}

由于“指向指针的指针”这个概念不容易理解，我们可以用函数返回值来传递动态内存。这种方法更加简单。

char *GetMemory3(int num)
{
    char *p = (char *)malloc(sizeof(char) * num);
    return p;
}
int main(void)
{
    char *str = NULL;
    str = GetMemory3(100);  
    strcpy(str, "hello");
    cout<< str << endl;
    free(str);  
}

用函数返回值来传递动态内存这种方法虽然好用，但是常常有人把return语句用错了。这里强调不要用return语句返回指向“栈内存”的指针，因为该内存在函数结束时自动消亡。

杜绝“野指针”

“野指针”不是NULL指针，是指向“垃圾”内存的指针。人们一般不会错用NULL指针，因为用if语句很容易判断。但是“野指针”是很危险的，if语句对它不起作用。“野指针”的成因主要有两种：

指针变量没有被初始化。任何指针变量刚被创建时不会自动成为NULL指针，它的缺省值是随机的，它会乱指一气。所以，指针变量在创建的同时应当被初始化，要么将指针设置为NULL，要么让它指向合法的内存。例如

char *p = NULL;
char *str = (char *) malloc(100);

指针p被free或者delete之后，没有置为NULL，让人误以为p是个合法的指针。
指针操作超越了变量的作用范围。这种情况让人防不胜防，示例程序如下：

class A 
{   
public:
    void Func(void){ cout << “Func of class A” << endl; }
};
    void Test(void)
{
    A  *p;
    {
        A  a;
        p = &a; // 注意 a 的生命期
    }
    p->Func();      // p是“野指针”
}

函数Test在执行语句p->Func()时，对象a已经消失，而p是指向a的，所以p就成了“野指针”。但奇怪的是我运行这个程序时居然没有出错，这可能与编译器有关。

malloc/free和new/delete

malloc与free是C++/C语言的标准库函数，new/delete是C++的运算符。它们都可用于申请动态内存和释放内存。

对于非内部数据类型的对象而言，光用maloc/free无法满足动态对象的要求。对象在创建的同时要自动执行构造函数，对象在消亡之前要自动执行析构函数。由于malloc/free是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数和析构函数的任务强加于malloc/free。因此C++语言需要一个能完成动态内存分配和初始化工作的运算符new，以及一个能完成清理与释放内存工作的运算符delete。

如果用free释放“new创建的动态对象”，那么该对象因无法执行析构函数而可能导致程序出错。如果用delete释放“malloc申请的动态内存”，理论上讲程序不会出错，但是该程序的可读性很差。所以new/delete必须配对使用，malloc/free也一样。

函数malloc的原型为void * malloc(size_t size)，用malloc申请一块长度为length的整数类型的内存，程序如下：

int  *p = (int *) malloc(sizeof(int) * length);

malloc返回值的类型是void *，所以在调用malloc时要显式地进行类型转换，将void * 转换成所需要的指针类型。malloc函数本身并不识别要申请的内存是什么类型，它只关心内存的总字节数，可以使用sizeof运算符求变量所占字节数。

函数free的原型为void free( void * memblock )。如果p是NULL指针，那么free对p无论操作多少次都不会出问题。如果p不是NULL指针，那么free对p连续操作两次就会导致程序运行错误。

new内置了sizeof、类型转换和类型安全检查功能。对于非内部数据类型的对象而言，new在创建动态对象的同时完成了初始化工作。如果对象有多个构造函数，那么new的语句也可以有多种形式。

class Obj
{
public :
    Obj(void);      // 无参数的构造函数
    Obj(int x);     // 带一个参数的构造函数
…
}
void Test(void)
{
    Obj  *a = new Obj;
    Obj  *b = new Obj(1);   // 初值为1
    …
    delete a;
    delete b;
}

如果用new创建对象数组，那么只能使用对象的无参数构造函数。例如

Obj  *objects = new Obj[100];   // 创建100个动态对象

在用delete释放对象数组时，留意不要丢了符号‘[]’。

delete []objects;   // 正确的用法
delete objects; // 错误的用法

后者相当于delete objects[0]，漏掉了另外99个对象。

8 C++函数的高级特性

对比于C语言的函数，C++增加了重载（overloaded）、内联（inline）、const和virtual四种新机制。其中重载和内联机制既可用于全局函数也可用于类的成员函数，const与virtual机制仅用于类的成员函数。

函数重载的概念

在C++程序中，可以将语义、功能相似的几个函数用同一个名字表示，即函数重载。这样便于记忆，提高了函数的易用性。

只能靠参数而不能靠返回值类型的不同来区分重载函数。编译器根据参数为每个重载函数产生不同的内部标识符。如果C++程序要调用已经被编译后的C函数，该怎么办？假设某个C函数的声明如下：

void foo(int x, int y);

该函数被C编译器编译后在库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字用来支持函数重载和类型安全连接。由于编译后的名字不同，C++程序不能直接调用C函数。C++提供了一个C连接交换指定符号extern“C”来解决这个问题。例如：

extern “C”
{
   void foo(int x, int y);
   … // 其它函数
}

//或者写成
extern “C”
{
   #include “myheader.h”
   … // 其它C头文件
}

这就告诉C++编译译器，函数foo是个C连接，应该到库中找名字_foo而不是找_foo_int_int。

注意并不是两个函数的名字相同就能构成重载。全局函数和类的成员函数同名不算重载，因为函数的作用域不同。

9 类的构造函数、析构函数与赋值函数

每个类只有一个析构函数和一个赋值函数，但可以有多个构造函数（包含一个拷贝构造函数，其它的称为普通构造函数）。对于任意一个类，如果不想编写上述函数，C++编译器将自动为产生四个缺省的函数。

注意：“缺省的拷贝构造函数”和“缺省的赋值函数”均采用“位拷贝”而非“值拷贝”的方式来实现，倘若类中含有指针变量，这两个函数注定将出错。

本章以类 String 的设计与实现为例，深入阐述被很多教科书忽视了的道理。String 的结构如下：

class String 
{ 
    public: 
        String(const char *str = NULL); // 普通构造函数 
        String(const String &other);  // 拷贝构造函数 
        ~ String(void);         // 析构函数 
        String & operate =(const String &other);  // 赋值函数 
    private: 
        char *m_data;        // 用于保存字符串 
};

构造函数与析构函数

不少难以察觉的程序错误是由于变量没有被正确初始化或清除造成的，而初始化和清除工作很容易被人遗忘。Stroustrup 在设计 C++语言时充分考虑了这个问题并很好地予以解决：把对象的初始化工作放在构造函数中，把清除工作放在析构函数中。当对象被创建时，构造函数被自动执行。当对象消亡时，析构函数被自动执行。这下就不用担心忘了对象的初始化和清除工作。让构造函数、析构函数与类同名，由于析构函数的目
的与构造函数的相反，就加前缀‘~’以示区别。

构造函数有个特殊的初始化方式叫“初始化表达式表”（简称初始化表）。初始化表位于函数参数表之后，却在函数体 {} 之前。这说明该表里的初始化工作发生在函数体内的任何代码被执行之前。构造函数初始化表的使用规则：

如果类存在继承关系，派生类必须在其初始化表里调用基类的构造函数。
类的 const 常量只能在初始化表里被初始化，因为它不能在函数体内用赋值的方式来初始化。
类的数据成员的初始化可以采用初始化表或函数体内赋值两种方式，这两种方式的效
率不完全相同。函数体内赋值其实是先进行默认初始化再进行赋值。非内部数据类型的成员对象应当采用第一种方式初始化，以获取更高的效率。

// String 的普通构造函数 
String::String(const char *str) 
{ 
    if(str==NULL) 
    { 
        m_data = new char[1]; 
        *m_data = ‘\0’; 
    }   
    else 
    { 
        int length = strlen(str); 
        m_data = new char[length+1]; 
        strcpy(m_data, str); 
    } 
}   

// String 的析构函数 
String::~String(void) 
{
    // 由于 m_data 是内部数据类型，也可以写成 delete m_data;
    delete [] m_data;
}

构造与析构的次序

构造从类层次的最根处开始，在每一层中，首先调用基类的构造函数，然后调用成员对象的构造函数。析构则严格按照与构造相反的次序执行，该次序是唯一的，否则编译器将无法自动执行析构过程。

一个有趣的现象是，成员对象初始化的次序完全不受它们在初始化表中次序的影响，只由成员对象在类中声明的次序决定。这是因为类的声明是唯一的，而类的构造函数可以有多个，因此会有多个不同次序的初始化表。如果成员对象按照初始化表的次序进行构造，这将导致析构函数无法得到唯一的逆序。

拷贝构造函数与赋值函数

本章开头讲过，如果不主动编写拷贝构造函数和赋值函数，编译器将以“位拷贝”的方式自动生成缺省的函数。倘若类中含有指针变量，那么这两个缺省的函数就隐含了错误。以类 String 的两个对象 a,b 为例，假设 a.m_data 的内容为“hello”，b.m_data的内容为“world”。现将 a 赋给 b，缺省赋值函数的“位拷贝”意味着执行 b.m_data = a.m_data。这将造成三个错误：一是 b.m_data 原有的内存没被释放，造成内存泄露；二是 b.m_data和 a.m_data 指向同一块内存，a 或 b 任何一方变动都会影响另一方；三是在对象被析构时，m_data 被释放了两次。

拷贝构造函数和赋值函数非常容易混淆，常导致错写、错用。拷贝构造函数是在对象被创建时调用的，而赋值函数只能被已经存在了的对象调用。以下程序中，第三个语句和第四个语句很相似，你分得清楚哪个调用了拷贝构造函数，哪个调用了赋值函数吗？

String  a(“hello”); 
String  b(“world”); 
String  c = a;  // 调用了拷贝构造函数，最好写成 c(a); 
c = b;  // 调用了赋值函数

// 拷贝构造函数 
String::String(const String &other) 
{   
    // 允许操作 other 的私有成员 m_data 
    int length = strlen(other.m_data);   
    m_data = new char[length+1]; 
    strcpy(m_data, other.m_data); 
} 

// 赋值函数 
String & String::operate =(const String &other) 
{   
    // (1) 检查自赋值 
    if(this == &other) 
        return *this; 

    // (2) 释放原有的内存资源 
    delete [] m_data; 

    // （3）分配新的内存资源，并复制内容 
    int length = strlen(other.m_data);   
    m_data = new char[length+1]; 
    strcpy(m_data, other.m_data); 

    // （4）返回本对象的引用 
    return *this; 
}

如果我们实在不想编写拷贝构造函数和赋值函数，又不允许别人使用编译器生成的缺省函数，只需将拷贝构造函数和赋值函数声明为私有函数，不用编写代码。

在派生类中实现类的基本函数

基类的构造函数、析构函数、赋值函数都不能被派生类继承。如果类之间存在继承关系，在编写上述基本函数时应注意以下事项：

派生类的构造函数应在其初始化表里调用基类的构造函数。
基类与派生类的析构函数应该为虚（即加 virtual 关键字）。

#include <iostream.h> 
class Base 
{ 
    public:  
    virtual ~Base() { cout<< "~Base" << endl ; } 
}; 

class Derived : public Base 
{ 
    public:  
    virtual ~Derived() { cout<< "~Derived" << endl ; } 
}; 

void main(void) 
{ 
    Base * pB = new Derived;  // upcast 
    delete pB; 
}

输出结果为：
~Derived
~Base
如果析构函数不为虚，那么输出结果为
~Base

在编写派生类的赋值函数时，注意不要忘记对基类的数据成员重新赋值。

class Base 
{ 
    public: 
    … 
    Base & operate =(const Base &other);  // 类 Base 的赋值函数 
    private:   int  m_i, m_j, m_k; 
}; 

class Derived : public Base 
{ 
    public: 
    … 
    Derived & operate =(const Derived &other);  // 类 Derived 的赋值函数 
    private: 
    int  m_x, m_y, m_z; 
}; 

Derived & Derived::operate =(const Derived &other) 
{ 
    //（1）检查自赋值 
    if(this == &other) 
    return *this; 

    //（2）对基类的数据成员重新赋值 
    Base::operate =(other); // 因为不能直接操作私有数据成员 

    //（3）对派生类的数据成员赋值 
    m_x = other.m_x; 
    m_y = other.m_y; 
    m_z = other.m_z; 

    //（4）返回本对象的引用 
    return *this; 
}