常变量

变量用const修饰，其值不得被改变。任何改变此变量的代码都会产生编译错误。Const加在数据类型前后均可。

例如：

void main(void)

{

const int i = 10; //i,j都用作常变量

int const j = 20;

i = 15; //错误，常变量不能改变

j = 25; //错误，常变量不能改变

}

常指针

Const跟指针一起使用的时候有两种方法。

const可用来限制指针不可变。也就是说指针指向的内存地址不可变，但可以随意改变该地址指向的内存的内容。

int main(void)

{

int i = 10;

int *const j = &i; //常指针, 指向int型变量

(*j)++; //可以改变变量的内容

j++; //错误，不能改变常指针指向的内存地址

}

const也可用来限制指针指向的内存不可变，但指针指向的内存地址可变。

int main(void)

{

int i = 20;

const int *j = &i; //指针,指向int型常量

//也可以写成int const *j = &i;

j++; //指针指向的内存地址可变

(*j)++; //错误,不能改变内存内容

}

看完上面的两个例子，是不是糊涂了？告诉你一个诀窍，在第一个例子中，const用来修饰指针j,j不可变（也就是指向int变量的常指针）；第二个例子中，const用来修饰*j,*j不可变（也就是指向int常量的指针）。

这两种方式可以组合起来使用，使指针和内存内容都不可变。

int main(void)

{

int i = 10;

const int *const j = &i; //指向int常量的常指针

j++; //错误，不能改变指针指向的地址

(*j)++; //错误，不能改变常量的值

}

Const和引用

引用实际上就是变量的别名，这里有几条规则：

声明变量时必须初始化

一经初始化，引用不能在指向其它变量。

任何对引用的改变都将改变原变量。

引用和变量本身指向同一内存地址。

下面的例子演示了以上的规则:

void main(void)

{

int i = 10; //i和j是int型变量

int j = 20;

int &r = i; //r 是变量i的引用

int &s; //错误,声明引用时必须初始化

i = 15; //i 和 r 都等于15

i++; //i 和 r都等于16

r = 18; //i 和r 都等于18

printf("Address of i=%u, Address of r=%u",&i,&r); //内存地址相同

r = j; //i 和 r都等于20,但r不是j的引用

r++; //i 和 r 都等于21, j 仍等于20

}

用const修饰引用,使应用不可修改，但这并不耽误引用反映任何对变量的修改。Const加在数据类型前后均可。

例如：

void main(void)

{

int i = 10;

int j = 100;

const int &r = i;

int const &s = j;

r = 20; //错，不能改变内容

s = 50; //错，不能改变内容

i = 15; // i和r 都等于15

j = 25; // j和s 都等于25

}

Const和成员函数

声明成员函数时，末尾加const修饰，表示在成员函数内不得改变该对象的任何数据。这种模式常被用来表示对象数据只读的访问模式。例如：

class MyClass

{

char *str ="Hello, World";

MyClass()

{

//void constructor

}

~MyClass()

{

//destructor

}

char ValueAt(int pos) const //const method is an accessor method

{

if(pos >= 12)

return 0;

*str = 'M'; //错误，不得修改该对象

return str[pos]; //return the value at position pos

}

}

Const和重载

重载函数的时候也可以使用const,考虑下面的代码：

class MyClass

{

char *str ="Hello, World";

MyClass()

{

//void constructor

}

~MyClass()

{

//destructor

}

char ValueAt(int pos) const //const method is an accessor method

{

if(pos >= 12)

return 0;

return str[pos]; //return the value at position pos

}

char& ValueAt(int pos) //通过返回引用设置内存内容

{

if(pos >= 12)

return NULL;

return str[pos];

}

}

在上面的例子中，ValueAt是被重载的。Const实际上是函数参数的一部分，在第一个成员函数中它限制这个函数不能改变对象的数据，而第二个则没有。这个例子只是用来说明const可以用来重载函数，没有什么实用意义。

实际上我们需要一个新版本的GetValue。如果GetValue被用在operator=的右边，它就会充当一个变量；如果GetValue被用作一元操作符，那么返回的引用可以被修改。这种用法常用来重载操作符。String类的operator[]是个很好的例子。（这一段译得很烂，原文如下：In reality due to the beauty of references just the second definition of GetValue is actually required. If the GetValue method is used on the the right side of an = operator then it will act as an accessor, while if it is used as an l-value (left hand side value) then the returned reference will be modified and the method will be used as setter. This is frequently done when overloading operators. The [] operator in String classes is a good example.）

