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

一个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
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、如果函数体内出现循环,那么执行函数体内代码的时机要比函数调用的开销大

 

你可能感兴趣的:(IT书籍读书笔记,编程,读书,编译器,float,null)