C++复合类型

1. 引用

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

类型名 & 引用名 = 变量名

int n = 4;
int & r = n; 

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

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

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

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

double a = 4, b = 5;
double & r1 = a;
double & r2 = r1; // r2也引用 a
r2 = 10;
cout << a << endl; // 输出 10
r1 = b; // r1并没有引用b
cout << 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; //ok
p = &m; //ok, 常量指针的指向可以变化

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

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

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

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

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

int n;
const int & r = n;
r = 5; //error
n = 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;