C++快速入门

C++快速入门

一、命名空间

1.初始C++

​ 先简单认识一下C++，依然从Hello World开始

从上图代码中发现有三个不同之处：

1. C++所包的头文件：# include<iostream>；这里 i 表示输入、o表示输出、stream表示流；即输入输出流
2. using namespace std；这个就是命名空间了，有了这段代码，才可以使用cout、cin这些C++库函数（即打印和输入）,这里简单认个脸熟就行；
3. 相比C语言C++打印函数就和C语言有所不同了，当然C++是为了解决C的某些方面不足，是一个升级版，它是兼容C的，所以在C++中使用printf也是完全可以的；

2.概念

​ 在C/C++中，函数和后面的类都是大量存在的，这些变量、函数和类的名称都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是 对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的；

​ 从上图的代码中可以看出，（图b）我们定义了一个全局变量的rand这个是C语言的库函数，当在C的代码中包含了#include<stdlib.h>时，并进行调试时，系统提示“重定义”；（图a）是C++的代码，也存在同样的问题；这里就表明自己定义的变量名于库函数的函数名发生了冲突导致的，我们把这种叫做“命名冲突或名字污染”；在C++为了解决C语言在这方面的缺陷对其进行了改进，增加了一个叫做“命名空间”的使用；命名冲突通常有以下几种：

1. 我们的代码跟库的冲突
2. 我们互相之间的冲突

3.命名空间的定义

​ 定义命名空间，需要使用namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。

1.普通的命名空间

//定义了一个命名空间--定义的是一个域
//域有好几种：类域，命名空间域，局部域，全局域
//对命名空间域展开就暴露在了全局，不可以重复
namespace mlxg {
	int rand = 0;
   	//rand还是属于全局的变量，放到静态区的；这里不能进行复制操作
}
int a = 0;
int main(){
	int a = 1;
	printf("Hello World\n");
	printf("%d\n", mlxg::rand);
    //::这个符号叫作--域作用限定符号 表达的意思是这个rand去取左边域里面的
	printf("%d\n", a);
	printf("%d\n", ::a);
    //全局域找a；::的左边为空代表全局域
	return 0;
}

​ 上面的代码中，我们定义了变量，分别为a、rand、它们都属于全局变量；并且rand是放在了一个名为mlxg的域中的，rand就是mlxg域中的一个成员变量；

​ 当我们想要打印出这个rand的值时，并不是直接去打印的，如果按照普通的打印格式，还是一样出现“重定义”；这个时候就需要用到它“：：”——域限定符，比如说，你定义了很多个域，就想打印某个域中的某个变量的值时，使用方法：mlxg::rand（告诉编译器你去mlxg的那个域中去找rand，不要去别的地方了）；如果你写成::rand表面左边的域是空白，编译器就默认去全局域中找这个rand了；除此之外，我们就只能通过展开命名空间域才能访问。

2.命名空间的嵌套

namespace mlxg {	
//命名空间还可以定义变量/函数/类型
	int rand = 0; 
	int Add(int left, int right){
		return left + right;
	}
	struct Node{
		struct Node* next;
		int val;
	}; 
    //嵌套
	namespace mlxg1{	
		int rand = 100;
		int Sub(int left, int right){
			return left + right;
		}
		struct Node{
			struct Node* next;
			int val;
		};
	}//可以不断的嵌套
}
//使用
int main(){ 
	//把mlxg域中的rand赋值为10
    mlxg::rand = 10;
    //创建一个mlxg域中的名Node的结构体的一个变量；注意这里的域名要写在结构体的后面
	struct mlxg::Node node;
    //这里是调用mlxg域中的Add函数
	mlxg::Add(1, 2);
    //打印mlxg域中的mlxg1域中的rand的值，其结果为100
	printf("%d\n", mlxg::mlxg1::rand);
	return 0;
}

​ 从上述的代码中可以看出命名空间的成员变量可以是变量、函数、类型和嵌套一个域，就像是无限套娃；这里要注意的就是主函数中的赋值，定义结构体变量、打印时的使用方法。