class MyClass

{

char *str ="Hello, World";

MyClass()

{

//void constructor

}

~MyClass()

{

//destructor

}

char& operator[](int pos) //通过返回引用可用来更改内存内容

{

if(pos >= 12)

return NULL;

return str[pos];

}

}

void main(void)

{

MyClass m;

char ch = m[0]; //ch 等于 'H'

m[0] = 'M'; //m的成员str变成：Mello, World

}

Const的担心

C/C++中，数据传递给函数的方式默认的是值传递，也就是说当参数传递给函数时会产生一个该参数的拷贝，这样该函数内任何对该参数的改变都不会扩展到此函数以外。每次调用该函数都会产生一个拷贝，效率不高，尤其是函数调用的次数很高的时候。

例如：

class MyClass

{

public:

int x;

char ValueAt(int pos) const //const method is an accessor method

{

if(pos >= 12)

return 0;

return str[pos]; //return the value at position pos

}

MyClass()

{

//void constructor

}

~MyClass()

{

//destructor

}

MyFunc(int y) //值传递

{

y = 20;

x = y; //x 和 y 都等于 20.

}

}

void main(void)

{

MyClass m;

int z = 10;

m.MyFunc(z);

printf("z=%d, MyClass.x=%d",z,m.x); //z 不变, x 等于20.

}

通过上面的例子可以看出，z没有发生变化，因为MyFunc()操作的是z的拷贝。为了提高效率，我们可以在传递参数的时候，不采用值传递的方式，而采用引用传递。这样传递给函数的是该参数的引用，而不再是该参数的拷贝。然而问题是如果在函数内部改变了参数，这种改变会扩展到函数的外部，有可能会导致错误。在参数前加const修饰保证该参数在函数内部不会被改变。

class MyClass

{

public:

int x;

MyClass()

{

//void constructor

}

~MyClass()

{

//destructor

}

int MyFunc(const int& y) //引用传递, 没有任何拷贝

{

y =20; //错误，不能修改常变量

x = y

}

}

void main(void)

{

MyClass m;

int z = 10;

m.MyFunc(z);

printf("z=%d, MyClass.x=%d",z,m.x); //z不变, x等于10.

}

如此，const通过这种简单安全机制使你写不出那种说不定是什么时候就会掉过头来咬你一口的代码。你应该尽可能的使用const引用，通过声明你的函数参数为常变量（任何可能的地方）或者定义那种const method，你就可以非常有效确立这样一种概念：本成员函数不会改变任何函数参数，或者不会改变任何该对象的数据。别的程序员在使用你提供的成员函数的时候，不会担心他们的数据被改得一塌糊涂。

　　如果我们有一个int test(int a)的函数，那么，它的地址就是函数的名字，这一点如同数组一样，数组的名字就是数组的起始地址。

　　定义一个指向函数的指针用如下的形式，以上面的test()为例：

int (*fp)(int a);//这里就定义了一个指向函数的指针

　　函数指针不能绝对不能指向不同类型，或者是带不同形参的函数，在定义函数指针的时候我们很容易犯如下的错误。

int *fp(int a);//这里是错误的，因为按照结合性和优先级来看就是先和()结合，然后变成了一个返回整形指针的函数了，而不是函数指针，这一点尤其需要注意！

　　下面我们来看一个具体的例子：

#include <iostream> 
#include <string> 
using namespace std; 
 
int test(int a); 
 
void main(int argc,char* argv[])   
{ 
    cout<<test<<endl;//显示函数地址 
    int (*fp)(int a); 
    fp=test;//将函数test的地址赋给函数学指针fp 
    cout<<fp(5)<<"|"<<(*fp)(10)<<endl; 
//上面的输出fp(5),这是标准c++的写法,(*fp)(10)这是兼容c语言的标准写法,两种同意,但注意区分,避免写的程序产生移植性问题! 
    cin.get(); 
} 
 
int test(int a) 
{ 
    return a; 
}

typedef定义可以简化函数指针的定义，在定义一个的时候感觉不出来，但定义多了就知道方便了，上面的代码改写成如下的形式：

#include <iostream> 
#include <string> 
using namespace std; 
 
