高质量c/c++编程指南"读书笔记1

标签: 质量 编程 读书 | 发表时间:2012-08-13 01:33 | 作者:zengraoli
出处:http://blog.csdn.net

一个strcpy函数的代码
能考查三个方面
(1) 编程风格
(2) 出错处理
(3) 算法复杂度分析(用于提供性能)


定义编程老手和编程高手
定义1:能长期稳定地编写出高质量程序的程序员称为编程老手
定义2:能长期稳定地编写出高难度、高质量的程序与称为编程高手

 

第一章 文件结构


1.1 版权和版本的声明
版权和版本的声明位于头文件和定义文件的开头,主要内容有:
(1) 版权信息
(2) 文件名称、标识符、摘要
(3) 当前版本号、作者/修改者、完成日期
(4) 版本历史信息

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


1.2 头文件结构
    头文件由三部分内容组成
(1) 头文件开头处的版权和版本声明
(2) 预处理块
(3) 函数和类结构声明等
    为了防止头文件被重复用in用,应当用ifndef/define/endif结构产生预处理块
    头文件中只存放"声明"而不存放"定义"
  在C++语法中,类的成员函数可以在声明的同时被定义,并且自动成为内联函数。这虽然会带来书写上的方便,但却造成了风格不一致,弊大于利。建议将成员函数的定义与声明分开,不论该函数体有多么小。
    不提倡使用全局变量,尽量不要再头文件中出现像extern int value这类声明


1.3 头文件的作用
(1) 通过头文件来调用库功能。在很多场合,源代码不便(或不准)向用户公布,只要向用户提供头文件和二进制库即可。用户只需要按照头文件中的接口声明来调用库功能,而不必关系接口怎么实现的。编译器会从库中提取相应的代码。

(2) 头文件能加强类型安全监察。如果某个接口被实现或被使用时,其方式与头文件中的声明不一致,编译器就会指出错误,这一见到的规则能大大减轻程序员调试、改错的负担。


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

 

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


2.1 空行
    空行起着分隔程序段落的作用。空行得体(不过多也不过少)将使程序的布局更加清晰。空行不会浪费内存,虽然打印含有空行的程序是会多消耗一些纸张,但是值得。
(1) 在每个类声明之后、每个函数定义结束之后都要加空行
void Function1(...)
{}

vodi Function2(...)
{}

(2) 在一个函数体内,逻辑上密切相关的语句之间不加空行,其他地方应加空行分隔
while( flag )
{
    statement1;
    // 空行
    if( condition )
    {
       statement2;
    }
    else
    {
       statement3;
    }
    // 空行
    statement4;
}


2.2 代码行
(1) 一行代码只做一件事情,如之定义一个变量,或只写一条语句。这样的代码容易阅读,并且方便于写注释
int width;
int height;

(2) if、for、while、do等语句自占一行,执行语句不得紧跟其后。不论执行语句有多少都要加{}。这样可以防止书写失误


2.3 代码行内的空格
(1) 关键字之后要留空格。像const、virtual、inline、case等关键字之后至少要留一个空格,否则无法辨析关键字。想if、for、while等关键字之后应留一个空格再跟左括号'(',以突出关键字

(2) 代码行最大长度宜控制在70至80个字符以内。代码行不要过长,否则眼睛看不过来,也不便于打印

(3) 长表达式要在低优先级操作符处拆分成新航,操作符放在新行之首(以便突出操作符)。拆分出的新行要进行适当的缩进,使排版整齐,语句刻度
if (( very_longer_variable1 >= very_longer_variable2 )
   && (very_longer_variable3 <= very_longer_variable4 )
   && (very_longer_variable5 <= very_longer_variable6 ))
{...}


2.4 修饰符的位置
    应当将修饰符*和&紧靠变量名


2.5 注释
    C语言的注释符为"/*...*/"。C++语言中,程序块的注释常采用"/*...*/",行注释一般采用"//..."。注释通常用于:
 版本、版权声明
 函数接口说明
 重要的代码行或段落提示
    虽然注释有助于理解代码,但注意不可过多地使用注释
(1) 注释是对代码的“提示”,而不是文档。程序中的注释不可喧宾夺主,注释太多了会让人眼花缭乱。注释的花样要少

(2) 如果代码本来就是清楚的,则不必加注释。否则多此一举,令人厌烦例如
    i++; // i加1,多余的注释

(3) 边写代码边注释,修改代码同时修改相应的注释,以保证注释与代码的一致性。不再有用的注释要删除
/*
 *  函数介绍:
 *  输入参数:
 *  输出参数:
 *  返回值  :
*/
void Function(float x, float y, float z)
{
  …
}