3.命名空间的重名问题

​ 定义变量存在同名，那么在命名空间就不可能重名了吗？答案是肯定会重名的，如果定义了很多很多个命名空间，难免会有重名的存在，但是编译器会将重名的命名空间整合到一起，不同文件内的命名空间在合并的时候也会归并到一个命名空间中。

​ 强调：一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中，直接展开会有风险，我们定义如果跟库重名，就报错了。建议项目里面不要去展开，只有日常练习这么用。

3.命名空间的展开

​ 全部展开不推荐，如果想要方便一点可以使用下面的部分展开。

//展开部分,只展开常用的函数，从而提升开发效率
using std::cout;
using std::endl;

二、C++的输入&输出

​ 输入——cin；输出——cout，使用cout标准输出（控制台）和cin标准输入（键盘）时，必须包含 头文件以及std标准命名空间。

#include <iostream>
using namespace std::cin;
using namespace std::cout;
int main() {
	int i = 0;
	int i1 = 0; 
    //C++
	cin >> i;//流提取
	cout << i << endl;//流插入 
	//C
    scanf("%d", &i1);
	printf("%d", i1);
	return 0;
}

​ 上述代码中：<< ——流插入运算符；>>——流提取运算符；endl——换行；C++和C语言的比较：
​ C语言在给变量输入时需要%d和&（取地址），打印时需要%d，也就是定义的是什么类型就需要相应的打印格式；浮点型——%f、字符型——%c、地址——%p；
​ C++在给变量输入时、就很形象，没有那么麻烦，打印数据时也不需要相应的格式，因为C++会自动识别类型；但是C++的输入输出没有C语言的快。因为C++的IO流要兼容C语言，C++的缓冲区要兼容和同步C语言的缓冲区，如果在cout前有printf，那么C++需要先把C语言缓冲区的内容刷掉才能进行自己的输出，所以会运行的比较慢。

三、缺省参数

​ 缺省参数是声明或定义函数时为函数的参数指定一个默认值。在调用该函数时，如果没有指定实参则采用该默认值，否则使用指定的实参

1.全缺省参数

下面的代码中，Func函数采用的就是全缺省；在传参的过程中需要注意：

1. 可以无参数传——Func()；表明这个函数里的a/b/c就是默认值是10/20/30；

2. 可以传一个或多个参数

   Func（1）——a使用指定的1；b、c使用默认值

   Func（1，2）——a使用指定的1；b使用指定的2；c使用默认值

   Func（1，2，3）——a使用指定的1；b使用指定的2；c使用指定的3

void Func(int a = 10, int b = 20, int c = 30){
	cout << "a=" << a << endl;
	cout << "b=" << a << endl;
	cout << "c=" << a << endl << endl;
}
int main(){
	Func();
	Func(1);
	Func(1, 2);
	Func(1, 2, 3);
	return 0;
}

2.半缺省参数

下面的代码中，Func函数采用的就是半缺省，在传参的过程中需要注意：

1. 不可以无参传——Fun（）；
2. 不能间隔传——Func（1，，2）；
3. 必须从左向右依次传；从右往左缺省；

void Func(int a , int b , int c = 30){
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;
	cout << "c=" << c << endl << endl;
}
int main(){
    //Func();不可无参传，指定不明确
	Func(1, 2);
    //Func(1, ,3);不能间隔着传参
	Func(1, 2, 3);
	return 0;
}

3.缺省参数的用途

//减少数据结构初始化时扩容的消耗
void StackInit(struct Stack* pst,int defaultCapacity=4){
    pst->a=(int*)malloc(sizeof(int)*defaultCapacity);
    if(pst->a==NULL){
        perror("malloc fail");
        return;
    }
    pst->top=0;
    pst->capacity=defaultCapacity;
}
int main(){
    struct Stack st1;
    //需要插入100个数据
    StackInit(&st1,100);
}

4.缺省参数的注意点

1. 半缺省参数必须是从右往左依次来给出，不能间隔着给；