int test(int a); 
 
void main(int argc,char* argv[])   
{ 
    cout<<test<<endl; 
    typedef int (*fp)(int a);//注意,这里不是生命函数指针,而是定义一个函数指针的类型,这个类型是自己定义的,类型名为fp 
    fp fpi;//这里利用自己定义的类型名fp定义了一个fpi的函数指针! 
    fpi=test; 
    cout<<fpi(5)<<"|"<<(*fpi)(10)<<endl; 
    cin.get(); 
} 
 
int test(int a) 
{ 
    return a; 
}

二.字节对齐对程序的影响:
    先让我们看几个例子吧(32bit,x86环境,gcc编译器):
设结构体如下定义：
struct A
{
    int a;
    char b;
    short c;
};
struct B
{
    char b;
    int a;
    short c;
};
现在已知32位机器上各种数据类型的长度如下:
char:1(有符号无符号同)   
short:2(有符号无符号同)   
int:4(有符号无符号同)   
long:4(有符号无符号同)   
float:4    double:8
那么上面两个结构大小如何呢?
结果是:
sizeof(strcut A)值为8
sizeof(struct B)的值却是12

结构体A中包含了4字节长度的int一个，1字节长度的char一个和2字节长度的short型数据一个,B也一样;按理说A,B大小应该都是7字节。
之所以出现上面的结果是因为编译器要对数据成员在空间上进行对齐。上面是按照编译器的默认设置进行对齐的结果,那么我们是不是可以改变编译器的这种默认对齐设置呢,当然可以.例如:
#pragma pack (2) /*指定按2字节对齐*/
struct C
{
    char b;
    int a;
    short c;
};
#pragma pack () /*取消指定对齐，恢复缺省对齐*/
sizeof(struct C)值是8。
修改对齐值为1：
#pragma pack (1) /*指定按1字节对齐*/
struct D
{
    char b;
    int a;
    short c;
};
#pragma pack () /*取消指定对齐，恢复缺省对齐*/
sizeof(struct D)值为7。
后面我们再讲解#pragma pack()的作用.

三.编译器是按照什么样的原则进行对齐的?
    先让我们看四个重要的基本概念：
1.数据类型自身的对齐值：
  对于char型数据，其自身对齐值为1，对于short型为2，对于int,float,double类型，其自身对齐值为4，单位字节。
