#include//输入输出

#include//提供了常用类型和宏的定义

#include

#include

#include//Sleep

using namespace std;

引用（别名）

int a = 10;

int b = a;

int& c = a;

a += 10;

cout << a << c << endl; //20 20

c += 10;

cout << a << c << endl; //30 30

cout << &a << &c << endl; //same

int a = 10, b = 20;

int& x;//error 不能空引用

int& x = a;

int&& y = x;//error 没有引用的引用

int a = 10;

int& b = a;

b += 10;

int const& c = a;

cout << c << endl;

// c += 1-; error

int& const x = a;

x += 10; //right

const int a = 10;

int& x = a;//error

int const& x = a;//right

const int& a = 100;//常引用 底层有tmp

int &a = 100; error 右值不能引用（不能取地址的叫右值 ）

指针和引用的区别

1.指针存储地址 引用是别名

2.指针需要分配内存空间 而引用不需要

3.指针需要解引用 引用可以直接用

4.指针变量的值可以发生改变，指向改变

引用在定义是就被初始化，之后无法改变

5.指针可以为空 没有空引用

6.有指针的指针 没有引用的引用

const

/*int a = 10,b = 20;

const int* p2 = &a;*/

int const* p2 = &a; 与上一行等价

*p2 = 100//error

p2 = &b;//right

int* const p3 = &b;

*p3 = 100;//right

p3 = &a;//error

const int n = 5;

int ar[n] = { 1,2,3,4,5 };

int* p =(int *)&n;

*p = 100;//n = 100

//输入输出

char ch;

int a;

//cin 键盘

cin >> ch >> a;

//cin >> ch,a error

cout << a << ch << endl;

char str[20];

cin.getline(str, 20,'#');//防止碰见空格cin就结束

cout << str << endl;

//初始化列表

int a = 10;

int b(10);

int c = int(10);

//C11{}

int d = { 10 };

int e{ 10 };

int f = int{ 10 };

cout << "hello" << endl;

return 0;

void fun(int a, int b = 0, int c = 0, int d = 0)

{

cout << a << b << c << d << endl;

}

bool IsNumber(char ch)

{

return (ch >= '0' && ch <= '9') ? true : false;

}

int my_max(int a, int b)

{

return a > b ? a : b;

}

char my_max(char a, char b)

{

return a > b ? a : b;

}

double my_max(double a, double b)

{

return a > b ? a : b;

}

template

T my_max(T a, T b)

{

return a > b ? a : b;

}

int main()

{

函数模板

为了代码重用，使代码不受类型的限制

int x = my_max(12, 23);

char ch = my_max('a', 'b');

typeid(a).name() 打印a类型

如果参数有争议 可以加<>直接确定类型 int x = my_max(12.'b');

函数重载(通过名字粉碎，编译和链接过程名字不同)

如果两个函数的参数表相同，但是返回类型不同，会被标记为编译错误：函数的重复声明

参数表的比较过程与形参名无关

如果在两个函数的参数表中，只有缺省实参不同，则第二个声明被视为第一个的重复生命

当一个形参类型有const时，如果形参的方式是按值传递方式定义，在识别函数声明是否相同时，不考虑const

若const修饰的是指针 则不同

/*int x = my_max(12, 23);

char ch = my_max('a', 'b');

double c = my_max((12.23), (23.24));

*/

缺省函数

调用时实参个数可以与形参不同

在声明函数时为形参指定缺省值

fun(1);//1 0 0 0

fun(1, 2, 3, 4);//1 2 3 4

inline

当程序执行函数调用时，系统要建立栈空间，保护现场，

传递参数以及控制程序执行的转移等等，这些工作需要系统时间和空间的开销

inline是一种 以空间换时间 的做法 省去调用函数的额外开销

但当函数体的代码过长或者是递归函数即便加上inline关键字，

也不会在调用点以内联展开该函数

声明和定义函数不要分离

如果函数的执行开销大于开栈清栈 就不用inline

/*inline int Add_Int(int a, int b)

{

return a + b;

}

int c = 0;

c = Add_Int(10, 20);

cout << c << endl;*/

return 0;

}