2. 缺省参数不能在函数声明和定义中同时出现

//错误的方式-声明和定义同时给缺省值，最怕的就是声明和定义的时候缺省值不一致
//Stack.h——声明
void StackInit(struct Stack* ps, int capacity = 4);
//Stack.c——定义
void StackInit(struct Stack* ps, int capacity = 4) {}

//正确的方式-只在声明的时候给缺省值
//Stack.h——声明
void StackInit(struct Stack* ps, int capacity = 4); 
//Stack.c——定义
void StackInit(struct Stack* ps, int capacity){}

​ 应该是声明的时候给，预处理是头文件展开，编译的时候不会合并，链接的时候才会合到一起，编译阶段我是只能看到声明的，我看不到定义。如果声明的时候不给缺省，那么编译器会认为调用该函数时必须要传入两个参数！否则就会报错。

3. 缺省值必须是常量或者全局变量

4. C语言不支持（编译器不支持）

四、函数重载

​ 自然语言中，一个词可以有多重含义，人们可以通过上下文来判断该词真实的含义，即该次被重载了。比如：以前有一个笑话，我国有两个体育项目大家根本不用看，也不用担心。一个是乒乓球，一个是男足。前者是“谁也赢不了！”，后者是“谁也赢不了！”

1.函数重载的原则

​ 函数重载：是函数的一种特殊情况，C++允许在同一作用域声明几个功能类似的同名函数，这些同名函数的形参列表（参数个数 或 类型 或 顺序）必须不同，常用来处理实现功能类似数据类型不同的问题；

//1.函数的类型不同
int Add(int left, int right){ //类型——int
	cout<<"int Add(int left, int right)"<<endl;
	return left + right;
}
double Add(double left, double right) {//类型——double
	cout << "double Add(double left, double right)" << endl;
	return left + right;
}

//函数的参数个数不同
void f() { //无参
	cout << "f()" << endl;
}
void f(int a) {//一个参数
	cout << "f(int a)" << endl;
}

//参数顺序不同
void f(int a, char b) {
	cout << "f(int a,char b)" << endl;
}
int main() { 
    //1.函数的类型不同
	Add(1, 2); Add(1.1, 2.2);
    //2.函数的参数个数不同
    f(); f(1);
    //3.虽然只有一个函数，但是参数的顺序发生变化，依然构成函数重载
	f(10, 'A'); f('A', 10);
	return 0;
}

2.以下的函数不能构成函数重载

1.返回值不同的函数

//仅返回值不同
short Add(short left, short right) {
	return left + right;
}
int Add(short left, short right) {
	return left + right;
}

2.缺省值不同的函数

//缺省值不同，有or没有
void f(int a){
	cout << "f()" << endl;
}
void f(int a = 0){
	cout << "f(int a)" << endl;
}

3.传参调用问题

​ 虽然构成重载，但使用时会出现问题，f()；调用不明确，存在歧义

void f(){
	cout << "f()" << endl;
}
void f(int a = 0){
	cout << "f(int a)" << endl;
}
int main(){
	f();//调谁呢？
	f(1);
	return 0;
}

3.函数重载的原理

​ C++中支持了函数重载，而C语言是不支持的；究其原因，在函数调用的时候，C++编译器对函数名的修饰规则和C语言编译器是存在差异的；由于在VS编译器下很难看出C++和C的区别；这里我们利用Linux进行演示；
以下面的代码为例：

void f(){
	cout << "f()" << endl;
}
void f(int a){
	cout << "f(int a)" << endl;
}

​ 如下图所示为Linux的反汇编，第一个f()函数命名为==_Z1fv==；第二个f(int a)函数命名为 _Z1fi;
​ _Z：表示前缀
​ 1：表示函数名的长度
​ f：表示函数名
​ i：参数为int类型（取首字母）
​ v：参数为void类型（取首字母）

​ 以下是C的反汇编

​ 结合两种编译器下的函数名修饰规则可以看出；
C++的函数名修饰风格：_Z + 函数名长度 + 函数名 + 参数类型的首字母；
C语言的函数名修饰风格：直接就是函数名；
​ 在简单的了解了函数名修饰规则后，回想一下程序编译链接的过程：

