1.C++统一初始化:
初始化列表解决方案：
//C语言的初始化方案
int main()
{
int a = 10;
int* ip = nullptr;
int ar[] = { 12,23,34,45,56,67 };
}C++ 初始化：使用{ }
int main()
{
//char ch = 'a';
char ch{ 'a' };
//int a = 10;
int a{ 10 };
int b = int(10);
int x{ 10 };
int y = int{ 10 };
//double* ip = nullptr;
double* ip{ nullptr };
int ar[] = { 1,2,3,4,5,6 };
int br[]{ 1,2,3,4,5,6 };
return 0;
}2.输入输出
C++的输入输出
#include<iostream>
using namespace std;
int main()
{
int a{};
char ch{};
//scanf_s("%d", &a);
//scanf_s("%c", &ch);
cin >> a >> ch; //cin输入流对象
//printf("a=%d ch=%c \n", a, ch);
cout << a << "\t" << ch << endl; //endl=> \n;
cout << a << " " << ch << endl; // \n;
return 0;
}int main()
{
int a{ 10 }, b{ 20 };
printf("a=%d b=%d\b", a, b);
cout << "a=" << a << "b=" << b << endl;
return 0;
}注：
使用cout标准输出(控制台)和cin标准输入(键盘)时，必须包含<iostream >头文件以及std标准命名空间endl相当于'/n'；
字符串的输入：
int main()
{
char str[128]{};
//cin >> str;
cin.getline(str, 128); //127 \0
cin.getline(str, 128, '#');
cout << str << endl;
return 0;
}3.const 与指针
const 在C与C++的区别：
int main()
{
const int n = 10;
int ar[n] = { 1,2,3,4 };
int* p = (int*)&n;
*p = 100;
printf("n=%d *p=%d\n", n, *p);
return 0;
}C++以常量为主 C语言以变量为主
const与指针的关系：
int main()
{
int a{ 10 }, b{ 20 }; //指针自身的值 指针所指之物的值
int* ip1 = &a; // *ip1 = 100;ip1=&b;
const int* ip2 = &a; //const修饰自身指向能力时， 指向不可修改 自身可以修改
int const* ip3 = &a; //ip2=&b
int* const ip4 = &a; //const修饰ip自身 *ip4=100;
const int* const ip5 = &a; //都不能修改
return 0;
}
A：const修饰自身指向能力时， 指向不可修改 自身可以修改， 指向为常性 在赋值的时候
//1 不能给普通指针，无法编译通过 能力扩展了
//3 const修饰指针自身 没有修饰指向
B: const修饰p自身
4.引用（别名）
引用的定义
类型& 引用变量名称 = 变量名称
这就是引用变量的定义。&和类型结合称之为引用符号，不是取地址的符，代表别名的意思。
int main()
{
int a = 10;
int b = a;
int& c = a;
return 0;
}
引用的特点：
int main()
{
int a{ 10 };
int& b=a; //int *ip{nullptr}
}
const引用：
//引用
int main()
{
int a{ 10 };
const int b{ 20 }; //常变量
int& x = a; //普通引用引用普通变量
int &x = b; //error 不能拿普通引用引用常变量
//常性引用是万能引用
const int& x = b; //ok 常引用可以引用常变量
const int& y = a; //ok 常引用可以引用普通变量 y只能读取a的值 不能通过y去修改a的值
const int& z = 10; //ok 常引用可以引用字面常量
return 0;
}
引用作为形参代替指针：
void Swap(int *ap, int *bp) //形参是指针
{
assert(ap != nullptr && bp != nullptr);
int tmp = *ap;
*ap = *bp;
*bp = tmp;
}
int main()
{
int x = 10, y = 20;
Swap(&x,&y);
cout << "x=" << x << "y=" << y << endl;
return 0;
}使用引用交换两个整型值
其他引用：
1）引用作为其它变量的别名而存在，因此在一些场合可以代替指针
2）引用相对于指针来说具有更好的可读性和实用性
5.缺省参数
一般情况下，函数调用时的实参个数应与形参相同，但为了更方便地使用函数，C++也允许定义具有缺省参数的函数，这种函数调用时，实参个数可以与形参不相同。
缺省参数指在定义函数时为形参指定缺省值（默认值)。
这样的函数在调用时，对于缺省参数，可以给出实参值，也可以不给出参数值。如果给出实参，将实参传递给形参进行调用，如果不给出实参，则按缺省值进行调用。
缺省参数的函数调用:缺省实参并不一定是常量表达式，可以是任意表达式，甚至可以通过函数调用给出。如果缺省实参是任意表达式，则函数每次被调用时该表达式被重新求值。但表达式必须有意义;
int my_rand()
{
srand(time(nullptr));
int ra = rand() % 100;
return ra;
}
void func(int a, int b = my_rand())
{
cout << "a= " << a << endl;
cout << "b= " << b << endl;
}
int main()
{
func(1);
return 0;
}
当缺省实参是一个表达式时在函数被调用时该表达式被求值。
6.函数重载
C语言实现int,double,char 类型的比较大小函数：
函数重载(Function Overload)：用同一个函数名定义不同的函数，当函数名和不同的参数搭配时函数的含义不同。
在C++中可以为两个或两个以上的函数提供相同的函数名称，只要参数类型不同，或参数类型相同而参数的个数不同， 称为函数重载。
void func(int a,char ch){}
void func(char ch,int a){}
int main()
{
func(12, 'a');
func('a', 12);
return 0;
}
1.如果两个函数的参数表相同，但是返回类型不同，会被标记为编译错误: 函数的重复声明
⒉参数表的比较过程与形参名无关。
3.如果在两个函数的参数表中，只有缺省实参不同，则第二个声明被视为第一个的重复声明。
4.注意函数调用的二义性;
如果在两个函数的参数表中,形参类型相同,而形参个数不同,形参默认值将会影响函数的重载.
5.当一个形参类型有const或volatile修饰时,如果形参是按值传递方式定义,在识别函数声明是否相同时,并不考虑const和volatile修饰符.
6.当一个形参类型有const或volatile修饰时,如果形参定义指针或引用时,在识别函数声明是否相同时，就要考虑const和volatile修饰符.
总结:
函数重载的依据
返回类型不同的函数是否可以重载。
参数带有默认值的情况
为什么C++可以函数重载而C语言不可
名字粉碎。
extern 关键字的使用
