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
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