2.结构体或者类的自身对齐值：其成员中自身对齐值最大的那个值。
3.指定对齐值：#pragma pack (value)时的指定对齐值value。
4.数据成员、结构体和类的有效对齐值：自身对齐值和指定对齐值中小的那个值。
有 了这些值，我们就可以很方便的来讨论具体数据结构的成员和其自身的对齐方式。有效对齐值N是最终用来决定数据存放地址方式的值，最重要。有效对齐N，就是 表示“对齐在N上”，也就是说该数据的"存放起始地址%N=0".而数据结构中的数据变量都是按定义的先后顺序来排放的。第一个数据变量的起始地址就是数 据结构的起始地址。结构体的成员变量要对齐排放，结构体本身也要根据自身的有效对齐值圆整(就是结构体成员变量占用总长度需要是对结构体有效对齐值的整数 倍，结合下面例子理解)。这样就不能理解上面的几个例子的值了。
例子分析：
分析例子B；
struct B
{
    char b;
    int a;
    short c;
};
假 设B从地址空间0x0000开始排放。该例子中没有定义指定对齐值，在笔者环境下，该值默认为4。第一个成员变量b的自身对齐值是1，比指定或者默认指定 对齐值4小，所以其有效对齐值为1，所以其存放地址0x0000符合0x0000%1=0.第二个成员变量a，其自身对齐值为4，所以有效对齐值也为4， 所以只能存放在起始地址为0x0004到0x0007这四个连续的字节空间中，复核0x0004%4=0,且紧靠第一个变量。第三个变量c,自身对齐值为 2，所以有效对齐值也是2，可以存放在0x0008到0x0009这两个字节空间中，符合0x0008%2=0。所以从0x0000到0x0009存放的 都是B内容。再看数据结构B的自身对齐值为其变量中最大对齐值(这里是a）所以就是4，所以结构体的有效对齐值也是4。根据结构体圆整的要求， 0x0009到0x0000=10字节，（10＋2）％4＝0。所以0x0000A到0x000B也为结构体B所占用。故B从0x0000到0x000B 共有12个字节,sizeof(struct B)=12;其实如果就这一个就来说它已将满足字节对齐了, 因为它的起始地址是0,因此肯定是对齐的,之所以在后面补充2个字节,是因为编译器为了实现结构数组的存取效率,试想如果我们定义了一个结构B的数组,那 么第一个结构起始地址是0没有问题,但是第二个结构呢?按照数组的定义,数组中所有元素都是紧挨着的,如果我们不把结构的大小补充为4的整数倍,那么下一 个结构的起始地址将是0x0000A,这显然不能满足结构的地址对齐了,因此我们要把结构补充成有效对齐大小的整数倍.其实诸如:对于char型数据，其 自身对齐值为1，对于short型为2，对于int,float,double类型，其自身对齐值为4，这些已有类型的自身对齐值也是基于数组考虑的,只 是因为这些类型的长度已知了,所以他们的自身对齐值也就已知了.
同理,分析上面例子C：
#pragma pack (2) /*指定按2字节对齐*/
struct C
{
    char b;
    int a;
    short c;
};
#pragma pack () /*取消指定对齐，恢复缺省对齐*/
第 一个变量b的自身对齐值为1，指定对齐值为2，所以，其有效对齐值为1，假设C从0x0000开始，那么b存放在0x0000，符合0x0000%1= 0;第二个变量，自身对齐值为4，指定对齐值为2，所以有效对齐值为2，所以顺序存放在0x0002、0x0003、0x0004、0x0005四个连续 字节中，符合0x0002%2=0。第三个变量c的自身对齐值为2，所以有效对齐值为2，顺序存放
在0x0006、0x0007中，符合 0x0006%2=0。所以从0x0000到0x00007共八字节存放的是C的变量。又C的自身对齐值为4，所以C的有效对齐值为2。又8%2=0,C 只占用0x0000到0x0007的八个字节。所以sizeof(struct C)=8.

四.如何修改编译器的默认对齐值?
1.在VC IDE中，可以这样修改：[Project]|[Settings],c/c++选项卡Category的Code Generation选项的Struct Member Alignment中修改，默认是8字节。
2.在编码时，可以这样动态修改：#pragma pack .注意:是pragma而不是progma.

五.针对字节对齐,我们在编程中如何考虑?

    如果在编程的时候要考虑节约空间的话,那么我们只需要假定结构的首地址是0,然后各个变量按照上面的原则进行排列即可,基本的原则就是把结构中的变量按照 类型大小从小到大声明,尽量减少中间的填补空间.还有一种就是为了以空间换取时间的效率,我们显示的进行填补空间进行对齐,比如:有一种使用空间换时间做 法是显式的插入reserved成员：
         struct A{
           char a;
           char reserved[3];//使用空间换时间
           int b;
}

reserved成员对我们的程序没有什么意义,它只是起到填补空间以达到字节对齐的目的,当然即使不加这个成员通常编译器也会给我们自动填补对齐,我们自己加上它只是起到显式的提醒作用.

六.字节对齐可能带来的隐患:
    代码中关于对齐的隐患，很多是隐式的。比如在强制类型转换的时候。例如：
unsigned int i = 0x12345678;
unsigned char *p=NULL;
unsigned short *p1=NULL;

p=&i;
*p=0x00;
p1=(unsigned short *)(p+1);
*p1=0x0000;
最后两句代码，从奇数边界去访问unsignedshort型变量，显然不符合对齐的规定。
在x86上，类似的操作只会影响效率，但是在MIPS或者sparc上，可能就是一个error,因为它们要求必须字节对齐.

七.如何查找与字节对齐方面的问题:
如果出现对齐或者赋值问题首先查看
1. 编译器的big little端设置
2. 看这种体系本身是否支持非对齐访问
3. 如果支持看设置了对齐与否,如果没有则看访问时需要加某些特殊的修饰来标志其特殊访问操作。

八.相关文章:转自http://blog.csdn.net/goodluckyxl/archive/2005/10/17/506827.aspx

 ARM下的对齐处理
from DUI0067D_ADS1_2_CompLib

3.13 type  qulifiers

有部分摘自ARM编译器文档对齐部分

对齐的使用:
1.__align(num)
   这个用于修改最高级别对象的字节边界。在汇编中使用LDRD或者STRD时
   就要用到此命令__align(8)进行修饰限制。来保证数据对象是相应对齐。
   这个修饰对象的命令最大是8个字节限制,可以让2字节的对象进行4字节
   对齐,但是不能让4字节的对象2字节对齐。
   __align是存储类修改,他只修饰最高级类型对象不能用于结构或者函数对象。
  
2.__packed
  __packed是进行一字节对齐
  1.不能对packed的对象进行对齐
  2.所有对象的读写访问都进行非对齐访问
  3.float及包含float的结构联合及未用__packed的对象将不能字节对齐
  4.__packed对局部整形变量无影响
  5.强制由unpacked对象向packed对象转化是未定义,整形指针可以合法定
  义为packed。
     __packed int* p;  //__packed int 则没有意义
  6.对齐或非对齐读写访问带来问题
  __packed struct STRUCT_TEST
 {
  char a;
  int b;
  char c;
 }  ;    //定义如下结构此时b的起始地址一定是不对齐的
         //在栈中访问b可能有问题,因为栈上数据肯定是对齐访问[from CL]
//将下面变量定义成全局静态不在栈上
static char* p;
static struct STRUCT_TEST a;
void Main()
{
 __packed int* q;  //此时定义成__packed来修饰当前q指向为非对齐的数据地址下面的访问则可以

 p = (char*)&a;         
 q = (int*)(p+1);     
 
 *q = 0x87654321;
/*  
得到赋值的汇编指令很清楚
ldr      r5,0x20001590 ; = #0x12345678
[0xe1a00005]   mov      r0,r5
[0xeb0000b0]   bl       __rt_uwrite4  //在此处调用一个写4byte的操作函数
     
[0xe5c10000]   strb     r0,[r1,#0]   //函数进行4次strb操作然后返回保证了数据正确的访问
[0xe1a02420]   mov      r2,r0,lsr #8
[0xe5c12001]   strb     r2,[r1,#1]
[0xe1a02820]   mov      r2,r0,lsr #16
[0xe5c12002]   strb     r2,[r1,#2]
[0xe1a02c20]   mov      r2,r0,lsr #24
[0xe5c12003]   strb     r2,[r1,#3]
[0xe1a0f00e]   mov      pc,r14
*/

/*
如果q没有加__packed修饰则汇编出来指令是这样直接会导致奇地址处访问失败
[0xe59f2018]   ldr      r2,0x20001594 ; = #0x87654321
[0xe5812000]   str      r2,[r1,#0]
*/

//这样可以很清楚的看到非对齐访问是如何产生错误的
//以及如何消除非对齐访问带来问题
//也可以看到非对齐访问和对齐访问的指令差异导致效率问题
}

A(void); // 缺省的无参数构造函数

A(const A &a); // 缺省的拷贝构造函数

~A(void); // 缺省的析构函数

A & operate =(const A &a); // 缺省的赋值函数

这不禁让人疑惑，既然能自动生成函数，为什么还要程序员编写？

原因如下：

（1）如果使用“缺省的无参数构造函数”和“缺省的析构函数”，等于放弃了自主“初始化”和“清除”的机会，C++发明人Stroustrup的好心好意白费了。

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

对于那些没有吃够苦头的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; // 用于保存字符串

};

