C++复合类型

1. 引用

引用为对象起了另外一个名字，引用类型引用另外一种类型。通过将声明符写成&d的形式定义引用类型，其中d是声明的变量名。

类型名 & 引用名 = 变量名

int n = 4;int & r = n; 

某个变量的引用，等价于这个变量，相当于该变量的一个别名。

int n = 4;int & r = n; r = 4;cout << r; //输出 4cout << n; //输出 4n = 5;cout << r; //输出5

（1） 定义引用时一定要将其初始化成引用某个变量。
（2） 初始化后，它就一直引用该变量，不会再引用别的变量了。 

（3） 引用只能引用变量，不能引用常量和表达式。

double a = 4, b = 5;double & r1 = a;double & r2 = r1; // r2也引用 ar2 = 10;cout << a << endl; // 输出 10r1 = b; // r1并没有引用bcout << a << endl; //输出 5

c语言交换两个数

void swap( int * a, int * b){int tmp;tmp = * a; * a = * b; * b = tmp;}int n1, n2;swap(& n1,& n2) ; // n1,n2的值被交换

通过C++引用

void swap( int & a, int & b){int tmp;tmp = a; a = b; b = tmp;}int n1, n2;swap(n1,n2) ; // n1,n2的值被交换

引用作为函数返回值

int n = 4;int & SetValue() { return n; }int main(){SetValue() = 40;cout << n;return 0;} //输出： 40

常引用：定义引用时，前面加const关键字，即为“常引用”

int n;const int & r = n;

r 的类型是const int &
不能通过常引用去修改其引用的内容:

int n = 100;const int & r = n;r = 200; //编译错n = 300; // 没问题

const T & 和T & 是不同的类型!!!
T & 类型的引用或T类型的变量可以用来初始化 const T & 类型的引用。const T 类型的常变量和const T & 类型的引用则不能用来初始化T &类型的引用，除非进行强制类型转换。

2. 常量

（1）定义常量

const int MAX_VAL = 23；const string SCHOOL_NAME = "Peking University"；

（2）定义常量指针 

不可通过常量指针修改其指向的内容

int n,m;const int * p = & n;* p = 5; //编译出错n = 4; //okp = &m; //ok, 常量指针的指向可以变化

不能把常量指针赋值给非常量指针，反过来可以

const int * p1; int * p2;p1 = p2; //okp2 = p1; //errorp2 = (int * ) p1; //ok,强制类型转换

函数参数为常量指针时，可避免函数内部不小心改变参数指针所指地方的内容

void MyPrintf( const char * p ){strcpy( p,"this"); //编译出错printf("%s",p); //ok}

不能通过常引用修改其引用的变量

int n;const int & r = n;r = 5; //errorn = 4; //ok

3. 动态内存

（1） 分配一个变量

P = new T;

T是任意类型名， P是类型为T *的指针。 动态分配出一片大小为 sizeof(T)字节的内存空间，并且将该内存空间的起始地址赋值给P。比如

int * pn;pn = new int;* pn = 5;

（2） 分配一个数组

P = new T[N];

T :任意类型名
P :类型为T *的指针
N :要分配的数组元素的个数，可以是整型表达式
动态分配出一片大小为 sizeof(T)*N字节的内存空间，并且将该内存空间的起始地址赋值给P。 

用delete运算符释放动态分配的内存
用“new”动态分配的内存空间，一定要用“delete”运算符进行释放

int * p = new int;* p = 5;delete p;delete p; //导致异常， 一片空间不能被delete多次

用delete运算符释放动态分配的数组

int * p = new int[20];p[0] = 1;delete [ ] p;