2.6 类的版式
    类可以将数据和函数封装在一起,其中函数表示了类的行为(或称服务)。类提供关键字public、protected和private。这样可以达到信息隐藏的目的,即让类仅仅公开必须要让外界知道的内容,而隐藏其他一切内容。不可以滥用类的封装功能,不要把它当成火锅,什么东西都往里扔。
    将public类型的函数写在前面,而将private类型的数据写在后面,采用这种版式的程序员主张类的设计“以行为为中心”,重点关注的是类应该提供什么样的接口(或服务)
class A
{
  public:
  void Func1(void);
  void Func2(void);
  …
private:
  int    i, j;
  float  x, y;
  …
}

 

第三章 命名规则
    比较著名的命名规则当推MS公式的“匈牙利”法,该命名规则的主要思想是“在变量和函数名中加入前缀以增进人们对程序的理解”。例如所有的字符变量均以ch为前缀,若是指针变量则追加前缀p。如果一个变量有ppch开头,则表明它是指向字符指针的指针。
    匈牙利法最大缺点是繁琐


3.1 共性规则
(1) 标识符应当直观且可以品读,可望文知意,不必进行“解码”
标识符最好采用英文单词或其组合,便于记忆和阅读。切忌使用汉语拼音来命名。程序中的英文档次一般不会太复杂,用词应当准确。例如不要把CrurentValue写成NowValue

(2) 标识符的长度应当符合“min-length” && “max-information”原则。
几十年前老ANSI C规定名字不准超过6个字符,现今的C++/C不再有此限制。一般来说,长名字能更好地表达含义,所以函数名、变量名、类名长达十几个字符不足为奇。那么名字是否越长越好?不见得!例如变量名maxVal就比maxValueUntilOverflow好用。大字符的名字也是有用的,常见的如i,jk等,它们通常可以用作函数内的局部变量

(3) 命名规则尽量与所采用的操作系统或开发工具的风格保持一致。例如windows应用程序的标识符通常采用“大小写”混排的方式,如AddChild,而Unix应用程序的标识符通常采用“小写加下划线”的方式,如add_child。别把这两类风格混在一起用。

(4) 程序中不要出现紧靠大小写区分的相似的标识符。例如
int x, X; // 变量x与X容易混淆

(5) 变量的名字应当使用“名词”或者“形容词+名词”。例如
float value;
float oldValue;
float newValue;

(6) 全局函数的名字应当使用“动词”或者“动词+名词”(动宾词组)。类的成员函数应当只使用“动词”,被省略掉的名词就是对象本身。例如
DrawBox();   // 全局函数
bos->Draw(); // 类的成员函数


3.2 简单的windows应用程序命名规则
(1) 类名和函数名用大写字母开头的单词组合而成,例如:
class Node;     // 类名
class LeadNode; // 类名
void Draw( void );          // 函数名
void SetValue( int value ); // 函数名

(2) 变量和参数用小写字母开头的单词组合而成
BOOL flag;
int drawNode;

(3) 常量全用大写的字母,用下划线分隔单词,例如:
const int MAX = 100;
const int MAX_LENGTH = 100;

(4) 静态变量加前缀s_(表示static),例如:
vodi Init(...)
{
    static int s_initValue; // 静态变量
}

(5) 如果不得已需要全局变量,则使全局变量加前缀g_(表示global),例如:
int g_howManyPeople; // 全局变量
int g_howMuchMoney;  // 全局变量

(6) 类的数据成员加前缀m_(表示member),这样可以避免数据成员与成员函数的参数同名。例如:
void Object:L:SetValue( int width, int height )
{
    m_width = width;
    m_height = height;
}

 

第四章 表达式和基本语句
4.1 if语句
a、布尔变量与零值比较
    不可将不二变量直接与TRUE、FALSE或者1、0进行比较
    根据布尔类型的语义,零值为“假”(记为FALSE),任何非零值都是“真”(记为TRUE)。TRUE的值究竟是什么病没有统一的标准。例如Virtual C++将TRUE定义为1,而VB则就爱那个TRUE定义为-1
假设布尔变量名字为flag,它与零值比较的标准if语句如下:
if ( flag )  // 表示flag为真
if ( !flag ) // 表示flag为假
其他的用法都属于不良风格,例如:
if ( TRUE == flag )
if ( 1 == flag )

b、整型变量与零值比较
if ( 0 == value )
if ( 0 != value )

c、浮点变量与零值比较
    不可将浮点变量用"=="或"!="与任何数字比较
    千万要留意,无论是float还是double类型的表露,都有精度限制。所以一定要避免将浮点变量用"=="或"!="与数字比较,应该设法转化成">="或"<="形式
假设浮点变量的名字为x,应当将
if ( 0.0 == x ) // 隐含错误的比较
转化为
if ( ( x >= -ESPINON) && ( x <= EPSINON) )
其中EPSINON是允许的误差(即精度)

d、指针变量与零值比较
if ( NULL == p )
if ( NULL != p )


