引用

1、C++类型检查严格

```c++

const int a = 10;

int b = a;

cont int *pa = &a;

int *b = &a;

以上两种操作，c++编译器就会报错

```

2、函数重载

2.1 重载规则

1）函数名相同，参数类型、个数、顺序不同

2）返回值类型不同的不构成重载

2.2 匹配规则

1）完全匹配则调用

2）隐式转换则调用

```c++

int-> long double 会出现二义性

double -> int float 会出现二义性

```

2019.11.11

1、引用

```c++

int a = 500;  //变量名 实际为内存空间的别名

*（int *）0xb00002345 = 500; 

int &ra = a;  //ra为a的引用，ra与a地址一样

int &ra = b;  //错，不能修改引用关系

int &rra = ra;  //对，对引用ra再引用

int &&ra = ra; //错，不能建立引用的引用

```

总结：

1）引用是一种声明关系，声明时就必须初始化，引用不开辟空间，也就是ra==不占用内存空间==

2）一旦声明，不能改变

3）可以对引用再次引用，但是不能建立引用的引用

指针引用

```c++

#include <iostream>

using namespace std;

//void change(char** ps1, char** ps2)

//{

//    char* tmp = *ps1;

//    *ps1 = *ps2;

//    *ps2 = tmp;

//}

void change(char*& ps1, char*& ps2)

{

    char* tmp = ps1;

    ps1 = ps2;

    ps2 = tmp;

}

int main(int argc, char *argv[])

{

    char *s1 = "hello";

    char *s2 = "world";

    cout << "s1 = " << s1 << " s2 = " << s2 << endl;

    //change(&s1,&s2);    //平级解决不了的要升级

    change(s1, s2); //引用在平级可以解决

    cout << "s1 = " << s1 << " s2 = " << s2 << endl;

    return 0;

}

```

```c++

int a = 100;

int *pa = a;

int * &rpa = pa;  //对，指针的引用

int & ra = a;

int & &rra = ra;  //错，不能建立引用的引用

int & rra = ra; //对，引用再次引用

int a = 100;

int *pa = &a;

int **ppa = &pa;  //对，指针的指针，二级指针

int & * pra = &ra //错，不能定义引用的指针，指针本质是对指针的包装，引用的指针是对引用取地址，相当解封装，逆操作，违背设计原则，因此不支持

int x, y, z;

int * arr[] = {&x, &y, &z};  //对，指针数组

int & arr[] = {x, y, z};  //错，不能定义引用的数组

arr是首元素地址，也就是 int& * ，这个就是引用的指针，就不支持

int arr[] = {x, y, z};

int (& rarr)[3]  =  arr;  //对，可以建立数组的引用

常引用

const int a = 1;

int &b = a;  //错误，不能把普通引用绑定到const对象

const int &b = a;  //对，通过b不会修改a的值

const引用初始化微妙，如下：

const int &a = 1;  //对，可用常量直接引用

double a = 1;

const int &b = a;  //对，可用不同类型初始化

int a = 1, b = 2;

const int &a = (a+b); //对，可用表达式引用

```

结论：

1、可以对变量引用：普通变量的引用，指针的引用，数组的引用，引用再次引用 （对）

2、可以对引用取地址，不可以建立引用的指针，引用的指针，引用的数组，引用的引用 （错）

------

2019.11.12