0. 前言
C++是在C的基础之上，容纳进去了面向对象编程思想，并增加了许多有用的库，以及编程范式等。熟悉C语言之后，对C++学习有一定的帮助
1. C++关键字(C++98)
C++总计63个关键字，C语言32个关键字
2. 命名空间
在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。
#include <stdio.h>
#include <stdlib.h>
int rand = 10;
// C语言没办法解决类似这样的命名冲突问题，所以C++提出了namespace来解决
int main()
{
printf("%d\n", rand);
return 0;
}
// 编译后后报错：error C2365: “rand”: 重定义；以前的定义是“函数”将变量定义在命名空间中即可,命名空间可以定义变量/函数/类型
#include <stdio.h>
#include <stdlib.h>
namespace test
{
int rand = 10;
}
int main()
{
printf("%p\n", rand);
//域作用限定符 ::
printf("%d\n", test::rand);
return 0;
}
命名空间定义
定义命名空间，需要使用到namespace关键字，后面加命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。
//1. 正常的命名空间定义
namespace test
{
// 命名空间中可以定义变量/函数/类型
int rand = 10;
int Add(int left, int right)
{
return left + right;
}
struct Node
{
struct Node* next;
int val;
};
}2. 命名空间可以嵌套
// test.cpp
#include<stdio.h>
#include<stdlib.h>
namespace N1
{
int rand = 0;
int Add(int left, int right)
{
return left + right;
}
namespace N2
{
int rand = 10;
int Sub(int left, int right)
{
return left - right;
}
}
}
int main()
{
printf(%p\n, rand);//一个地址
printf(%d\n, N1::rand);//0
printf("%d\n", N1::N2::rand);//10
return 0;
}3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。
// ps：一个工程中的test.h和上面test.cpp中两个N1会被合并成一个
// test.h
namespace N1
{
int Mul(int left, int right)
{
return left * right;
}
}
//test.cpp
namespace N1
{
int rand = 0;
int Add(int left, int right)
{
return left + right;
}
namespace N2
{
int rand = 10;
int Sub(int left, int right)
{
return left - right;
}
}
}注意：一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中
命名空间使用
namespace test
{
// 命名空间中可以定义变量/函数/类型
int a = 0;
int b = 1;
int Add(int left, int right)
{
return left + right;
}
struct Node
{
struct Node* next;
int val;
};
}
int main()
{
// 编译报错：error C2065: “a”: 未声明的标识符
printf("%d\n", a);//因为默认在全局中搜索
return 0;
}命名空间的使用有三种方式：
1.直接指定：加命名空间名称及作用域限定符::
namespace test
{
// 命名空间中可以定义变量/函数/类型
int a = 0;
int b = 1;
int Add(int left, int right)
{
return left + right;
}
struct Node
{
struct Node* next;
int val;
};
}
namespace N1
{
int a;
int b;
int Add(int left, int right)
{
return left + right;
}
namespace N2
{
int c;
int d;
int Sub(int left, int right)
{
return left - right;
}
}
}
int Add(int left, int right)
{
return (left + right)*2;
}
int main()
{
printf("%d\n", test::a);
printf("%d\n", test::Add(1,2));//结果为3
printf("%d\n", Add(1,2));//结果为6,并不会和test命名空间内的Add冲突
struct test::Node node;//结构体不要在struct前使用作用域限定符
printf("%d\n", N1::N2::Sub(1,2));
return 0;
}2.部分展开：使用using将命名空间中某个成员引入
#include <stdlib.h>
#include <stdio.h>
namespace test
{
// 命名空间中可以定义变量/函数/类型
int a = 0;
int b = 1;
int Add(int left, int right)
{
return left + right;
}
struct Node
{
struct Node* next;
int val;
};
}
using test::Add;
int main()
{
printf("%p\n", rand);//优先去全局搜索,在stdlib中找到
printf("%d\n", Add(1,2));//test命名空间部分展开，可以不加::
printf("%d\n", test::a);//访问未展开的变量，需要加::
return 0;
}3.全部展开：使用using namespace 命名空间名称引入 ，大型项目建议不要全部展开，很可能出现命名空间冲突。
namespace test
{
// 命名空间中可以定义变量/函数/类型
int a = 0;
int b = 1;
int Add(int left, int right)
{
return left + right;
}
struct Node
{
struct Node* next;
int val;
};
}
using namespce test;
int main()
{
printf("%d\n", a);
printf("%d\n", b);
printf("%d\n, Add(10, 20)");
struct Node node;
return 0;
}3.C++输入&输出
#include<iostream>
//这一行是干什么的?
// std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中
//将std全部展开
using namespace std;
int main()
{
cout<<"Hello world!!!"<<endl;
return 0;
}#include<iostream>
//部分展开
using std::cout;
using std::endl;
int main()
{
cout<<"Hello world!!!"<<endl;
return 0;
}#include<iostream>
int main()
{
std::cout<<"Hello world!!!"<<endl;
return 0;
}1.可以直接将std全部展开
2.也可以部分展开cout、endl然后使用
3.cout和endl都是C++标准库中的，都在std命名空间中，所以可以直接用作用域限定符.
说明：
1. 使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含< iostream >头文件，以及按命名空间使用方法使用std。
2. cout和cin是全局的流对象，endl是特殊的C++符号，表示换行输出，他们都包含在包含<
iostream >头文件中。
3. <<是流插入运算符，>>是流提取运算符。
4. 使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动控制格式，C++的输入输出可以自动识别变量类型。
5. 实际上cout和cin分别是ostream和istream类型的对象。
注意：
早期标准库将所有功能在全局域中实现，声明在.h后缀的头文件中，使用时只需包含对应
头文件即可，后来将其实现在std命名空间下，为了和C头文件区分，也为了正确使用命名空间，规定C++头文件不带.h；旧编译器(vc 6.0)中还支持<iostream.h>格式，后续编译器已不支持，因此推荐使用<iostream>+std的方式。
#include <iostream>
using namespace std;
int main()
{
int a;
double b;
char c;
// 可以自动识别变量的类型
cin>>a;
cin>>b>>c;
cout<<a<<endl;
cout<<b<<" "<<c<<endl;
return 0;
}std命名空间的使用惯例：
std是C++标准库的命名空间，如何展开std使用更合理呢？
1. 在日常练习中，建议直接using namespace std即可，这样就很方便。
2. using namespace std展开，标准库就全部暴露出来了，如果我们定义跟库重名的类型/对
象/函数，就存在冲突问题。该问题在日常练习中很少出现，但是项目开发中代码较多、规模
大，就很容易出现。所以建议在项目开发中使用，像std::cout这样指定命名空间 或者
using std::cout展开常用的库对象/类型等方式。
4. 缺省参数
缺省参数概念
缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参。
void Func(int a = 0)
{
cout<<a<<endl;
}
int main()
{
Func(); // 没有传参时，使用参数的默认值
Func(10); // 传参时，使用指定的实参
return 0;
}缺省参数分类
全缺省参数
void Func(int a = 10, int b = 20, int c = 30)
{
cout<<"a = "<<a<<endl;
cout<<"b = "<<b<<endl;
cout<<"c = "<<c<<endl;
}
int main()
{
Func();
Func(1);
Func(1,2);
Func(1,2,3);
return 0;
}
半缺省参数
void Func(int a, int b = 10, int c = 20)
{
cout<<"a = "<<a<<endl;
cout<<"b = "<<b<<endl;
cout<<"c = "<<c<<endl;
}注意：
1. 半缺省参数必须从右往左依次来给出，不能间隔着给,下面两种参数都不可以
void Func(int a = 10, int b = 20, int c);void Func(int a = 10, int b, int c = 20);2. 缺省参数不能在函数声明和定义中同时出现
Stack.h
#include<stdlib.h>
namespace test
{
/*void StackInit()
{
cout << "void StackInit()" << endl;
} */
typedef struct Stack
{
int* a;
int top;
int capacity;
}ST;
// 不允许声明和定义同时给缺省参数
// 如果声明与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该用哪个缺省值。
// 声明给，定义不给
void StackInit(ST* ps, int N = 4);
void StackPush(ST* ps, int x);
}Stack.cpp
#include "Stack.h"
//缺省参数声明给，定义不给
void test::StackInit(ST* ps, int N)
{
ps->a = (int*)malloc(sizeof(int) * N);
ps->top = 0;
ps->capacity = 0;
}
void test::StackPush(ST* ps, int x)
{
// ...
}还需要额外注意，声明和定义要分离，因为定义函数名会进入符号表，声明不会。如果在头文件定义，在多个cpp文件中包含该头文件就相当于定义了同名函数，会出现链接错误。还有一种解决方式，如果要在头文件定义，将函数定义为静态函数改变链接属性，外部链接改为内部链接，只能在当前文件中使用。
3. 缺省值必须是常量或者全局变量
4. C语言不支持（编译器不支持）
5. 函数重载
函数重载概念
函数重载：是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同，常用来处理实现功能类似数据类型不同的问题。
1.参数类型不同
#include "F.h"
#include<iostream>
using namespace std;
// 1、参数类型不同
void Add(int left, int right)
{
cout << "int Add(int left, int right)" << endl;
cout<< left + right<<endl;
}
void Add(double left, double right)
{
cout << "double Add(double left, double right)" << endl;
cout<< left + right<<endl;
}
int main()
{
Add(1, 2);
cout << endl;
Add(1.1, 2.2);
return 0;
}
2.参数个数不同
// 2、参数个数不同
void f()
{
cout << "f()" << endl;
}
void f(int a)
{
cout << "f(int a)" << endl;
}
int main()
{
f();
f(1);
return 0;
}
3.参数类型顺序不同
// 3、参数类型顺序不同
void f(int a, char b)
{
cout << "f(int a,char b)" << endl;
}
void f(char b, int a)
{
cout << "f(char b, int a)" << endl;
}
int main()
{
f(1, 'a');
f('a', 1);
return 0;
}
注意：
1.这不是函数重载，只是形参名变化了
void f(int a, char b) { cout << "f(int a,char b)" << endl; } void f(int b, char a) { cout << "f(char b, int a)" << endl; }2.命名空间最后都会合并，这也是函数重载。
namespace test1 { void func(int x) {}; } namespace test1 { void func(double x) {}; }3.这构成函数重载,但调用可能会有歧义
// 构成函数重载 void func(int a) { cout << "void func(int a)" << endl; } void func(int a, int b = 1) { cout << "void func(int a, int b)" << endl; }
4.两个函数只有返回值不同不构成重载(下面会解释)
C++支持函数重载的原理--名字修饰(name Mangling)
为什么C++支持函数重载，而C语言不支持函数重载呢？
在C/C++中，一个程序要运行起来，需要经历以下几个阶段：预处理、编译、汇编、链接。
Test.cpp
//预处理头文件展开/宏替换/去掉注释/条件编译
Test.i
//编译检查语法，生成汇编代码(指令级代码)
Test.s
//汇编将汇编代码生成二进制机器码,形成符号表
Test.o
//链接合并链接，生成可执行程序a.out / xxx.exe
实际项目通常是由多个头文件和多个源文件构成，【当前a.cpp中调用了b.cpp中定义的Add函数时】，编译后链接前，a.o的目标文件中没有Add的函数地址，因为Add是在b.cpp中定义的，所以Add的地址在b.o中。所以链接阶段就是专门处理这种问题，链接器看到a.o调用Add，但是没有Add的地址，就会到b.o的符号表中找Add的地址，然后链接到一起。 那么链接时，面对Add函数，链接接器会使用哪个名字去找呢？这里每个编译器都有自己的函数名修饰规则。
由于Windows下VS的修饰规则过于复杂:
而Linux下g++的修饰规则简单易懂，下面我们使用了g++演示了这个修饰后的名字。
通过下面我们可以看出gcc的函数修饰后名字不变。而g++的函数修饰后变成【_Z+函数长度
+函数名+类型首字母】。
采用C语言编译器编译后结果:
结论：在linux下，采用gcc编译完成后，函数名字的修饰没有发生改变,所以同名函数无法区分，C语言也就不支持函数重载。
采用C++编译器编译后结果:
结论：在linux下，采用g++编译完成后，函数名字的修饰发生改变，编译器将函数参
数类型信息添加到修改后的名字中。
通过这里就理解了C语言没办法支持重载，因为同名函数没办法区分。而C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。
注意：如果两个函数函数名和参数是一样的，返回值不同是不构成重载的，因为调用时编译器没办法区分。
那么如果在函数修饰规则中加入返回值，能不能构成重载？
不能，假如返回值也用类型首字母修饰，假设修饰以后的函数名为<_Zi4funcdi>、<_Zv4funcdi>，在调用func(1,1,1)时也会发生歧义，所以不能构成重载。
补充：Windows下名字修饰规则
对比Linux会发现，windows下vs编译器对函数名字修饰规则相对复杂难懂，但道理都
是类似的。
6.引用
引用概念
引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
定义引用格式：类型& 引用变量名(对象名) = 引用实体；
注意：引用类型必须和引用实体是同种类型的
引用特性
1. 引用在定义时必须初始化,且非常量引用的初始化必须是左值。
void TestRef()
{
int a = 10;
// int& ra; // 该条语句编译时会出错
int& ra = a;
}2. 一个变量可以有多个引用
void TestRef()
{
int a = 10;
// int& ra; // 该条语句编译时会出错
int& ra = a;
int& rra = a;
printf("%p %p %p\n", &a, &ra, &rra);
}3. 引用一旦引用一个实体，再不能引用其他实体
void TestRef()
{
int a = 10;
int& ra = a;
int& rra = a;
int x = 1;
ra = x;//赋值,并不是改变引用指向。
//int& ra = x;//重定义
}
结论：CPP的引用不能改变指向，所以CPP不能完全脱离指针。
引用的使用场景
一. 做参数
1.二叉树前序遍历
C语言实现的代码
int TreeSize(struct TreeNode* root) { return root == NULL ? 0 : TreeSize(root->left)+TreeSize(root->right)+1; } int* preorderTraversal(struct TreeNode* root, int* returnSize){ *returnSize = TreeSize(root); int* ret = (int*)malloc((*returnSize)*sizeof(int)); int i = 0; _preorder(root,ret,&i); return ret; } void _preorder(struct TreeNode* root,int* a,int* pi) { if(root == NULL) return; a[(*pi)++] = root->val; _preorder(root->left,a,pi); _preorder(root->right,a,pi); }其中i要传地址并解引用访问，因为形参的改变改变不了实参。而现在传入引用之后：可以直接使用引用，不需要再传地址，解引用。
int TreeSize(struct TreeNode* root) { return root == NULL ? 0 : TreeSize(root->left)+TreeSize(root->right)+1; } int* preorderTraversal(struct TreeNode* root, int* returnSize){ *returnSize = TreeSize(root); int* ret = (int*)malloc((*returnSize)*sizeof(int)); int i = 0; _preorder(root,ret,i); return ret; } void _preorder(struct TreeNode* root,int* a,int& i) { if(root == NULL) return; a[i++] = root->val; _preorder(root->left,a,i); _preorder(root->right,a,i); }
2.交换函数
void Swap(int& x, int& y)
{
int temp = x;
x = y;
y = temp;
}
int main()
{
int a = 1;
int b = 2;
Swap(a,b);
cout << a << endl;
cout << b << endl;
return 0;
}3.链表
C语言代码
typedef struct ListNode{ int val; struct ListNode* next; }ListNode; //c语言需要传二级指针 void PushBack(ListNode** pphead, int x) { ListNode* newnode; if (*pphead == NULL) { *pphead = newnode; } else { } }CPP代码
typedef struct ListNode { int val; struct ListNode* next; }ListNode, *PListNode; //CPP使用引用 void PushBack(ListNode*& phead, int x)//传指针的引用 //void PushBack(PListNode& phead, int x)//先将指针typedef,再传引用 { ListNode* newnode = (ListNode*)malloc(sizeof(ListNode)); // ... if (phead == NULL) { phead = newnode; } else { } }
二、做返回值
例1：传值返回和传引用返回的错误示范
一个很简单的程序，main函数调用Count函数，返回值n赋给了变量ret。在这个过程中，Count函数返回的n是直接就赋给了ret吗？不是，为什么呢？因为n是Count函数中创建的一个局部变量，它是存在Count函数的栈帧里的，当函数调用结束，n随着Count函数的栈帧一起被销毁了。这里的销毁不是说这块空间不存在了，是归还给系统，我们就没有这块空间的使用权了。所以函数调用结束n这块空间的值不能直接赋给ret。
而空间在销毁之前，会产生一个临时变量，来保存要返回的n的值（当要返回的数据比较小的时候，这个临时变量通常是一个寄存器，比较大的时候就不一定是寄存器了）。就算调用结束，n被销毁了，我们也保留了返回值可以赋给main函数的ret。
//传引用返回
int& Count()
{
int n = 0;
n++;
return n;
}
int main()
{
int ret = Count();
// 这里打印的结果可能是1，也可能是随机值
cout << ret << endl;
}
这里直接把局部变量n赋值给了ret，虽然结果显示还是1，但是其结果是未定义的，也可能是随机值，取决于空间销毁后是不是置为随机值。
例2: 引用作返回值的错误示范
//x64环境
using std::cout;
using std::endl;
//传引用返回
char& Count()
{
char n = 'a';
n++;
//..
return n;
}
int main()
{
char& ret = Count();
cout << ret << endl;
cout << ret << endl;
cout << (int)ret << endl;
return 0;
}
第一次调用cout先取值，取值的时候ret的位置还没有被覆盖，ret正常打印出b。第二次调用cout时原来的b就已经被覆盖了，第二次打印的是第一次覆盖之后的结果，由于ASIIC码表没有对应的字符，所以什么也没有打印出来，第三次强转为int可以看到ret位置上的值，这次结果是第二次覆盖后的结果。
例3：引用作返回值的错误示范
//x86环境
int& Count()
{
int n = 0;
n++;
//..
return n;
}
int main()
{
int& ret = Count();
cout << ret << endl;
cout << ret << endl;
return 0;
}
第一次调用cout先取值，取值的时候ret的位置还没有被覆盖，ret正常打印出1。第二次调用cout时就已经被覆盖了，第二次打印的是第一次覆盖之后的结果，是随机值。
但如果在Count函数内先开辟一块大的空间，再定义n，n可能就不会被覆盖：
例4：引用作返回值的错误示范
第二次调用恰好上一次c的位置又修改成了7。
函数Add中的c是局部变量，是创建在函数栈帧上的，函数调用结束就随着函数栈帧销毁了（这块空间归还给操作系统了），但是main函数用引用来接收，现在ret是c的一个引用，就可以用ret去访问c这块空间的值了，但是这块空间已经归还给操作系统了，已经不属于我们了，此时我们再去访问其实已经是非法的行为了。
但是也看到也打印出来3，这是因为这块空间归还之后，操作系统有可能还没有去清理这块空间，所以我们再去拿还是拿到了原来算出来的3，那如果操作系统进行了一些处理，我们拿到什么可能就不知道了，可能就是随机值了。
就像我们后面又调用了一次，然后打印是7，后面又打印就是一个随机值了。
结论： 这里的打印出来的结果并不重要，可能在不同的编译器上，不同的平台上，就有所差异。这个结果是未定义的，因为这本身就是一种错误的，非法的行为。
重点是要明白这个程序是错误的，这种情况是不能返回引用的总结：如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用引用返回(比如：静态的、全局的、malloc的等等），如果已经还给系统了，则必须使用传值返回。
例4：引用作返回值的正确示范
#include<assert.h>
struct SeqList
{
int a[10];
int size;
};
//C的接口设计
//读取第i个位置的值
int SLAT(struct SeqList* ps, int i)
{
assert(i < ps->size);
// ...
return ps->a[i];
}
//修改第i个位置的值
void SLModify(struct SeqList* ps, int i, int x)
{
assert(i < ps->size);
// ...
ps->a[i] = x;
}
//CPP接口设计
//读 or 修改第i个位置的值
int& SLAT(struct SeqList& ps, int i)
{
assert(i < ps.size);
// ...
return (ps.a[i]);
}
nt main()
{
struct SeqList s;
s.size = 3;
//调用C语言接口
SLModify(&s, 0, 100);
SLModify(&s, 1, 200);
SLModify(&s, 2, 300);
cout << SLAT(s, 0) << endl;
cout << SLAT(s, 1) << endl;
cout << SLAT(s, 2) << endl;
//调用C++接口
SLAT(s, 0) = 10;
SLAT(s, 1) = 20;
SLAT(s, 2) = 30;
cout << SLAT(s, 0) << endl;
cout << SLAT(s, 1) << endl;
cout << SLAT(s, 2) << endl;
return 0;
}
可以看到C++用引用返回可以一个函数可以同时做到 修改和读取。
C++新增成员函数和运算符重载，可以更便捷地实现修改与访问：
//升级成了类
#define N 10
struct SeqList
{
// 成员函数
int& at(int i)
{
assert(i < N);
return a[i];
}
//运算符重载
int& operator[](int i)
{
assert(i < N);
return a[i];
}
// 成员变量
int a[N];
};
int main()
{
//struct SeqList s1; //也可以这样创建，兼容c的用法
SeqList s2;
for (size_t i = 0; i < N; i++)
{
s2[i] = i;
//等价于s2.at(i) = i;
//等价于s2.operator[](i) = i;
}
for (size_t i = 0; i < N; i++)
{
//cout << s2.at(i) << " ";
cout << s2[i] << " ";
}
cout << endl;
return 0;
}
传值、传引用效率比较
以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回值的一份临时拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。
值、引用作为函数参数类型的性能比较
#include <time.h>
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();
// 分别计算两个函数运行结束后的时间
cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}
int main()
{
TestRefAndValue();
return 0;
}
值和引用的作为返回值类型的性能比较
#include <time.h>
struct A { int a[10000]; };
A a;
// 值返回
A TestFunc1() { return a; }
// 引用返回
A& TestFunc2() { return a; }
void TestReturnByRefOrValue()
{
// 以值作为函数的返回值类型
size_t begin1 = clock();
for (size_t i = 0; i < 100000; ++i)
TestFunc1();
size_t end1 = clock();
// 以引用作为函数的返回值类型
size_t begin2 = clock();
for (size_t i = 0; i < 100000; ++i)
TestFunc2();
size_t end2 = clock();
// 计算两个函数运算完成之后的时间
cout << "TestFunc1 time:" << end1 - begin1 << endl;
cout << "TestFunc2 time:" << end2 - begin2 << endl;
}
int main()
{
TestReturnByRefOrValue();
return 0;
}
通过上述代码的比较，发现传值和传引用效率相差很大。
总结：
传引用传参(任何时候都可以用)
1、提高效率
2、输出型参数（形参的修改，影响实参，可以实现函数返回多个值的效果)
传引用返回(出了函数作用域对象还在才可以用)
1、提高效率
2、修改返回对象
常引用
常引用：
const引用不允许通过引用对所绑定的对象进行修改，它只能读取对象的值，不允许修改。试图通过const引用修改对象的值将导致编译错误。
当一个引用被声明为const时，它表示引用的值是只读的，不能通过该引用修改所引用的对象。这意味着编译器会在编译期间强制执行这个规则，确保我们不会通过该引用修改对象的值。因此，const修饰的引用可以绑定到不同类型的数据，并且允许接收临时对象，因为我们不能通过该引用来修改这些数据的值，只能读取。它允许类型之间的隐式转换，包括常规类型转换和用户定义的类型转换。这是因为const引用只用于读取对象的值，不会修改对象，所以允许在一定程度上放宽类型匹配的要求。
double a = 0;
const int& b = a;举个例子：假设有一个const引用类型为const int&，但我们试图将其绑定到一个double类型的变量。由于存在从double到int的隐式转换，编译器会允许这种隐式转换并将double类型的值转换为int类型，然后将其绑定到const int&引用。
需要注意的是，虽然const修饰的引用允许隐式转换，但这并不意味着它可以绑定到任何类型，仍然需要满足基本的类型兼容性规则。所谓的兼容性规则指的是 a = b 这个操作行得通，例如系统基础的数据类型 int、double、char 等之间都可以，但如果是两个类或者结构体的话需要有对应的operator=才可以。
非常量引用：
先简单认识一下左值和右值：
左值（L-value）：左值是指具有标识符的表达式，或者是可以取地址的表达式。左值可以出现在赋值操作的左侧和右侧，表示一个具体的存储位置或对象。
右值（R-value）：右值是指不能取地址的表达式，或者是临时的、即将销毁的值。右值只能出现在赋值操作的右侧。
非const修饰的引用可以修改所引用对象的值，通过非const引用，可以修改对象的值，包括赋予新值、修改成员等。所以，非const引用的类型必须与所引用对象的类型完全匹配。否则，会导致编译错误。并且，非const引用的初始值必须为左值。这是为了确保引用的有效性、避免悬空引用、防止意外的修改。
悬空引用： 当一个引用被绑定到一个左值时，它将引用该左值所代表的具体对象或存储位置。这意味着引用可以安全地访问和修改所绑定的对象。但是，如果引用被绑定到一个右值（例如临时值、临时对象、表达式的结果、函数的临时返回值等），当该右值超出范围并被销毁后，引用将变成悬空引用。悬空引用指向一个不再存在的对象，使用它可能导致一种很危险的未定义行为。所以为了避免这种情况，C++要求非常量引用的初始值必须是左值，以确保引用绑定到持久性的对象上。
防止意外的修改： 因为非常量引用允许修改所绑定对象的值。所以如果允许非常量引用绑定到右值（临时对象），那么修改临时对象的值可能会导致不可预料的行为。由于右值可能在其他地方被共享或使那么允许修改它们可能会对程序的正确性和安全性产生负面影响。因此，C++限制了非常量引用的初始值必须是左值，以确保我们只能修改持久性的对象。
————————————————
版权声明：此段为CSDN博主「真-小白菜」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_73759312/article/details/131752635
int main()
{
const int a = 0;
//权限的放大 非const引用的类型必须和所引用的对象类型完全匹配
int& b = a;//错误，权限的放大
int b = a;//正确，这是赋值，b的改变对a没有影响
//const修饰的引用可以绑定到不同类型的数据，
//并且允许接收临时对象，因为我们不能通过该引用来修改这些数据的值，
//只能读取。它允许类型之间的隐式转换，包括常规类型转换和用户定义的类型转换。
//权限的平移
const int& c = a;
//权限的缩小
int x = 0;
const int& y = x;
//类型转换
double a = 0;
const int& b = a;
return 0;
}常引用接收临时变量：
int func()
{
int a;
return a;
}
int main()
{
//int& ret = func();//错误，临时变量具有常性
const int& ret = func();//正确
return 0;
}引用和指针的区别
在语法概念上引用就是一个别名，不会额外开辟空间，和其引用实体共用同一块空间。
看一段代码，用引用和指针来实现同样的效果：
int main()
{
int a = 10;
//引用
int& ra = a;
ra = 20;
//指针
int* pa = &a;
*pa = 20;
return 0;
}
可以看到，它们产生的汇编代码都是一样的。
引用和指针的不同点:
1. 概念上，引用定义一个变量的别名，指针存储一个变量地址。
2. 引用在定义时必须初始化，指针没有要求。
3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体。
4. 没有NULL引用，但有NULL指针。
5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小。
7. 有多级指针，但是没有多级引用。
8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理。
9. 引用比指针使用起来相对更安全。
7.内联函数
宏的优缺点？
优点：
1.增强代码的复用性。
2.提高性能。
缺点：
1.不方便调试宏。（因为预编译阶段进行了替换）
2.导致代码可读性差，可维护性差，容易误用。
3.没有类型安全的检查
概念
以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。
int Add(int x, int y)
{
return x + y;
}
int main()
{
int ret = 0;
ret = Add(1, 2);
return 0;
}
如果在上述函数前增加inline关键字将其改成内联函数，在编译期间编译器会用函数体替换函数的
调用。
查看方式：
1. 在release模式下，查看编译器生成的汇编代码中是否存在call Add
2. 在debug模式下，需要对编译器进行设置，否则不会展开(因为debug模式下，编译器默认不会对代码进行优化，以下给出vs2013的设置方式)
inline int Add(int x, int y)
{
return x + y;
}
int main()
{
int ret = 0;
ret = Add(1, 2);
return 0;
}
特性
1. inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会
用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。缺陷：可能会使目标文件变大，
优势：少了调用开销，提高程序运行效率。这里说的这个空间换时间，不是说程序运行时占用的空间会变大，而是最终产生的可执行程序可能会变大。
因为C++编译器会在调用内联函数的地方将函数直接展开，这样的话与普通的调用相比，产生的指令就可能变多，所以最终生成的可执行程序可能会变大。
2. inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建
议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不
是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略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 << "f(int i) "<< 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 中被引用正确写法：
// F.h #include <iostream> using namespace std; inline void f(int i) { cout << "f(int i) "<< i << endl; } // main.cpp #include "F.h" int main() { f(10); return 0; }
C++有哪些技术替代宏？
1. 常量定义 换用const enum
2. 短小函数定义 换用内联函数
8. auto关键字(C++11)
类型别名思考
随着程序越来越复杂，程序中用到的类型也越来越复杂，经常体现在：
1. 类型难于拼写
2. 含义不明确导致容易出错
auto简介
在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，但遗憾的是一直没有人去使用它。
C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。
int TestAuto()
{
return 10;
}
int main()
{
int a = 10;
auto b = a;
auto c = 'a';
auto d = TestAuto();
auto& e = a;
//typeid().name()可以查看类型
cout << typeid(b).name() << endl;
cout << typeid(c).name() << endl;
cout << typeid(d).name() << endl;
cout << typeid(e).name() << endl;
//auto f; 无法通过编译，使用auto定义变量时必须对其进行初始化
return 0;
}
使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型。
auto的使用细则
1.auto与指针和引用结合起来使用
用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&
int main()
{
int x = 10;
auto a = &x;
auto* b = &x;
auto& c = x;
cout << typeid(a).name() << endl;
cout << typeid(b).name() << endl;
cout << typeid(c).name() << endl;
*a = 20;
*b = 30;
c = 40;
return 0;
}
auto声明引用时，typeid对应的类型是引用的类型而不是引用。
2.在同一行定义多个变量
当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译
器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。
void TestAuto()
{
auto a = 1, b = 2;
auto c = 3, d = 4.0; // 该行代码会编译失败，因为c和d的初始化表达式类型不同
}auto不能推导的场景
1.auto不能作为函数的参数
// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
void TestAuto(auto a)
{}2.auto不能直接用来声明数组
void TestAuto()
{
int a[] = {1,2,3};
auto b[] = {4，5，6};
}3. 为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法。
4. auto在实际中最常见的优势用法就是和C++11提供的新式for循环，还有lambda表达式等进行配合使用。
9. 基于范围的for循环(C++11)
范围for的语法
在C++98中如果要遍历一个数组，可以按照以下方式进行：
void TestFor()
{
int array[] = { 1, 2, 3, 4, 5 };
for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
array[i] *= 2;
for (int* p = array; p < array + sizeof(array)/ sizeof(array[0]); ++p)
cout << *p << endl;
}对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。
void TestRangeFor()
{
int array[] = { 1,2,3,4,5 };
for (auto e : array)
{
e *= 2;
}
for (auto e : array)
{
cout << e << ' ';
}
cout << endl;
}
int main()
{
TestRangeFor();
return 0;
}
发现数组内的值并没有被修改。如果需要修改迭代的内容，需要auto&,不然修改的只是临时变量。
void TestRangeFor()
{
int array[] = { 1,2,3,4,5 };
for (auto& e : array)
{
e *= 2;
}
for (auto e : array)
{
cout << e << ' ';
}
cout << endl;
}
int main()
{
TestRangeFor();
return 0;
}
注意：与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环。
范围for的使用条件
1. for循环迭代的范围必须是确定的
对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供
begin和end的方法，begin和end就是for循环迭代的范围。
注意：以下代码就有问题，因为for的范围不确定
void TestFor(int array[])
{
for(auto& e : array)
cout<< e <<endl;
}这里我们能看出来是数组传参，数组传参其实是传的首元素地址，这里虽然用数组接收，但其本质上还是个指针。
2. 迭代的对象要实现++和==的操作。
10.指针空值nullptr(C++11)
C++98中的指针空值
在良好的C/C++编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现不可预料的错误，比如未初始化的指针。如果一个指针没有合法的指向，我们基本都是按照如下方式对其进行初始化：
void TestPtr()
{
int* p1 = NULL;
}// C语言中NULL定义
#define NULL (void*)0 //c语言中NULL为void类型的指针，但允许将NULL定义为0
// C++中NULL的定义
#ifndef NULL
#ifdef _cpluscplus //用于判定是c++类型还是c类型
#define NULL 0 //c++中将NULL定义为整数0
#else
#define NULL ((void*)0) //C语言中NULL为void类型的指针
#endif
#endif
可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦，比如：
void f(int)
{
cout<<"f(int)"<<endl;
}
void f(int*)
{
cout<<"f(int*)"<<endl;
}
int main()
{
f(0);
f(NULL);
return 0;
}
程序本意是想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，因此与程序的初衷相悖。
在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void*)常量，但是编译器默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转。
C++11引入了一个新关键字nullptr来表示空指针：
注意：
1. 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。2. 在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。
3. 为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
