一些基础的c++概念

最近有时间，看了《高质量c++编程》把不清晰的概念，列出来了。

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

void  Func( char  a[ 100 ])
... {
    cout<< sizeof(a) << endl; // 4 字节而不是100 字节
}

2:  char *p = “world”; // 注意p 指向常量字符串
     p[0] = ‘X’; // 编译器不能发现该错误
指针p 指向常量字符串“world”（位于静态存储区，内容为world/0），常量字符串的内容是不可以被修改的。从语法上看，编译器并不觉得语句p[0]= ‘X’有什么不妥，但是该语句企图修改常量字符串的内容而导致运行错误

3.
如果函数返回值是一个对象，要考虑return 语句的效率。例如return String(s1 + s2);
这是临时对象的语法，表示“创建一个临时对象并返回它”。不要以为它与“先创建一个局部对象temp 并返回它的结果”是等价的，如
String temp(s1 + s2);
return temp;
实质不然，上述代码将发生三件事。首先，temp 对象被创建，同时完成初始化；然后拷贝构造函数把temp 拷贝到保存返回值的外部存储单元中；最后，temp 在函数结束时被销毁（调用析构函数）。然而“创建一个临时对象并返回它”的过程是不同的，编译器直接把临时对象创建并初始化在外部存储单元中，省去了拷贝和析构的化费，提高了效率。
类似地，我们不要将
return int(x + y); // 创建一个临时变量并返回它
写成
int temp = x + y;
return temp;

4. 函数的返回值
一个函数， 用于出错处理的返回值一定要清楚，让使用者不容易忽视或误解错误

5.  常量定义规则
    需要对外公开的常量放在头文件中，不需要对外公开的常量放在定义文件的头部。为便于管理，可以把不同模块的常量集中存放在一个公共的头文件中

    如果某一常量与其它常量密切相关，应在定义中包含这种关系，而不
   应给出一些孤立的值。
   例如：
  const float RADIUS = 100;
  const float DIAMETER = RADIUS * 2;

6  类中的常量
有时我们希望某些常量只在类中有效。由于#define 定义的宏常量是全局的，不能达到目的，于是想当然地觉得应该用const 修饰数据成员来实现。const 数据成员的确是存在的，但其含义却不是我们所期望的。const 数据成员只在某个对象生存期内是常量，而对于整个类而言却是可变的，因为类可以创建多个对象，不同的对象其const 数据成员的值可以不同。不能在类声明中初始化const 数据成员。以下用法是错误的，因为类的对象未被创建时，编译器不知道SIZE 的值是什么。
class A
{⋯
const int SIZE = 100; // 错误，企图在类声明中初始化const 数据成员
int array[SIZE]; // 错误，未知的SIZE
};
const 数据成员的初始化只能在类构造函数的初始化表中进行，例如
class A
{⋯
A(int size); // 构造函数
const int SIZE ;
};
A::A(int size) : SIZE(size) // 构造函数的初始化表
{
⋯
}
A a(100); // 对象 a 的SIZE 值为100
A b(200); // 对象 b 的SIZE 值为200
怎样才能建立在整个类中都恒定的常量呢？别指望const 数据成员了，应该用类中
的枚举常量来实现。例如
class A
{⋯
enum { SIZE1 = 100, SIZE2 = 200}; // 枚举常量
int array1[SIZE1];
int array2[SIZE2];
};
枚举常量不会占用对象的存储空间，它们在编译时被全部求值。枚举常量的缺点是：
它的隐含数据类型是整数，其最大值有限，且不能表示浮点数（如PI=3.14159）

7： 静态变量加前缀s_（表示static）

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

9： 整型变量与零值比较
应当将整型变量用“==”或“！=”直接与0 比较。
假设整型变量的名字为value，它与零值比较的标准if 语句如下：
if (value == 0)
if (value != 0)
不可模仿布尔变量的风格而写成
if (value) // 会让人误解 value 是布尔变量
if (!value)

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

11:  指针变量与零值比较
应当将指针变量用“==”或“！=”与NULL 比较。
指针变量的零值是“空”（记为NULL）。尽管NULL 的值与0 相同，但是两者意义不
同。假设指针变量的名字为p，它与零值比较的标准if 语句如下：
if (p == NULL) // p 与NULL 显式比较，强调p 是指针变量
if (p != NULL)
不要写成
if (p == 0) // 容易让人误解p 是整型变量
if (p != 0)
或者
if (p) // 容易让人误解p 是布尔变量
if (!p)