4.2 循环语句的效率
C/C++循环语句中,for语句使用频率最高,while语句其次,do语句很少用。

a、在多重循环中,如果有可能,应当将最长的循环放在最内层,最短的循环放在最外层,以减少CPU跨切循环层的次数。例如
for ( row = 0; row < 100; row ++)
{
    for ( col = 0; col < 5; col++ )
    {
        sum = sum + a[ row ][ col ];
    }
}
这里的效率就比较低:长循环在最外层,应改成:
for ( col = 0; col < 5; col++ )
{
    for ( row = 0; row < 100; row ++)
    {
        sum = sum + a[ row ][ col ];
    }
}

b、如果循环体内存在逻辑判断,并且循环次数很大,宜将逻辑判断移到循环体的外面。比如(1)中的程序比(2)的程序多执行了N-1次逻辑判断。并且由于前者老妖进行逻辑判断,打断了循环“流水线”作业,是的编译器不能对循环进行优化处理,降低了小路。如果N非常大,最好采用(2)的写法,可以提高小路。如果N非常小,两者效率差别并不明显,但采用(1)的写法比较好,因为程序更加简洁
(1)
for ( i = 0; i < N; i++ )
{
    if ( condition )
    {
        DoSomething();
    }
    else
    {
        DoOtherthing();
    }
} // 效率低但程序简洁
(2)
if ( condition )
{
    for ( i = 0; i < N; i++ )
    {
        DoSomething();
    }
}
else
{
    for ( i = 0; i < N; i++ )
    {
        DoOtherthing();
    }
} // 效率高但程序简洁


4.3 for语句的循环控制变量
建议for语句的循环控制变量的取值采用“半开半闭区间”写法
(1)
for ( int i = 0; i < N; i++ )
{...}
x值属于半开半闭区间“0 =< x < N”,起点到终点的间隔为N,循环次数为N
(2)
for ( int i = 0 ; i <= N -1; i++ )
{...}
x值属于闭区间“0 =< x <= N-1”,起点到终点的间隔为N-1,循环次数为N
相比之下(1)的写法更加直观,尽管两者的功能是相同的

 

第五章 常量
    常量是一种标识符,它的值在运行期间恒定不变。C语言用#define来定义常量(成为宏常量)。C++语言除了#define外还可以用const来定义常量(成为const常量)


5.1 为什么需要常量
    如果不适用常量,直接在程序中填写数字或字符串,将会有什么麻烦?
(1) 程序的可读性(可理解性)变差。程序员自己会放假那些数字或字符串是什么意思,用户则更加不知他们从何而来、表示什么
(2) 在程序的很多地方输入同样的数字或字符串,难保不发生书写错误
(3) 如果要修改数字或字符串,则会在很多地方改动,既麻烦又容易出错


5.2 const与#define的比较
    C++语言可以用const来定义常量,也可以用#define来定义常量。但是前者比后者有更多的有点:
(1) const常量有数据类型,而宏常量没有数据类型。编译器可以对前者进行类型安全监察。而对后者只进行字符替换,没有类型安全监察,并且在字符替换可能会产生意料不到的错误(边界效应)
(2) 有些集成化调试工具可以对const常量进行调试,但是不能对宏常量进行调试


5.3 类的常量
    不能在类声明中初始化const数据成员。以下用法是错误的,因为累的对象未被创建时,编译器不知道SIZE的值是什么
class Test_A
{
    ...
private:
    const int SIZE = 100; // 错误,企图在类声明中初始化const数据成员
    int array[ SIZE ];    // 错误,未知而SIZE
};

const数据成员的初始化只能在类构造函数的初始化表中进行,例如:
class Test_A
{
public:
    Test_A( int size );   // 构造函数
    const int SIZE;
};

Test_A::Test_A( int size) : SIZE( size ) // 构造函数的初始化表
{}

怎样才能简历在整个类中都恒定的常量呢?别指望const数据成员了,应该用类中的枚举常量来实现。例如:
class Test_A
{
    ...
public:
    enum { SIZE1 = 100, SIZE2 = 200 }; // 枚举常量
    int array1[ SIZE];
    int array2[ SIZE];  
}
枚举常量不会占用对象的存储空间,他们在编译时被全部求职。枚举常量的缺点是:他的隐含数据类型是整数,其最大值优先,且不能表示浮点数(如PI = 3.14159)

 

第六章 函数设计
6.1 参数的规则
a、参数额书写要完整,不要贪图省事致谢参数的类型而省略参数名字,如果函数没有参数,则用void填充,例如:
void GetValue(void);

b、如果参数是指针,且仅作输入用,则应在类型前加const,以防止该指针在函数体内被意外修改

c、如果输入参数以值传递的方式传递对象,则宜改用“const &”方式来传递,这样可以省去临时对象的构造和析构过程,从而提高效率