9.1 构造函数与析构函数的起源
作为比C更先进的语言，C++提供了更好的机制来增强程序的安全性。C++编译器具有严格的类型安全检查功能，它几乎能找出程序中所有的语法问题，这的确帮了程序员的大忙。但是程序通过了编译检查并不表示错误已经不存在了，在“错误”的大家庭里，“语法错误”的地位只能算是小弟弟。级别高的错误通常隐藏得很深，就象狡猾的罪犯，想逮住他可不容易。

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

构造函数与析构函数的名字不能随便起，必须让编译器认得出才可以被自动执行。Stroustrup的命名方法既简单又合理：让构造函数、析构函数与类同名，由于析构函数的目的与构造函数的相反，就加前缀‘~’以示区别。

除了名字外，构造函数与析构函数的另一个特别之处是没有返回值类型，这与返回值类型为void的函数不同。构造函数与析构函数的使命非常明确，就象出生与死亡，光溜溜地来光溜溜地去。如果它们有返回值类型，那么编译器将不知所措。为了防止节外生枝，干脆规定没有返回值类型。

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

构造函数初始化表的使用规则：

u 如果类存在继承关系，派生类必须在其初始化表里调用基类的构造函数。

例如

class A

{…

A(int x); // A的构造函数

};

class B : public A