12:  循环语句的效率
在多重循环中，如果有可能，应当将最长的循环放在最内层，最短的循环放在最外层，以减少CPU 跨切循环层的次数

13:  如果函数的返回值是一个对象，有些场合用“引用传递”替换“值传递”可以提高效率。而有些场合只能用“值传递”而不能用“引用传递”，否则会出错。例如：
class String
{⋯
// 赋值函数
String & operate=(const String &other);
// 相加函数，如果没有friend 修饰则只许有一个右侧参数
friend String operate+( const String &s1, const String &s2);
private:
char *m_data;
}
String 的赋值函数operate = 的实现如下：
String & String::operate=(const String &other)
{
if (this == &other)
return *this;
delete m_data;
m_data = new char[strlen(other.data)+1];
strcpy(m_data, other.data);
return *this; // 返回的是 *this 的引用，无需拷贝过程
}
对于赋值函数，应当用“引用传递”的方式返回String 对象。如果用“值传递”的方式，虽然功能仍然正确，但由于return 语句要把 *this 拷贝到保存返回值的外部存储单元之中，增加了不必要的开销，降低了赋值函数的效率。例如：
String a,b,c;
⋯
a = b; // 如果用“值传递”，将产生一次 *this 拷贝
a = b = c; // 如果用“值传递”，将产生两次 *this 拷贝
String 的相加函数operate + 的实现如下：
String operate+(const String &s1, const String &s2)
{
String temp;
delete temp.data; // temp.data 是仅含‘/0’的字符串
temp.data = new char[strlen(s1.data) + strlen(s2.data) +1];
strcpy(temp.data, s1.data);
strcat(temp.data, s2.data);
return temp;
}
对于相加函数，应当用“值传递”的方式返回String 对象。如果改用“引用传递”，那么函数返回值是一个指向局部对象temp 的“引用”。由于temp 在函数结束时被自动销毁，将导致返回的“引用”无效。

14:
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;
}


15： 引用与指针的比较
引用的一些规则如下：
（1）引用被创建的同时必须被初始化（指针则可以在任何时候被初始化）。
（2）不能有NULL 引用，引用必须与合法的存储单元关联（指针则可以是NULL）。
（3）一旦引用被初始化，就不能改变引用的关系（指针则可以随时改变所指的对象）

引用的主要功能是传递函数的参数和返回值。C++语言中，函数的参数和返回值的传递方式有三种：值传递、
指针传递和引用传递

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

17： return 语句返回常量字符串
char *GetString2(void)
{
char *p = "hello world";
return p;
}
void Test5(void)
{
char *str = NULL;
str = GetString2();
cout<< str << endl;
}
函数Test5 运行虽然不会出错，但是函数GetString2 的设计概念却是错误的。因为GetString2 内的“hello world”是常量字符串，位于静态存储区，它在程序生命期内恒定不变。无论什么时候调用GetString2，它返回的始终是同一个“只读”的内存块。

18: new/delete,  malloc/free
对于非内部数据类型的对象而言，光用maloc/free 无法满足动态对象的要求。对象
在创建的同时要自动执行构造函数， 对象在消亡之前要自动执行析构函数。由于
malloc/free 是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数
和析构函数的任务强加于malloc/free

19: 内存耗尽怎么办
如果在申请动态内存时找不到足够大的内存块，malloc 和new 将返回NULL 指针，宣告内存申请失败。通常有三种方式处理“内存耗尽”问题。
（1）判断指针是否为NULL，如果是则马上用return 语句终止本函数。例如：
void Func(void)
{
A *a = new A;
if(a == NULL)
{
return;
}
…
}
（2）判断指针是否为NULL，如果是则马上用exit(1)终止整个程序的运行。例如：
void Func(void)
{
A *a = new A;
if(a == NULL)
{
cout << “Memory Exhausted” << endl;
exit(1);
}
…
}
（3）为new 和malloc 设置异常处理函数。例如Visual C++可以用_set_new_hander 函数为new 设置用户自己定义的异常处理函数，也可以让malloc 享用与new 相同的异常处理函数。详细内容请参考C++使用手册。
上述（1）（2）方式使用最普遍。如果一个函数内有多处需要申请动态内存，那么方式（1）就显得力不从心（释放内存很麻烦），应该用方式（2）来处理。很多人不忍心用exit(1)，问：“不编写出错处理程序，让操作系统自己解决行不行？”不行。如果发生“内存耗尽”这样的事情，一般说来应用程序已经无药可救。如果
不用exit(1) 把坏程序杀死，它可能会害死操作系统

