目录
1、命名空间
2、C++的输入&输出
3、缺省参数
缺省参数的定义
缺省参数的分类
4、函数重载
重载的概念
C++支持函数重载的原理——名字修饰
5、引用
引用的概念
引用特性
常引用
引用的使用场景
引用和指针的区别
编辑
6、内联函数
7、auto关键字（C++11）
8、基于范围的for循环（C++11）
9. 指针空值nullptr(C++11)
1、命名空间
在C/C++中会出现大量的变量，函数，起名字是一个很大的问题，为了防止命名重复，就出现了命名空间的概念，使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突和名字污染
#include <stdio.h> #include <stdlib.h> int rand = 10; // C语言没办法解决类似这样的命名冲突问题，所以C++提出了namespace来解决 int main() { printf("%d\n", rand); return 0; } // 编译后报错：error C2365: “rand”: 重定义；以前的定义是“函数”
命名空间内可以定义变量，函数，也可以嵌套定义，使用命名空间有三种方式：
1.直接展开命名空间
using namespace ljp
ljp是命名空间的名字，自己可以随便起，要是有相同名字的命名空间，会合并成一个空间
2.使用using将命名空间中某个成员引入
using ljp::a
例如我引入的是一个int 类型的变量a，::是作用域限定符，
3.加命名空间和作用域限定符
ljp::a
这样就可以直接使用a变量了
2、C++的输入&输出
C++定义了新的输入和输出，输入是cin,输出是cout，但是使用时要展开C++官方的命名空间
using namespace std ，例如:
#include<iostream> using namespace std; int main() { int a = 10; cin >> a; cout << a << endl; cout << "hello world" << endl; return 0; }
使用cin和cout输入输出非常方便，不需要控制格式了，cin和cout可以自动识别类型，关于更加复杂的知识我们后面了解，这里简单使用一下输入输出。
std命名空间的使用惯例：
1.在日常练习中建议直接展开using namespace std，这样比较方便。
2.using namespace std展开，标准库就全部暴露出来了，如果我们定义跟库重名的类型/对象/函数，就存在冲突问题。该问题在日常练习中很少出现，但是项目开发中代码较多、规模大，就很容易出现。所以建议在项目开发中使用，像std::cout这样使用时指定命名空间 + using std::cout展开常用的库对象/类型等方式。
3、缺省参数
缺省参数的定义
缺省参数是声明或定义函数时为函数的参数指定一个缺省值，在调用这个函数时，如果实参没有指定的函数值，就采用该缺省参数。
第一个fun()函数，没有指定实参的值，则默认使用形参的缺省值，第二个fun()函数，实参是20，那么就用实参的值。
缺省参数的分类
全缺省参数
void Func(int a = 10, int b = 20, int c = 30) { cout<<"a = "<<a<<endl; cout<<"b = "<<b<<endl; cout<<"c = "<<c<<endl; }
半缺省参数
void Func(int a, int b = 10, int c = 20) { cout<<"a = "<<a<<endl; cout<<"b = "<<b<<endl; cout<<"c = "<<c<<endl; }
注意：
1.半缺省参数只能从右往左依次定义，不能间隔着给；
2.缺省参数不能在函数定义和声明中同时出现，最好是在函数声明中定义缺省参数，因为当我们定义对象时传的有参数，那么缺省参数就不算了，那么当我们定义对象时不传参数，这时候就会调用默认构造函数，因为我们写的有参构造函数，编译器不在生成默认构造函数，然而我们在构造函数的声明2中没有缺省值，编译器就会报错，没有合适的构造函数调用；
//a.h void Func(int a = 10); // a.cpp void Func(int a = 20) {} // 注意：如果声明与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该 用那个缺省值。
3.缺省值必须是常量或全局变量，
4.C语言不支持。
4、函数重载
重载的概念
函数重载：是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表（参数个数或类型或类型顺序）不同，常用来实现功能类似但数据类型不同的问题。
int Add(int a, int b) { return a + b; } int Add(double a, double b) { return a + b; } int Add(double a, int b) { return a + b; } int Add(int a, double b) { return a + b; } int Add(double a, double b,int c) { return a + b+c; } int main() { cout << Add(10, 20) << endl; cout << Add(10.5, 20.5) << endl; cout << Add(10.5, 20) << endl; cout << Add(10, 20.5) << endl; cout << Add(10.5, 20.5,30) << endl; return 0; }
这些都是同名函数，但都是函数重载；
C++支持函数重载的原理——名字修饰
为什么C++支持函数重载，而C语言不支持函数重载呢？
在C/C++中，一个程序的运行需要经过以下几个阶段：预处理，编译，汇编，链接
1.实际上 项目通常是由多个头文件和源文件组成的，当a.cpp中调用b.cpp中的add函数时，编译后连接前，a.o的目标文件中没有add函数的地址，因为add是在b.cpp中定义的，所以add的地址在b.cpp中，
2. 链接器看到a.o调用add,但是没有add的地址，就会到b.o的符号表中去找add的地址，然后链接到一起，
3.但是链接器会使用哪个名字去找呢？这里每个编译器都会有自己的函数名修饰规则。具体的up主就噶了（我也不会了，更加深入了，以后慢慢了解）
4.通过这里就理解了C语言没办法支持重载，因为同名函数没办法区分。而C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。
5.如果两个函数函数名和参数是一样的，返回值不同是不构成重载的，因为调用时编译器没办法区分了。
5、引用
引用的概念
引用不是新定义一个变量，而是给已存在变量取一个别名，编译器不会为引用变量开辟内存空间，
它和它引用的变量共用同一块内存空间。
类型& 引用变量名(对象名)=引用实体
voidTestRef() { inta=10; int&ra=a;//<====定义引用类型 printf("%p\n", &a); printf("%p\n", &ra); }
注意：引用类型必须和引用实体是同种类型的。
引用特性
1.引用在定义时必须初始化；
2.一个变量可以有多个引用；
3.引用一旦引用一个实体，不能再引用其他实体。
voidTestRef() { inta=10; // int& ra; // 该条语句编译时会出错 int&ra=a; int&rra=a; printf("%p %p %p\n", &a, &ra, &rra); }
常引用
void TestConstRef() { const int a = 10; //int& ra = a; // 该语句编译时会出错，a为常量 const int& ra = a; // int& b = 10; // 该语句编译时会出错，10为常量 const int& b = 10; double d = 12.34; //int& rd = d; // 该语句编译时会出错，类型不同 const int& rd = d; }
1.权限可以平移/缩小，但是不能放大，
2.类型转换会产生临时变量，临时变量具有常性，所以上面代码的最后一行要加上const，否则会报错。
引用的使用场景
略
引用和指针的区别
语法概念上引用就是一个别名，没有独立空间，和实体共用一块空间，但在地层逻辑上是有空间的，
引用和指针的不同点：
1.引用在概念上是定义一个变量的别名，指针是变量的地址；
2.引用在定义时必须初始化，指针没有要求；
3.引用在初始化引用一个实体后，不在引用其他实体，而指针可以指向任何实体；
4.没有NULL引用。但是有NULL指针；
5.在sizeof含义下，引用的大小是引用类型的大小，而地址的指针大小始终是地址空间所占字节大小的个数（64位平台下是8个字节，32位平台下是4个字节）；
6.引用自加则引用的实体增加1，指针自加，即指针向后偏移一个类型的大小，
7.有多级指针，没有多级引用；
8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理；
9. 引用比指针使用起来相对更安全。
6、内联函数
以inline修饰的函数是内联函数，编译器会在调用内联函数的地方展开，没有函数栈帧的开辟，提升程序运行的效率， Add就是内联函数；
特性;
1.inline是一种空间换时间的做法，如果编译器将内联函数当一个函数体处理，减少了函数的调用，提高程序效率，但会使目标文件变大；
2. inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建
议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。下图为
《C++prime》第五版关于inline的建议：
3.Inline不建议声明和定义分离，分离会导致链接错误，因为inline被展开就没有函数地址了，链接就会找不到。
// F.h #include <iostream> using namespace std; inline void f(int i); // F.cpp #include "F.h" void f(int i) { cout << i << endl; } // main.cpp #include "F.h" int main() { f(10); return 0; } // 链接错误：main.obj : error LNK2019: 无法解析的外部符号 "void __cdecl f(int)" (?f@@YAXH@Z)，该符号在函数 _main 中被引用
7、auto关键字（C++11）
auto可以自动识别变量的类型，auto声明的变量由编译器编译得知，方便了使用者，使用auto变量时一定要初始化，在编译阶段编译器会根据初始化类型来推导auto的实际类型。因此auto并不是一种“类型”的声明，而是一个类型声明的“占位符”，编译时auto会被替换成变量实际的类型。
假设我们定义一个函数指针
void func(int a,int b) int main() { void(*pf1)(int,int)=func; auto pf2=func; cout<<typeid(pf1).name()<<endl; cout<<typeid(pf2).name()<<endl; }
这段代码中，pf1和pf2是等价的，都是函数指针，我们可以用typeid来查看pf1和pf2的类型
他们类型是相同的。
typedef的用法：
typedef char* pstring; int main() { const pstring p1; // 编译成功还是失败？ const pstring* p2; // 编译成功还是失败？ return 0; }
auto与指针和引用结合起来使用：
1.用auto声明指针类型时用auto和auto*没有任何区别，但是声明引用类型时必须加&；
2.在同一行定义多个变量时，变量类型要一致，否则会报错；
3.auto不能直接作为函数的参数，也不能直接用来声明数组；
4. auto在实际中最常见的优势用法就是跟以后会讲到的C++11提供的新式for循环，还有
lambda表达式等进行配合使用。
8、基于范围的for循环（C++11）
for循环后面的括号有冒号“：”分为两部分，第一部分是范围内用于迭代的变量，第二部分用于被迭代的范围。
范围for的使用条件：
1.for循环迭代的范围必须是确定的；对数组而言，就是数组的第一个元素和最后一个元素，对于类而言，应该提供 begin和end的方法，begin和end就是for循环迭代的范围。
以后会慢慢了解，这里简单了解一下。
9. 指针空值nullptr(C++11)
NULL其实是一个宏，在传统的C头文件中(stdio.h)，我们可以看到以下代码：
#ifndef NULL #ifdef __cplusplus #define NULL 0 #else #define NULL ((void *)0) #endif #endif
可以看到，NULL可能被定义成字面常量0，或者被定义成无类型指针(void*)的常量，在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void*)常量，但是编译器 默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void *)0。
注意：
1. 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入 的；
2. 在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同；
3. 为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。