6.2 返回值的规则
a、函数名字与返回值类型在语义上不可冲突
违反这条规则的典型带便是C标准库函数getchar,例如:
char c;
c = getchar();
if ( EOF == c )
{...}
按照getchar名字的意思,将变量c声明为char类型是很自然的事情。但不幸的是getchar的确不是char类型,而是int类型,其原型如下:
int getchar( void );
由于c是char类型,取值范围是[ -128, 127 ],如果宏EOF的值在char的取值范围之外,那么if语句将总是失败,这种“危险”人们一般不会料到,导致本例错误的责任是函数getchar误导了使用者

b、不要将正常值和错误标识混在一起返回。正常值用输出参数获得,而错误标志用return语句返回
    回顾上例,C标准库函数的设计者为什么要将getchar声明为令人迷糊的int类型?
    在正常情况下,getchar的确返回单个字符。但如果getchar碰到文件结束标志或发生读错误,它必须返回一个标志EOF。为了区别于正常的字符,志豪将EOF定义为负数(通常为-1)。因此函数getchar就成了int类型。

c、有时候函数原本不需要返回值,但为了增加灵活性如支持链式表达,可以附加返回值
例如字符串拷贝函数strcpy的原型:
char *strcpy( char *strDest, const char *strSrc );
strcpy函数将strSrc拷贝至输出参数strDest中,同时函数的返回值又是strDest。这样做并非多次一举,可以获得如下灵活性:
char str[ 20 ];
int length = strlen( strcpy( str, "hello world" ));


6.3 函数内部实现的规则
    不同功能的函数其内部实现各不相同,看起来似乎无法就“内部实现”达成一致的观点。但根据经验,可以在函数体的“入口处”和“出口处”从严把关,从而提高函数的质量
a、在函数体的“入口处”,对参数的有效性进行检查
看6.5

b、在函数体的“出口处”,对return语句的正确性和效率进行检查
如果函数有返回值,那么函数的“出口处”是return语句。如果return语句写得不好,函数要么出错,要么效率低下。
注意事项如下:
(1) return语句不可反悔指向“栈内存”的“指针”或者“引用”,因为该内存在函数体结束时被自动销毁,例如:
char *Func( void )
{
    char str[] = "hello world"; // str的内存位于栈上
    return str;    // 将导致错误
}
(2) 如果函数返回值是一个对象,要考虑return语句的效率。例如:
return String( s1 + s2 );
    这是临时对象的语法,表示“创建一个临时对象并返回他”。不要以为他与“先创建一个局部对象temp并返回他的结果”是等价的,如:
String temp( s1 + s2 );
return temp;
是指不然,上述代码发生三件事。首先,temp对象被创建,同时完成初始化;然后拷贝够咱函数吧temp拷贝到保存返回值存储单元中;最后,temp在函数结束时被销毁(调用析构函数)。然后“创建一个临时对象并返回他”的过程是不同的,编译器直接把临时对象创建并初始化在外部存储单元中,省去了拷贝和析构的花费,提高了效率


6.4 其他建议
(1) 函数的功能要单一,不要涉及多用途的函数
(2) 函数体的规模要小,尽量控制在50行代码之内
(3) 函数中尽量少用static局部变量,除非必要
(4) 不仅要检查输入蚕食的有效性,还要检查通过其他途径进入函数体内的变量的有效性,例如全局变量、文件句柄等
(5) 用于出错处理的返回值一定要清楚,让使用者不容易忽视或误解错误情况


6.5 使用断言
    程序一般分为Debug版本和Release版本。
    断言assert是尽在Debug版本其作用的宏,他用于检测“不应该”发生的情况。
void *memory( void *pvTo, const void *pvFrom, size_t size )
{
    assert( ( NULL != pvTo) && ( NULL != pvFrom ) ); // 使用断言
    byte *pbTo = ( byte * )pvTo;     // 防止改变pvTo的地址
    byte *pbFrom = ( byte * )pvFrom; // 防止改变pvFrom的地址
    while( size-- > 0 )
    {
        *pbTo++ = *pbFrom++;
    }
    return pvTo;
}
    在函数的入口处,使用断言检查参数的有效性(合法性)
    在编写函数时,要进行反复的考查,并且自问:“我打算做哪些假定?”,一旦确定了假定,就要使用断言对假定进行检查


6.6 引用于指针的比较
引用的一些规则
(1) 引用被创建的同事必须被初始化(指针则可以在任何时候被初始化)
(2) 不能有NULL引用,引用必须与合法的存储单元关联(指针则可以是NULL)
(3) 一旦引用被初始化,就不能改变引用的关系(指针则可以随时改变所指的对象)
    指针能够毫无约束地操作内存中的任何东西,尽管指针功能强大,但是非常危险。就像一把刀,他可以用来砍树、裁纸、修指甲、理发等等,谁敢这样用?
    如果的确只需要借用一下某个对象的“别名”,那么就用“引用”,而不要用“指针”,以免发生意外。比如说,某人需要一份证明,本来在文件上盖上公章的印子就行了,如果把取公章的钥匙交给他,那么他就获得了不该有的权利。

 

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