20: 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 直接引用这些头文件

21: 令人迷惑的隐藏规则
本来仅仅区别重载与覆盖并不算困难，但是C++的隐藏规则使问题复杂性陡然增加。
这里“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：
（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual
关键字，基类的函数将被隐藏（注意别与重载混淆）。
（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual
关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。


22: 运算符重载
运算符 规则
所有的一元运算符 建议重载为成员函数
= () [] -> 只能重载为成员函数
+= -= /= *= &= |= ~= %= >>= <<= 建议重载为成员函数
所有其它运算符 建议重载为全局函数

23: 函数内联
inline 是一种“用于实现的关键字”，而不是一种“用于声明的关键字”。
定义在类声明之中的成员函数将自动地成为内联函数，例如
class A
{
public:
void Foo(int x, int y) { ⋯ } // 自动地成为内联函数
}
将成员函数的定义体放在类声明之中虽然能带来书写上的方便，但不是一种良好的编程
风格，上例应该改成：
// 头文件
class A
{
public:
void Foo(int x, int y)；
}
// 定义文件
inline void A::Foo(int x, int y)
{
⋯
}

24：构造函数的初始化列表
B::B(const A &a)  //初始化表里调用了类A 的拷贝构造函数，从而将成员对象m_a 初始化。
: m_a(a)
{
…
}
B::B(const A &a)  //构造函数干了两件事：先暗地里创建m_a对象（调用了A 的无参数构造函数），再调用类A 的赋值函数，将参数a 赋给m_a
{
m_a = a;
…
} 

25: 构造和析构的次序
构造从类层次的最根处开始，在每一层中，首先调用基类的构造函数，然后调用成员对象的构造函数。析构则严格按照与构造相反的次序执行，该次序是唯一的，否则编译器将无法自动执行析构过程。
一个有趣的现象是，成员对象初始化的次序完全不受它们在初始化表中次序的影响，只由成员对象在类中声明的次序决定。这是因为类的声明是唯一的，而类的构造函数可以有多个，因此会有多个不同次序的初始化表。如果成员对象按照初始化表的次序进行构造，这将导致析构函数无法得到唯一的逆序

26: 拷贝构造函数与赋值函数
编译器将以“位拷贝”的方式自动生成缺省的函数。倘若类中含有指针变量，那么这两个缺省的函数就隐含了错误。
拷贝构造函数和赋值函数非常容易混淆，常导致错写、错用。拷贝构造函数是在对象被创建时调用的，而赋值函数只能被已经存在了的对象调用。以下程序中，第三个语句和第四个语句很相似，你分得清楚哪个调用了拷贝构造函数，哪个调用了赋值函数吗？
String a(“hello”);
String b(“world”);
String c = a; // 调用了拷贝构造函数，最好写成 c(a);
c = b; // 调用了赋值函数
本例中第三个语句的风格较差，宜改写成String c(a) 以区别于第四个语句

27:
// 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(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;
}

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


28: 在编写派生类的赋值函数时，注意不要忘记对基类的数据成员重新赋值
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;
}

29;
函数返回值采用“引用传递”的场合并不多，这种方式一般只出现在类的赋值函数中，目的是为了实现链式表达。
例如
class A
{⋯
A & operate = (const A &other); // 赋值函数
};
A a, b, c; // a, b, c 为A 的对象
⋯
a = b = c; // 正常的链式赋值
(a = b) = c; // 不正常的链式赋值，但合法
如果将赋值函数的返回值加const 修饰，那么该返回值的内容不允许被改动。上例中，语句 a = b = c 仍然正确，但是语句 (a = b) = c 则是非法的。

30: 继承和组合的规则
（1）若在逻辑上B 是A 的“一种”，并且A 的所有功能和属性对B 而言都有意义，则允许B 继承A 的功能和属性。
（2）若在逻辑上A 是B 的“一部分”（a part of），则不允许B 从A 派生，而是要用A 和其它东西组合出B。


31：  引用本身不占存储单元，系统也不给引用分配存储单元。故：对引用求地址，就是对目标变量求地址。&ra与&a相等