{…

B(int x, int y);// B的构造函数

};

B::B(int x, int y)

: A(x) // 在初始化表里调用A的构造函数

{

…

}

u 类的const常量只能在初始化表里被初始化，因为它不能在函数体内用赋值的方式来初始化（参见5.4节）。

u 类的数据成员的初始化可以采用初始化表或函数体内赋值两种方式，这两种方式的效率不完全相同。

非内部数据类型的成员对象应当采用第一种方式初始化，以获取更高的效率。例如

class A

{…

A(void); // 无参数构造函数

A(const A &other); // 拷贝构造函数

A & operate =( const A &other); // 赋值函数

}；

class B

{

public:

B(const A &a); // B的构造函数

private:

A m_a; // 成员对象

};

示例9-2(a)中，类B的构造函数在其初始化表里调用了类A的拷贝构造函数，从而将成员对象m_a初始化。

示例9-2 (b)中，类B的构造函数在函数体内用赋值的方式将成员对象m_a初始化。我们看到的只是一条赋值语句，但实际上B的构造函数干了两件事：先暗地里创建m_a对象（调用了A的无参数构造函数），再调用类A的赋值函数，将参数a赋给m_a。

B::B(const A &a)

: m_a(a)

{

…

}
B::B(const A &a)

{

m_a = a;

…

}

示例9-2(a) 成员对象在初始化表中被初始化 示例9-2(b) 成员对象在函数体内被初始化

对于内部数据类型的数据成员而言，两种初始化方式的效率几乎没有区别，但后者的程序版式似乎更清晰些。若类F的声明如下：

class F

{

public:

F(int x, int y); // 构造函数

private:

int m_x, m_y;

int m_i, m_j;

}

示例9-2(c)中F的构造函数采用了第一种初始化方式，示例9-2(d)中F的构造函数采用了第二种初始化方式。

F::F(int x, int y)

: m_x(x), m_y(y)

{

m_i = 0;

m_j = 0;

}
F::F(int x, int y)

{

m_x = x;

m_y = y;

m_i = 0;

m_j = 0;

}

示例9-2(c) 数据成员在初始化表中被初始化 示例9-2(d) 数据成员在函数体内被初始化

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

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

9.4 示例：类String的构造函数与析构函数
// 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)

{

delete [] m_data;

// 由于m_data是内部数据类型，也可以写成 delete m_data;

}

9.5 不要轻视拷贝构造函数与赋值函数
由于并非所有的对象都会使用拷贝构造函数和赋值函数，程序员可能对这两个函数有些轻视。请先记住以下的警告，在阅读正文时就会多心：

u 本章开头讲过，如果不主动编写拷贝构造函数和赋值函数，编译器将以“位拷贝”的方式自动生成缺省的函数。倘若类中含有指针变量，那么这两个缺省的函数就隐含了错误。以类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被释放了两次。

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

String a(“hello”);

String b(“world”);

String c = a; // 调用了拷贝构造函数，最好写成 c(a);

c = b; // 调用了赋值函数

本例中第三个语句的风格较差，宜改写成String c(a) 以区别于第四个语句。

9.6 示例：类String的拷贝构造函数与赋值函数
// 拷贝构造函数

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拷贝构造函数与普通构造函数（参见9.4节）的区别是：在函数入口处无需与NULL进行比较，这是因为“引用”不可能是NULL，而“指针”可以为NULL。

类String的赋值函数比构造函数复杂得多，分四步实现：

（1）第一步，检查自赋值。你可能会认为多此一举，难道有人会愚蠢到写出 a = a 这样的自赋值语句！的确不会。但是间接的自赋值仍有可能出现，例如

// 内容自赋值

b = a;

…

c = b;

…

a = c;
// 地址自赋值

b = &a;

…

a = *b;

也许有人会说：“即使出现自赋值，我也可以不理睬，大不了化点时间让对象复制自己而已，反正不会出错！”

他真的说错了。看看第二步的delete，自杀后还能复制自己吗？所以，如果发现自赋值，应该马上终止函数。注意不要将检查自赋值的if语句