1. 预处理：头文件展开，宏替换，条件编译，去掉注释，预处理结束后.h就都展开了，生成.i文件
2. 编译：检查语法，生成汇编代码.i文件生成.s文件（生成汇编代码，指令级代码），但是汇编指令我们基本可以看懂(都是符号)，但是机器只识别二进制的机器码
3. 汇编：汇编代码转成二进制机器码 .o文件，生成符号表
4. 链接：生成可执行程序：xxx.exe/a.out 只有生成可执行程序的时候各个.o文件之间才会合作一把

​ 我们在编译的时候是拿不到函数的地址的，因为.h里面只有声明【没定义的化没有确定的地址，只是一个承诺但还没有实现】，没有地址，但是可以编译过去，在汇编的时候生成符号表，然后在链接的时候通过函数名修饰规则去符号表中寻找函数的地址【声明和定义未分离就不需要这个操作】。通过编译链接的分析，C++支持函数重载，C语言不支持函数重载，原因就算函数名的修饰风格不同；

五、引用

​ 引用不是新定义一个变量，而是给已存在的变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间

1.引用的定义

int main() {
	int a = 10;
	int& b = a;//--定义引用类型
	//引用在语法层，我们要理解这里没有开新的空间，就是对原来的取了一个新的称叫做b
	//int* p = &b;//--这里是取地址b
	a = 20;
	b = 30;
	//a改变了，b也会改变；b改变了，a也会改变
	return 0;
}

2.引用的特性

int main(){
	//1.引用在定义的时候必须初始化
	int a = 10;
	int& b;//---未初始化
    
	//2.一个变量可以有多个引用，类似于一个人可以有多个外号
	int a = 10;
	int& b = a;
	int& c = a;
	int& d = b;
    
	//3.引用一旦引用了一个实体，再不能引用其他实体了
	int a = 10;
	int& b = a;
	int c = 20;
	//1.这里是让b变成c的别名呢？否
	//2.还是把c赋值给b呢？  是
	b = c;
	return 0;
}

3.常引用

int main() {
	//1.权限放大----不可以
	//const int a = 10;
	//int& b = a;//错误
    
	//2.权限不变----可以
	const int a = 10;
	const int& b = a;
    
	//3.权限的缩小----可以
	int c = 10;
	const int& d = c;//缩小的是d作为别名的权限
    c++;//还是可以的
    
    //4.权限的平移
    const int& m=10;
	
    //5.
    double d =11.11;
    //int& a = d;这是错误的
    const int& a = d;//正确
	return 0;
}

​ 第五种情况的解释，

//临时变量返回的场景
//场景1
int func1(){
    static int x=0;
    return x;//返回的临时变量，临时变量具有常性
}
int main(){
    int& ret1=func1();//不可以，权限放大
    const int& ret2=func1();//可以，权限平移
    return 0;
}
//场景2
int& func2(){
    static int x=0;
    return x;
}
int main(){
    int& ret2=func2();//权限平移
    const int& ret2=func2();//权限缩小
    return 0;
}

4.使用场景

1.引用作参数

//引用作参数,输出型参数