7.2 常见的内存错误及其对策
(1) 内存分配未成功,却使用了它
    常用的解决办法是,在使用内存之前检查指针是否为NULL。如果指针p是函数的参数,那么在函数的入口处用assert(NULL != p)进行检查。如果是malloc或者new来申请内存,应该用if ( NULL == p )或if ( NULL != p )进行放错处理

(2) 内存分配虽然成功,但是尚未初始化就引用它
    犯这种错误主要有两个原因:一时没有初始化的观念;二是误以为内存的缺省初值全为零,导致引用初值错误(例如数组)
    内存的缺省初值究竟是什么并没有统一的标准,尽管有些时候全为零值,我们宁可信其无不可信其有。所以无论用何种方式创建数组,都别忘了赋初值,即便是赋零值也不可省略,不要嫌麻烦

(3) 释放了内存却继续使用它
    有三种情况:
a、程序中的对象调用关系过于复杂,是在难以搞清楚某个对象究竟是否已经释放了内存。此时应该重新设计数据结构,从根本上解决对象管理的混乱局面
b、函数的return语句写错了,注意不要返回指向“栈内存”的“指针”或者“引用”,因为该内存在函数体结束时被自动销毁
c、使用free或delete释放了内存后,没有将指针设置为NULL。导致产生“野指针”

(4) 用free或delete释放了内存之后,立即将指针设置为NULL,防止产生“野指针”


7.3 指针与数组的对比
(1) 例
char *p = "hello world";
p[ 0 ] = 'X';
cout << p << endl;
指针p指向常量字符串"hello world"(位于静态存储区,内容为hello world\0),常量字符串的内容是不可以被修改的。从语法上看,编译器并不觉得语句p[ 0 ] = 'X'有什么不妥,但是该语句企图修改常量字符串的内容而导致运行错误

(2) 把数组中的数据赋给指针p
int Length = strlen( a );
char *p = ( char *)malloc( sizeof( char ) * ( len + 1 ) );
strcpy( p, a );
if( 0 == strcmp( p, a ) )
语句p = a并不能把a的内容复制到指针p,而是把a的地址赋给了p。要像复制a的内容,可以先用库函数malloc为p申请一块容量为strlen( a ) + 1个字符的内容,再用strcpy进行字符串复制。同理,语句if( p == a )比较的不是内容而是地址,应该用库函数strcmp来比较
注意:strcpy自动会给字符串的末尾加上\0;memcpy却不会

一个例子:
char str[ 6 ] = "world";
cout << strlen( str ) << endl;
char *p = new char[ strlen( str ) + 1 ];
memcpy( p, str, strlen( str ) + 1 );
cout << p << endl;
cout << strlen( p ) << endl;

另一个例子:
char str[ 6 ] = "world";
cout << strlen( str ) << endl;
char *p = new char[ strlen( str ) + 1 ];
strcpy( p, str );
cout << p << endl;
cout << strlen( p ) << endl;

(3) 计算内存容量
    用运算符sizeof可以计算出数组的容量(字节数)。但是sizeof( p )的值却是4.这是因为sizeof( p )得到的是一个指针变量的字节数,相当于sizeof( char * ),而不是p所指向的内存容量。C/C++语言没有办法知道指针所指的内存容量,除非在申请内存时记住它。
    注意当数组作为函数的参数继续参数传递时,该数组自动退化为同类型的指针,例如
void Func( char a[ 100 ])
{
    cout << sizeof(a ) << endl; // 4字节而不是100字节}
不论数组a的容量是多少,sizeof( a )始终是等于sizeof( char *)

(4) 指针参数是如何传递内存的
    如果函数的参数是一个指针,不要指望用该指针去申请动态内存
void GetMemory( char *p, int num )
{
    p = ( char * )malloc( sizeof( char ) * num );
}
void Test( void )
{
    char *str = { 0 };
    GetMemory( str, 100 );  // str仍然为NULL
    strcpy( str, "hello" ); // 运行错误
}
毛病出在函数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 );
}
void Test( void )
{
    char *str = { 0 };
    GetMemory( &str, 100 );
    strcpy( str, "hello" );
    free( str );
}

    由于“指向指针的指针”这个概念不容易理解,我们可以用函数返回值i来传递动态内存。这种方法更加简单:
char *GetMemory( int num )
{
    char *p = ( char * )malloc( sizeof( char ) * num );
    return p;
}
void Test( void )
{
    char *str = { 0 };
    str = GetMemory( 100 );
    strcpy( str, "hello" );
    free( str );
}

    用函数返回值来传递动态内存这种方法虽然好用,但是常常有人把return语句用错了。这里强调不要用return语句返回指向“栈内存”的指针,因为该内存在函数结束时自动消亡:
char *GetString( void )
{
    char p[] = "hello world";
    return p; // 编译器将发出警告
}
void Test( void )
{
    char *str = NULL;
    str = GetString(); // str的内容是垃圾
    cout << str << endl;
}
用调试器逐步跟踪Test,发现执行str = GetString语句后str不再是NULL指针,但是str的内容不是"hello world"而是垃圾。

    如果改成如下:
char *GetString( void )
{
    char *p = "hello world";
    return p; // 编译器将发出警告
}
void Test( void )
{
    char *str = NULL;
    str = GetString(); // str的内容是垃圾
    cout << str << endl;
}
函数Test运行虽然不会出错但是函数GetString的设计概念却是错误的。因为GetString内的"hello world"是常量字符串,位于静态存储区,他在程序生命期内恒定不变。无论什么时候调用GetString,他返回的始终是同一个"只读"的内存块

(5) free和delete把指针怎么啦?
    别看free和delete的名字恶狠狠的(尤其是delete),他们只是把指针所指的内存给释放掉,但并没有把指针本身干掉
char *p = new char[ 5 ];
strcpy( p, "zeng" );
cout << p << endl;
delete p;
if ( NULL !=  p )
{
 cout << "p is not NULL, p value is:" << p << endl;
}
可以看到在delete之后if ( NULL !=  p )进行放错处理并不起作用,因为即便p不是NULL指针,他也不指向合法的内存块

(6) 动态内存会被自动释放吗?
void Func( void )
{
    char *p = ( char * )malloc( 100 ); // 动态内存会自动释放吗?
}
    当函数Func结束时,指针消亡了,并不表示它所指向的内存会被自动释放;内存被释放了,并不表示指针会消亡或者成了NULL指针。

(7) 杜绝“野指针”
    “野指针”不是NULL指针,是指向“垃圾”内存的指针。“野指针”的成因主要有两种:
a、指针变量没有被初始化。任何贺子珍变量刚被创建时不会自动成为NULL指针,它的缺省值是随机的,它会乱指一气。所以,指针变量在创建的同事应当被初始化,要么将指针设置为NULL,要么让他指向合法的内存。例如:
char *p = NULL;
char *str = ( char * )malloc( 100 );

b、指针p被free或者delete之后,没有被置为NULL,让人误以为p是个合法的指针

c、指针操作超越了变量的作用范围。这种情况让人防不胜防:
class TestA
{
public:
    void Func( void ){ cout << "Func of class TestA" << endl; }
};
void Test( void )
{
    A *p;
    {
        A a;
        p = &a; // 注意a的生命期
    }
    p->Func();  // p是“野指针”
}
函数Test在执行语句p->Func()时面对像a已经消失,而p是指向a的,所以p就成了“野指针”。但是要论编译器而定,留意指针的生命期即可

 

第八章 C++函数的高级特性
8.1 如果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。C++编译器开发商
依旧对C标准库头文件做了extern "C"处理,所以可以用#include直接引用这些头文件

8.2 成员函数的重载、覆盖与隐藏
(1) 重载与覆盖
    成员函数被重载的特征
a、相同的范围(在同一个类中)
b、函数名字相同
c、参数不同
d、virtual关键字可有可无

    覆盖是指派生类函数覆盖基类函数,特征是:
a、不同的范围(分别位于派生类与基类)
b、函数名字相同
c、参数相同
d、积累函数必须有virtual关键字

(2) 令人迷惑的隐藏规则
    本来仅仅区别重载与覆盖并不算困难,但是C++的隐藏规则使问题复杂性突然增加。这里“隐藏”是指派生类的函数屏蔽了与其同名的基类函数,规则如下:
a、如果派生类的函数与基类函数同名,但是参数不同。此时,不论有无virtual关键字,基类的函数将被影藏
b、如果派生类的函数与基类的函数同名,并且参数也相同,但是基类函数没有virtual关键字。此时,基类的函数被隐藏
#include <iostream>
class Base
{
public:
    virtual void f( float x ){ cout << "Base::f( float ) " << endl; }
            void g( float x ){ cout << "Base::g( float ) " << endl; }
            void h( float x ){ cout << "Base::h( float ) " << endl; }
};
class Derived : public Base
{
public:
    virtual void f( float x ){ cout << "Derived::f( float ) " << endl; }
            void g( int x ){ cout << "Derived::g( float ) " << endl; }
            void h( float x ){ cout << "Derived::h( float ) " << endl; }
};
void main( void )
{
    Derived d;
    Base *pb = &d;
    Derived  *pd = &d;

    pb->f( 3.14f ); // Derived::f( float ) 3.14
    pd->f( 3.14f ); // Derived::f( float ) 3.14

    pb->g( 3.14f ); // Base::g( float ) 3.14
    pd->g( 3.14f ); // Derived::g( int ) 3

    pb->h( 3.14f ); // Base::h( float ) 3.14
    pd->h( 3.14f ); // Derived::h( int ) 3
}