if(this == &other)

错写成为

if( *this == other)

（2）第二步，用delete释放原有的内存资源。如果现在不释放，以后就没机会了，将造成内存泄露。

（3）第三步，分配新的内存资源，并复制字符串。注意函数strlen返回的是有效字符串长度，不包含结束符‘\0’。函数strcpy则连‘\0’一起复制。

（4）第四步，返回本对象的引用，目的是为了实现象 a = b = c 这样的链式表达。注意不要将 return *this 错写成 return this 。那么能否写成return other 呢？效果不是一样吗？

不可以！因为我们不知道参数other的生命期。有可能other是个临时对象，在赋值结束后它马上消失，那么return other返回的将是垃圾。

9.7 偷懒的办法处理拷贝构造函数与赋值函数
如果我们实在不想编写拷贝构造函数和赋值函数，又不允许别人使用编译器生成的缺省函数，怎么办？

偷懒的办法是：只需将拷贝构造函数和赋值函数声明为私有函数，不用编写代码。

例如：

class A

{ …

private:

A(const A &a); // 私有的拷贝构造函数

A & operate =(const A &a); // 私有的赋值函数

};

如果有人试图编写如下程序：

A b(a); // 调用了私有的拷贝构造函数

b = a; // 调用了私有的赋值函数

编译器将指出错误，因为外界不可以操作A的私有函数。

template<class type>
class ablist
{
 public:
  ListNode<type> *GetHead()
  {
   return head;
  }
  ListNode<type> *GetNext(ListNode<type> &n)
  {
   return n.next==head?n.next->next:n.next;
  }
  type Get(int i);
  bool Set(type x,int i);
  ListNode<type> *Find1(type value);
  ListNode<type> *Find(int i);
  void MakeEmpty();
  virtual bool Insert(type value,int i)=0;
  virtual type Remove(int i)=0;
  virtual type Remove1(type value)=0;
 protected:
  ListNode<type> *head;
  int length;
};


template<class type>
bool ablist<type>::Set(type x,int i)
{
 ListNode<type> *p=Find(i);
 if(p==NULL||p==head)
 {
  return false;
 }
 else
 {
  p->data=x;
 }
 return true;
}

template<class type>
type ablist<type>::Get(int i)
{
 ListNode<type> *p=Find(i);
 assert(p&&p!=head);
 return p->data;
}

template<class type>
void ablist<type>::MakeEmpty()
{
 ListNode<type> *q=head->next;
 int i=1;
 while(i++<=length)
 {
  head->next=q->next;
  delete q;
  q=head->next;
 }
 length=0;
}

template<class type>
ListNode<type> *ablist<type>::Find1(type value)
{
 ListNode<type> *p=head->next;
 int i=1;
 while(i++<=length&&p->data!=value)
 {
  p=p->next;
 }
 return p;
}

template<class type>
ListNode<type> *ablist<type>::Find(int i)
{
 if(i<0||i>length)
 {
  return NULL;
 }
 if(i==0)
 {
  return head;
 }
 ListNode<type> *p=head->next;
 int j=1;
 while(p!=Null&&j<i)
 {
  p=p->next;
  j++;
 }
 return p;
}

class List:public ablist<type>
{
public:
 List()
 {
  head=new ListNode<type>;
  length=0;
 }
 List(List<type> &l)
 {
  Copy(l);
 }
 ~List()
 {
  MakeEmpty();
  delete head;
 }
 bool Insert(type value,int i);
 type Remove(int i);
 type Remove1(type value);
 List<type> &Copy(List<type> &l);
 List<type> &operator=(List<type> &l);
 friend ostream &operator<<(ostream &,List<type> &);
};

template<class type>
bool List<type>::Insert(type value,int i)
{
 ListNode<type> *p=Find(i-1);
 if(p=NULL)
 {
  return false;
 }
 ListNode<type> *newnode=new ListNode<type>(value,p->next);
 assert(newnode);
 p->next=newnode;
 length++;
 return true;
}


template<class type>
type List<type>::Remove(int i)
{
 ListNode<type> *p=Find(i-1),*q;
 assert(p&&p->next);
 q=p->next;
 p->next=q->next;
 type value=q->data;
 delete q;
 length--;
 return value;
}