//传地址
void swap(int* p1, int* p2){
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
//传引用,支持值交换,指针交换等
void swap(int& r1, int& r2){
	int tmp = r1;
	r1 = r2; 
	r2 = tmp;
}
//传值
void swap(int r1, int r2){
	int tmp = r1;
	r1 = r2;
	r2 = tmp;
}
//他们三个构成函数重载，他们类型不同，但是swap(x, y);调用时存在歧义，不知道调用传值还是传引用
int main(){
	int x = 0, y = 1;
	swap(&x, &y);
	//swap(x, y);
	return 0;
}

​ 回顾下我们之前写数据结构的时候，可以看到我们使用引用做参数的方便之处。

typedef struct ListNode{
    int val;
    struct ListNode* next;
    ListNode* next;//C++可以用类名做类型
}LTNode,*PLTNode;

//C语言
void ListPushBack(struct ListNode** phead,int x){}
//C++
void ListPushBack(struct ListNode *& phead,int x){}
void ListPushBack(LTNode*& phead,int x){}
void ListPushBack(PLTNode& phead,int x){}

​ 还有就是引用传参相比传值传参，效率更高，更快，涉及深浅拷贝

struct A{int a[10000];}//一个很大的类
void TestFunc1(A a){}
void TestFunc2(A& a){}//提高效率

void TestRefAndValue(){
    A a;
    //以值作为函数参数
    size_t begin1=clock();
    for(size_t i=0;i<10000;i++)
        TestFunc1(a);
    size_t end1=clock();
    //以引用作为函数参数
    size_t begin2=clock();
    for(size_t i=0;i<10000;i++)
        TestFunc2(a);
    size_t end2=clock();
}

2.引用作返回值

​ 如果函数返回时，出了函数作用域，如果返回对象还未还给系统，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。

//引用作返回值
int Add1(int a, int b){
	int c = a + b;
	return c;
   	//不管c是正常变量还是静态变量都会先生成临时变量
}
int& Add2(int a, int b){
	int c = a + b;
	return c;
    //不会生成临时变量
}
int main(){
	int x = 0, y = 1;
	int ret1 = Add1(1, 2);//3？
	int& ret2 = Add2(1, 2);//3？
	cout << ret1 << endl;
	cout << ret2 << endl;
	return 0;
}

​ 出了作用域，生成一个临时变量，函数的返回结果拷贝给临时变量，再通过临时变量返回拷贝给主函数。

​ 引用还有一张常见的用法就是通过返回值修改：

struct SeqList{
    int a[100];
    size_t n=100;
}
//这一个函数就实现了查找和修改两个功能
int& SLAt(SeqList* ps,int pos){
    assert(pos<100 && pos>=0);
    return ps->a[pos];//具有既读又写功能
}
int& SLAt(SeqList& ps,int pos){
    assert(pos<100 && pos>=0);
    return ps.a[pos];
}

//C++的玩法
struct SeqList{
    int a[100];
    size_t size;    
    //半成品
    int& at(int pos){
        assert(pos>=0 && pos<100);
        return a[pos];
    }
    //正宗
    int& operator[](int pos){
        assert(pos>=0 && pos<100);
        return a[pos];
    }
};
//本质都是引用返回
int main(){
    SeqList s;
    //半成品
    s.at(0)=0;
    s.at(0)++;
    cout<<s.at(0)<<endl;
    //正宗 类比vector
    s[1]=10;
    s[1]++;
    cout<<s[1]<<endl;
    return 0;
}

​ 总结：

1. 基本任何场景都可以用引用传参。

2. 谨慎用引用做返回值。出了函数作用域，对象不在了，就不能用引用返回，还在就可以用引用返回。
   

3. 常见的可以用引用返回的情况：全局变量，静态变量，malloc出来的堆上面的空间

4. 引用的底层【汇编角度】是指针

   

5.指针和引用的区别

1. 引用在定义时必须初始化，指针没有要求
2. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
3. 没有NULL引用，但有NULL指针
4. 在sizeof中含义不同：引用结果为引用引用类型的大小，但指针始终是地址空间所占字节个数（32位平台下占4个字节）
5. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
6. 有多级指针，但是没有多级引用
7. 访问实体方式不同，指针需要显示解引用，引用编译器自己处理
8. 引用比指针使用起来相对更安全

六、内联函数

​ 以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压栈的开销，内联函数提升程序运行的效率。

inline int Add(int x, int y) {//在函数前面加上inline
	int ret = x + y;
	return ret;
}
int main(){
	int ret = Add(2, 3);
	return 0;
}

上述代码的Add函数还可以用宏来替换

#define Add(x,y) ((x)+(y))
int main(){
	int ret = Add(2, 3);
	return 0;
}

​ 如果使用宏来替换函数的话，宏是非常复杂的，如果控制不好括号，容易造成错误；
​ 但内联也不是万能的，如果Add函数调用1000次的话，如果函数不展开，是1010行代码，如果函数按照inline展开的化，是10*1000行代码，会导致可执行程序变大。那么栈的开销就比较大；一般建议调用不频繁的函数可以设置成内联。

特性：

1. inline是一种以空间换时间的做法，省去调用函数的开销。所以代码很长或者有循环/递归的函数不适宜使用作为内联函数。
2. inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等等，编译器优化时会忽略掉内联。而且在debug程序下内联函数不会起作用，否则就影响调试了。
3. inline不建议声明和定义分离，分离会导致链接错误（编译过了但是链接不上）。因为inline被展开，就没有函数地址了，链接就会找不到，所以内联函数不要分离，直接定义在.h文件中，这样在声明的时候就有定义了，没有地址不会进符号表。

七、auto关键字

​ 在C++中它具有自动识别类型的功能；用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&；

int main() {
	int a = 0;
	int b = 0;
	//自动推荐类型
	auto c = a;
	auto d = 'a';
	auto e = 10.11;
	//typeid打印变量的类型
	cout << typeid(c).name() << endl;
	cout << typeid(d).name() << endl;
	cout << typeid(e).name() << endl;
    
	//实际中我们不会向上面那样去用auto
	//实际中使用场景
	std::map<std::string, std::string>dict = { {"sort","排序"}, { "insert","插入" } };
	std::map<std::string, std::string>::iterator it = dict.begin();
	//根据右边的值自动推到it的类型，写起来就方便了
	auto it = dict.begin();

	int x = 10;
	auto a = &x;//int*
	auto* b = &x; //int*
	auto& c = x;//int----声明引用类型是需要加&
	*a = 20;
	*b = 30;
	 c = 40;
	return 0;
}
/*那些很长的代码不理解对auto的理解没有任何影响*/

1.auto不能做参数，不能定义数组

//不可以作参数
void test(auto a){

}
int main() {
	int a[] = { 1,2,3 };
	auto b[] = { 1,2,3 };//不可以定义数组
	return 0;
}

2.范围for的使用

/* void TestFor(int a[]) {
	//范围for必须是数组名 这里的a不是数组名，是指针了
	for (auto& e : a) {
		cout << e << endl;
	}
} */
int main() {
	//语法糖 -- 范围for
	int array[] = { 1,2,3,4,5 };
	//TestFor(array);
	//C遍历数组
	for (int i = 0; i < sizeof(array) / sizeof(int); i++) {
		cout << array[i]<<" ";
	}
	cout << endl;
    
	//C++遍历数组,自动依次取数组array中的每个元素赋值给e
	for (auto e : array) { //e是名称，可以随便取名
		cout << e << " ";
	}
	cout << endl;
	for (int x : array) {//也可以把类型定义好，也是范围for
		cout << x << " ";
	}
	cout << endl;
    
	//用范围for把数组每个值+1，修改
	for (auto& e : array){
		e++;
	}
	for (auto e : array){
		cout << e << " ";
	}
	cout << endl;
	return 0;
}

八、指针空值

​ 在C语言中NULL表示空指针，在C++中空指针改为了nullptr；因为NULL和0本质是一个意思，放到C++中就会存在歧义；看下面的代码演示

void f(int) {
	cout << "f(int)" << endl;
}
void f(int*) {
	cout << "f(int*)" << endl;
}
int main() {
	//C++98/03
	int* p1 = NULL;
	int* p2 = 0;
	//C++11
	int* p3 = nullptr;
	f(NULL);//f(int)
	f(0);//f(int)
    
	f(nullptr);//f(int*)
	return 0;
}

​ 我们的本意是参数为0是想打印出f(int)；参数为NULL时，打印出f(int*)但是结果却是一样的，这就很好说明了，C++在0和NULL的处理是存在歧义的；注意：

1. 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。
2. 在C++11中，sizeof(nullptr)与sizeof( (void*) 0 ) 所占的字节数相同。
3. 为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。