函数Derived::f( float )覆盖了Base::f( float )
函数Derived::g( float )隐藏了Base::g( float ),而不是重载
函数Derived::h( float )隐藏了Base::h( float ),而不是覆盖
根据类的virtual很容易就能判断出来

(3) 摆脱隐藏
    隐藏规则引起来不少麻烦
class Base
{
public:
    void f( int x );
};
class Derived : public Base
{
public:
    void f( char *str );
};
void Test( void )
{
    Derived *pd = new Derived;
    pd->f( 10 ); // error
}
语句pd->f( 10 )的本意是想调用函数Base::f( int ),但是Base::f( int )不行被Derived::f( char * )隐藏了。由于数字10不能被隐式地转化为字符串,所以在编译时出错。
    隐藏规则至少有两个存在的理由:
a、写语句pd->f( 10 )的人可能真的想调用Derived::f( char * )函数,只是他误将函数参数写错了。有了隐藏规则,编译器就可以明确指出错误,这未必不是好事。否则,编译器会静悄悄地将错就错,程序员将很难发现这个错误,留下祸根。
b、加入类Derived有多个基类(多重继承),有时搞不清楚哪些基类定义了函数f。如果没有隐藏规则,那么pd->f( 10 )可能会调用一个出乎意料的基类函数f,尽管隐藏规则看起来不怎么有道理,但它的确能消灭这些意外

如果要调用基类的函数,需要使用域操作符Base::f( int );

8.3 参数的缺省值
    参数缺省值的使用规则:
(1) 参数缺省值只能出现在函数的声明中,而不能出现在定义体重。例如:
void Foo( int x = 0, int y = 0 ); // 正确,缺省值出现在函数的声明中
void Foo( int x = 0, int y = 0 )  // 错误,缺省值出现在函数的定义体重
{
    ...
}
可能的原因:
一、函数的实现(定义)本来就与参数是否有缺省值无关,所以没有必要让缺省值出现在函数的定义体重
二、参数的缺省值可能会改动,显然修改函数的声明比修改函数的定义要方便

8.4 不能被重载的运算符
    在C++运算符集合中,有一些运算符是不允许被重载的。这种限制是出于安全方面的考虑,可防止错误和混乱
(1) 不能改变C++内部数据类型(如int、float等)的运算符
(2) 不能重载'.',因为'.'在类中对任何成员都有意义,已成成为标准用法
(3) 不能重载目前C++运算符集合中没有的符号,如#、@、$等。原因有两点,一时难以理解,而是难以确定优先级
(4) 对已存在的运算符进行重载时,不能改变优先级规则,否则将引起混乱

8.5 内联函数
    对于任何内联函数,编译器在符号表里放入函数的声明(包括名字、参数类型、返回值)。如果编译器没有发现内联函数存在错误,那么该函数的代码也被放入符号表里。在调用一个内联函数时,编译器首先检查调用是否正确(进行类型安全检查,或者进行自动类型串行,当然对所有的函数都一样)。如果正确,内联函数的代码就会直接替换函数调用,于是省去了函数调用的开销。这个过程与预处理有显著的不同,因为预处理器不能进行类型安全检查,或者进行自动类型转换。加入内联函数是成员函数,对象的地址(this)会被放在合适的地方,这也是预处理器办不到

(1) inline是一种“用于实现的关键字”,而不是一种“用于声明的关键字”。
(1) 慎用内联内联能提供函数的执行效率,但是内联是以代码膨胀(复制)为代价,仅仅省去了函数调用的开销,从而提高函数的执行效率。如果执行函数体内代码的时间,相比于函数调用的开销较大,那么效率的收获会很少。另一方面,每一次内联函数的的调用都要复制代码,将使程序的总代码量增大,消耗更多的内存空间。以下情况不宜使用内联:
a、如果函数体内的代码比较长,使用内联将导致内存消耗代价较高
b、如果函数体内出现循环,那么执行函数体内代码的时机要比函数调用的开销大

 

作者:zengraoli 发表于2012-8-13 1:33:54 原文链接
阅读:3 评论:0 查看评论

相关 [质量 编程 读书] 推荐:

高质量c/c++编程指南"读书笔记1

- - CSDN博客推荐文章
一个strcpy函数的代码. (3) 算法复杂度分析(用于提供性能). 定义1:能长期稳定地编写出高质量程序的程序员称为编程老手. 定义2:能长期稳定地编写出高难度、高质量的程序与称为编程高手. 1.1 版权和版本的声明. 版权和版本的声明位于头文件和定义文件的开头,主要内容有:. (2) 文件名称、标识符、摘要.

