C++学习笔记（2）--高质量C++C编程指南一

If 语句与零值比较

一、不可将布尔变量直接与TRUE、FALSE或者1、0进行比较

规范：

if (flag)

if (!flga)

不规范：

if (flag == TRUE)

if (flag == 1 )

if (flag == FALSE)

if (flag == 0)

二、整型变量与零值比较

规范：

if (value == 0)

if (value != 0)

不规范：

if (value)

if (!value)

三、浮点变量与零值比较，不可将浮点变量用“==”或“！=”与任何数字比较。

由于float 或 double 都是有精度限制，所以一定不能“==”、“！=”来比较，要转化成“>=”等。

四、指针变量与零值比较，应当将指针变量用“==”或“！=”与NULL 比较。

规范：

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

if (p != NULL)

 

循环语句的效率

一、在多重循环中，如果有可能，应当将最长的循环放在最内层，最短的

循环放在最外层，以减少CPU 跨切循环层的次数。

二、如果循环体内存在逻辑判断，并且循环次数很大，宜将逻辑判断移到循环体的外面。

三、建议for 语句的循环控制变量的取值采用“半开半闭区间”写法。选择“0 =< x < N”而不是“0 =< x <= N-1”。

 

常量const  VS  #define(C)

一、在C++ 程序中只使用const 常量而不使用宏常量，即const 常量完全取代宏常量。

二、const常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意料不到的错误（边际效应）。且#define定义的宏常量是全局的，用起来没有const灵活。

 

函数设计

一、如果参数是指针，且仅作输入用，则应在类型前加const，以防止该

指针在函数体内被意外修改。

void StringCopy(char *strDestination，const char*strSource);

二、如果输入参数以值传递的方式传递对象，则宜改用“const &”方式

来传递，这样可以省去临时对象的构造和析构过程，从而提高效率。

三、不要省略返回值的类型。

四、在函数体的“入口处”，使用“断言”（assert）对参数的有效性进行检查。

五、在函数体的“出口处”，对return 语句的正确性和效率进行检查。

 

内存分配方式：

（1） 从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的

整个运行期间都存在。例如全局变量，static变量。

（2） 在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函

数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集

中，效率很高，但是分配的内存容量有限。

（3） 从堆上分配，亦称动态内存分配。程序在运行的时候用malloc 或new 申请任意

多少的内存，程序员自己负责在何时用free或delete 释放内存。动态内存的生存

期由我们决定，使用非常灵活，但问题也最多。

 

常见的内存错误及其对策如下：

一、内存分配未成功，却使用了它。

编程新手常犯这种错误，因为他们没有意识到内存分配会不成功。常用解决办法是，在使用内存之前检查指针是否为NULL。如果指针p是函数的参数，那么在函数的入口处用assert(p!=NULL)进行检查。如果是用malloc 或new 来申请内存，应该用if(p==NULL)或if(p!=NULL)进行防错处理。

二、内存分配虽然成功，但是尚未初始化就引用它。

犯这种错误主要有两个起因：一是没有初始化的观念；二是误以为内存的缺省初值i为零，导致引用初值错误（例如数组）。内存的缺省初值究竟是什么并没有统一的标准，尽管有些时候为零值，我们宁可信其无不可信其有。所以无论用何种方式创建数组，都别忘了赋初值，即便是赋零值也不可省略，不要嫌麻烦。

三、 内存分配成功并且已经初始化，但操作越过了内存的边界。

例如在使用数组时经常发生下标“多1”或者“少1”的操作。特别是在for循环语句中，循环次数很容易搞错，导致数组操作越界。

四、忘记了释放内存，造成内存泄露。

含有这种错误的函数每被调用一次就丢失一块内存。刚开始时系统的内存充足，你看不到错误。终有一次程序突然死掉，系统出现提示：内存耗尽。动态内存的申请与释放必须配对，程序中malloc与free的使用次数一定要相同，否则肯定有错误（new/delete 同理）。

 

五、释放了内存却继续使用它。

有三种情况：

（1）程序中的对象调用关系过于复杂，实在难以搞清楚某个对象究竟是否已经释放了内存，此时应该重新设计数据结构，从根本上解决对象管理的混乱局面。

（2）函数的return 语句写错了，注意不要返回指向“栈内存”的“指针”或者“引用”，因为该内存在函数体结束时被自动销毁。

（3）使用free或delete释放了内存后，没有将指针设置为NULL。导致产生“野指针”。

 

用运算符sizeof 可以计算出数组的容量（字节数）

char a[] = "helloworld";

char *p = a;

cout<< sizeof(a)<< endl; // 12 字节

cout<< sizeof(p)<< endl; // 4 字节

sizeof(p) 是一个指针变量的字节数，相当于sizeof(char*)，我们得不到指针所指向内存容量。

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

void Func(char a[100])

{

cout<< sizeof(a)<< endl; // 4 字节而不是100 字节

}

顺便试了一下各种数据类型在32位window7下的字节数如下：

各种char 1位、各种short 2位、各种int 4位、float 4位、double 8位

 

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

一、如果函数的参数是一个指针，不要指望用该指针去申请动态内存。编译器总是要为函数的每个参数制作临时副本，指针参数p 的副本是 _p，编译器使 _p = p。如果函数体内的程序修改了_p 的内容，就导致参数p 的内容作相应的修改。这就是指针可以用作输出参数的原因。在本例中，_p 申请了新的内存，只是把_p 所指的内存地址改变了，但是p 丝毫未变。

二、指针消亡了，并不表示它所指的内存会被自动释放。

三、内存被释放了，并不表示指针会消亡或者成了NULL指针。要记得使其变成NULL。

 

malloc 、free与 new/delete 区别

malloc 与free 是C++/C 语言的标准库函数，new/delete 是C++的运算符。它们都可用于申请动态内存和释放内存。但前者是针对c的，在c中只能用malloc 、free来动态分配内存，而在c++中，new /delete的功能完全覆盖了前者，且可以自动执行构造和析构函数，所以在C++中，我们尽量用new/delete。两两配对，尽量不要混用。

 

使用要点：

函数 malloc 的原型：void* malloc(size_t size);其返回值是void，所以我们在使用的过程中，要强制转换成我们所需要的类型。

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

而使用new，只需int *p2= new int[length];因为new中内置sizeof（）；

函数 free 的原型：voidfree( void * memblock );

C++函数的高级特性：

四种新机制：重载（overloaded）、内联（inline）、const 和virtual。后两者限于类成员

 

重载：类的构造函数需要重载机制，因为构造函数只能与类同名，而在创建不同的对象只能用重载来实现。编译器靠函数的参数来实现重载。

 

同一函数在C和C++的编译器中生成的重载函数名有区别，如果在C++中想调用在C中已经编译好的函数，就用加extern”c”来解决这个问题。

 

成员函数被重载的特征：

（1）相同的范围（在同一个类中）；

（2）函数名字相同；

（3）参数不同；

（4）virtual 关键字可有可无。

 

覆盖是指派生类函数覆盖基类函数，特征是：

（1）不同的范围（分别位于派生类与基类）；

（2）函数名字相同；

（3）参数相同；

（4）基类函数必须有virtual 关键字。

 

隐藏规则：

这里“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：

（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual

关键字，基类的函数将被隐藏（注意别与重载混淆）。重载是参数相同。

（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual

关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。覆盖是基类有virtual。

 

运算符重载

 

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