template<class type>
type List<type>::Remove1(type value)
{
 ListNode>type> *q,p=head;
 while(p->next!=NULL&&p->next->data!=value)
 {
  p=p->next;
 }
 assert(p->next);
 p->next=q->next;
 delete q;
 length--;
 return value;
}

template<class type>
List<type>& List<type>::Copy(List<type> &l)
{
 ListNode<type> *p,*q,*r;
 Length=l.length;
 Head=NULL;
 if(!l.head)
 {
  return *this;
 }
 head=new ListNode<type>;
 if(!head)
 {
  return *this;
 }
 head->data=(l.head)->data;
 head->next=NULL;
 r=NULL;
 p=head;
 q=l.head->next;
 while(q)
 {
  r=new ListNode<type>;
  if(!r)
  {
   return *this;
  }
  r->data=q->data;
  r-next=NULL;
  p->next=r;
  p=p->next;
  q=q->next;
 }
 return *this;
}

template<class type>
List<type>& List<type>::operator=(List<type>& l)
{
 if(head)
 {
  MakeEmpty();
 }
 Copy(l);
 return *this;
}

template<class type>
ostream& operator<<(ostream& out,List<type> &l)
{
 ListNode<type> *p=l.head->next;
 out<<"length:"<<l.length<<"\ndata";
 while(p)
 {
  out<<p->data<<"\n";
  p=p->next;
 }
 out<<"输出完毕";
 return out;
}

template<class type>
class CirList:public ablist<type>
{
 public:
  CirList();
  CirList(CirList<type> &l)
  {
   Copy(l);
  }
   ~CirList()
   {
    MakeEmpty();
    delete head;
   }
   bool Insert(type value,int i);
   type Remove(int i);
   type Remove1(type value);
   CirList<type>& Copy(CirList& l);
   CirList<type>& operator=(CirList<type> &l);
   friend ostream& operator<<(ostream&,CirList<type>&);
 private:
  ListNode<type>* tail;
};



template<class type>
CirList<type>::CirList()
{
 tail=head=new ListNode<type>;
 tail->next=head;
 length=0;
}

template<class type>
CirList<type>& CirList<type>::Copy(CirList<type> &l)
{
 ListNode<type> *p.*q,*r;
 Length=l.length;
 head=tail=NULL;
 if(!l.head)
 {
  return *this;
 }
 head->data=(l.head)->data;
 tail=head;
 tail->next=head;
 r=head;
 p=head;
 q=l.head->next;
 while(q!=l.head)
 {
  r=new ListNode<type>;
  if(!r)
  {
   return *this;
  }
  r->data=q->data;
  r->next=head;
  p->next=r;
  tail=r;
  p=p->next;
  q=q->next;
 }
 return *this;
}

template<class type>
bool CirList<type>::Insert(type value,int i)
{
 ListNode<type>* p=Find(i-1);
 if(p==NULL)
 {
  return false;
 }
 ListNode<type>* newnode=new ListNode<type>(value,p->next);
 if(p->next==head)
 {
  tail=newnode;
  tail->next=head;
 }
 p->next=newnode;
 length++;
 return true;
}
template<class type>
type CirList<type>::Remove(int i)
{
 ListNode<type> *p=Find(i-1);
 assert(!(p==NULL||p->next==head));
 q=p->next;
 p->next=q->next;
 type value=q->data;
 if(q==tail)
 {
  tail=p;
  tail->next=head;
 }
 delete q;
 length--;
 return value;
}

template<class type>
type CirList<type>::Remove1(type value)
{
 ListNode<type> *q,*p=head;
 while(p->next!=head&&p->next->data!=value)
 {
  p=p->next;
  assert(!(p->next==head&&p->data!=value);
 }
 q=p->next;
 p->next=q->next;
 if(q==tail)
 {
  tail=p;
  tail->next=head;
 }
 delete q;
 length--;
 return value;
}

template<class type>
CirList<type>& CirList<type>::operator=(CirList<type> &l)
{
 if(head)
 {
  MakeEmpty();
  Copy(l);
 }
 return *this;
}

template<class type>
ostream& operator<<(ostream& out,CirList<type> &l)
{
 ListNode<type> *p=l.head->next;
 out<<"\nlength:"<<l.length<<"\ndata:";
 while(p!=head);
 {
  out<<p->data<<"\n";
  p=p->next;
 }
 out<<"输出完毕\n";
 return out;
}