低质量软件编程成本价格表

- - ITeye资讯频道
注意:下面这个清单里描述的事情并不是你绝对不能做的,它只是用量化的方法来让你知道编程上的这些做法将会产生的负面代价. 这些费用是在代码审查时你将要付出的. 代码库中的程序编码风格一致虽然不是很重要,但值得你去遵守. 在提交代码的说明信息上偷懒. 请细读这篇 代码提交说明信息指导(英文). 大多数的局部变量都最好使用方法代替.

关于读书

- iDesperadO - 4G spaces
看到师弟蔡白银写的文章, 有所感, 写下几句不成文的心得体会.. 大学读经典书, 能缩小自己和发达国家学生的差距. 我们国家的大学和发达国家相比, 差距大家也都能看到. 在理工科上, 或许中国大学唯一能和外国大学在同一起跑线的, 就是图书馆里面躺着的经典英文原版书了. 科学发展到今天, 每个领域都是枝丫茂盛, 都有经典的著作.

Linux读书片言

- L - 博客园-首页原创精华区
  目前的高等教育与社会应用有一定距离,虽然整日都叫嚷着“一定要改革”. 但毕竟高等教育的本质只是给与一个平台,扎实基础,为往后自我学习的道路上提供  动力.   自我学习的能力在IT业着实重要,甚至是全部,不管是技术,还是业务. 从技术的角度来说,open source这玩意 还真是检验一个人“自我学习”能力的好东西.

技术文章的质量

- Kai Chen - 4G spaces
推友 @StarrySource 就微薄和推特的好坏问题写了一篇文章,正好和霍炬的文章同时发出来,推特上对这两篇文章叫好的人不少,其中还有一些直接就说 StarrySource 这篇比 virushuo 写得好. 文章好坏诚然是个很主观的事情,不过就仅从文章内容来说,就算有一千个读者一千个主观标准,我也想不出什么理由来说明 StarrySource 的这篇比 virushuo 写得好,因为客观上这两篇文章的差距会抵充掉主观上的一些好恶.

关于产品质量

- 茫茫 - 弯曲评论
记得去年某天曾去1号楼机房参观T系列存储系统的硬件,由于前期知道T系列的IO接口卡均可热插拔,而这在中端存储产品里是没有其他友商可以做到的. 抱着好奇的心态,我就反复尝试了一下,可以任意插拔IO接口卡而不影响业务,效果非常好. 为了进一步验证T系列的可靠性,我直接拔出了正在运行的双控中的一个控制器,此时主机端正在从阵列中拷出一个大文件,拔出控制器之后,拷贝出错终断了,这个也是可以理解的,毕竟操作系统自带的拷贝是写死的,超时值不可调.

苏泊尔“质量门”

- 棉花 - 南方周末-热点新闻
有业内人士质疑,以锰代镍是原材料价格上涨导致成本的增加后企业应对压力采取的手段. 对此,苏泊尔方反复强调“产品质量安全是没有问题的”,但未提及相关材质含量的问题.

软件质量之道

- - CSDN博客系统运维推荐文章
        我曾与一些资历非常高但毫无实际经验的人共事过,也曾与一些只有很少或根本没有资历但才华横溢的工程师一起工作过,我也曾经不得已跟一些并不想用心做事、也对学习新东西丝毫不感兴趣的人共事过. 如果说我们这个职业是一张纸,那么这些人就好比纸上的污点. 软件开发业的低劣性不能完全怪罪于那些无知的经理、狡猾的市场营销人员以及总是急不可耐的用户,实际上很大程度上要归咎于这个行业的某些从业人员,他们应该去从事一些即使玩忽职守也不会造成像软件业里这样大的危害的行当,而不应该混迹于这个聚集着人类想象力的最复杂的创造性的行业.

Hadoop Streaming 编程

- - 学着站在巨人的肩膀上
Hadoop Streaming是Hadoop提供的一个编程工具,它允许用户使用任何可执行文件或者脚本文件作为Mapper和Reducer,例如:. 采用shell脚本语言中的一些命令作为mapper和reducer(cat作为mapper,wc作为reducer). 本文安排如下,第二节介绍Hadoop Streaming的原理,第三节介绍Hadoop Streaming的使用方法,第四节介绍Hadoop Streaming的程序编写方法,在这一节中,用C++、C、shell脚本 和python实现了WordCount作业,第五节总结了常见的问题.

Shell编程

- - 博客园_首页
本来打算寒假回家好好学习Linux的,为以后学习嵌入式打好基础的. 回家之后的学习效率非常低,之前为了搭建Linux环境,折腾了很长时间,学到现在也就勉强才把Shell编程学完了. 今天就把自己学习的相关知识点总结整理一下. 个人感觉shell程序跟windows下的批处理文件有点像,就是将一些系统命令写进一个可执行文件中,然后执行.