指针也能达到这种效果

#include <iostream>using namespace std;int Add(int a, int b, int c = 3){	return a + b + c;}int main(){	cout << Add(10, 20, 30) << endl;	return 0;}

int main(){	const int a = 0;	//编译器报错  error C2440: “初始化”: 无法从“const int”转换为“int &”    //int& ra = a;//权限放大	const int& ra = a;//平等关系	int b = 0;	int& rc = b;	const int& rd = b;//权限缩小	//error C3892: “rd”: 不能给常量赋值	//rd++;	rc++;	return 0;}

void test(){    cout << "void test()" << endl;}void test(int n = 4){    cout << "void test(int n = 4)" << endl;}int main(){    test();    return 0;}

#include <iostream>namespace hx{    int rand = 6;	int Add(int left, int right)	{		return left + right;	}	struct Node    {      	int val;     	struct Node* next;	};}

void fun(const int& ra);

使用inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开内联函数，这种调用内联函数的方式就不需要要创建函数栈帧，提高了效率。}//引用int& test(){ int ret = 10; //…… return ret;//引用同理，引用一块被销毁的空间}int main(){ test()++; return 0;}

• 引用和指针在实践中相辅相成，功能有重叠性，但是各有特点，互相不可替代最大的点，C++引用定义后不能改变指向

#include <iostream>using namespace std;void Swap(int& x, int& y){	int temp = x;	x = y;	y = x;}int main(){	int a = 10;	int b = 50;	Swap(a, b);	cout << a << endl << b;	return 0;}

const引用

• 可以用于const对象，但是必须使用const引用。使用nullptr定义空指针可以避免类型转换的问题，因为nullptr只能被隐式地转换为指针类型，而不能被转换为整数类型。

• ::变量名，访问全局变量。输出对象。

  

  解决办法：将返回值进行引用，这里返回的就不会将返回值拷贝在临时对象中，而是给这个返回值取了一个别名，返回的是栈顶元素的别名，对别名加加的结果是栈顶元素大小加1。}

  int main(){    int a = 6;    int& b = a;    int& c = a;    int& d = b;	cout << &a << endl;    cout << &b << endl;    cout << &c << endl;    cout << &d << endl;    d++;    cout << a << endl;}

  

  引用的特性

  • 引用在定义时必须初始化
    

  • 一个变量可以有多个引用（上面提过例子）

  • 引用一旦引用一个实体，就不能引用其它实体，这里使用ra对变量a引用之后，还使用b进行引用，编译代码时没有报错，但运行后会报错，提示ra多次初始化

  int main(){	int a = 1;	int b = 10;	int& ra = a;	int& ra = b;       //这里并非是是引用，而是一个赋值，将10赋给ra    ra = b;	return 0;}

  

  引用的使用

  • 引用在实践中主要时用于传参和引用做返回值中，减少拷贝提高效率和改变引用对象时同时改变被用于对象。函数、这种特性使得同一个函数名可以执行不同的操作，C语言不支持这种操作。

  找到C/C++选项里的常规，将调试信息格式，设置为 程序数据库(/Zi)
  

  找到C/C++选项里的优化，将内联函数拓展设置为 只适用 _inline(/Ob1)

  

  nullptr

  NULL是一个宏，在C语言头文件里（stdd.f）可以观察。函数、日常做练习，测试方便可以使用，但不能养成创建一个main函数前，第一件事将，std命名空间展开，以及忘记对std命名空间的成员前使用域作用限定符的坏习惯。进行引用。

  int& StackTop(Stack& ps){	assert(ps.top > 0);	return ps.arr[ps.top - 1];}int main(){	Stack sk;	StackInit(&sk);	StackPush(&sk, 1);	StackPush(&sk, 2);	StackTop(sk)++;	return 0;}

  这里将栈顶元素放回后++，编译器会报错。在调用该函数时，如果没有传递参数，则使用该形参对应的缺省值，否则使用传递过来的参数，缺省参数分为全缺省和半缺省

  函数声明和定义分离时，缺省参数不能再函数声明和定义中同时出现，规定必须哈数声明给缺省值，例如，实现数据结构队列的.h头文件的函数声明和.c文件对函数的定义。

  • 不管是什么类型的数据，都会被转换为字符流，进行输入输出

• std::endl（end line），是一个函数，流插入、

• 内联函数易错点，含有循环语句、输出时，相当于插入一个换行符 加 刷新缓冲区。内联函数一般用于代码短小，频繁带哦用的函数。

• 命名空间域，只能定义在全局，它的成员本质上是全局变量。

• const修饰的引用作为函数参数，可以引用临时对象、

• 命名空间名::变量名，访问了命名空间域。

  例如，我传递100w个大小的整形数组，来解决某问题，传递数组时需要临时开辟100w个大小的整形空间，非常浪费，这里对数组使用引用就可以进行优化，从而提高效率。

  //初始化void StackInit(Stack* ps, int n = 4){	assert(ps);	ps->arr = (StackDatdType*)malloc(sizeof(StackDatdType) * n);	ps->capacity = ps->top = 0;}

  函数重载

  C++中允许在同一个作用域里定义多个同名函数，只要它们的参数列表不同。%s、指针也存在权限放大缩小。

  #ifndefNULL#ifdef__cplusplus#defineNULL0#else#defineNULL((void*)0)#endif#endif

  • C++中的NULL被定义为字面常量0，C语言里被定义为为类型指针的常量。类大量存在，由于它们的大量存在而可能导致名称使用上的冲突。C++规定临时对象具有常性（常性，形如被const修饰），这里触发了权限放大，必须使用常引用才可行。

  ---

  • 半缺省参数，部分形参给缺省值，C++规定半缺省值必须从右向左依次给缺省值。

    局部域和全局域除了会影响编译时的查找逻辑（先局部查找，然后全局查找），还会影响变量的生命周期。

  • Add(10, 20, 30)，三个参数都传递了，不会使用缺省值。
    • 第一步找到vs编译器的 项目，点击
    • 点击项目内容的最后一个选项。

    • 想要使用名称空间的成员，必须在变量/函数/结构体/……前加上名称空间的名字和 ::域作用限定符。%c这些东西，可以自动识别任意类型的变量、

    • 命名空间域和类域不影响变量生命周期。

    //#define ADD(a, b) a + b;//#define ADD(a, b) (a + b)//#define ADD(a, b) ((a) + (b))// 为什么不能加分号? 例如if语句调用加分号的ADD函数// 为什么要加外⾯的括号，为什么要加⾥⾯的括号?

    C语言debug版本默认不展开inline。

    ​ 对函数使用引用本质上是在传地址

  • 引用传参跟指针传参相对比较复杂，指针也也有类似场景。输出流库，定义了标准的输入、

• inline只是一种建议，是否展开还得看编译器，加了inline的函数编译器可以选在在调用的地方不展开，不同编译器处理inline的方法和场景不同，C++并没有对这些进行限制标准。flush（cout的主动刷新接口）才会输出到控制台中。

  指定展开命名空间成员

  项目中经常使用，且不会存在冲突的名称

  #include <iostream>namespace hx{    int n = 10;    int num = 20;}using hx::num;int main(){    cout << num << endl;    return 0;}

  C++的域

  C++中域有函数局部域、

  C++中为了避免引⼊太多的运算符，会复⽤C语⾔的⼀些符号，⽐如前⾯的<<和>>，这⾥引⽤也和取 地址使⽤了同⼀个符号&。debug版本想要展开需要设置这两点。

在这种情况下，传递NULL想调用int*版本的f函数，但调用的结果时int版本的函数，为了弥补这样的不足，C++引用了关键字nullptr

void f(int x){    cout << "void f(int x)" << endl;}void f(int* x){   cout << "void f(int* x)" << endl;}int main(){    f(1);    f(NULL);    return 0;}

• nullptr在C++11中引用的特殊关键字，nullptr是一种特殊类型的字面常量，它可以转换为其它类型的指针类型。命名空间域、类域，域影响的是变量/函数/类型的出处的逻辑， 有了域隔离（不同的域可以同名，同一个域不可以定义同一个东西），名字冲突的问题就解决了。

C++的输入和输出

< iostream >，是Input Output Stream 的缩写，是标准的输入、

类型& 引用别名 = 引用对象

int main(){	int a = 6;    int& b = a;    int& c = a;    int& d = b;//也可以对别名b取别名，d也是指向变量a        d++;//对d加加，a、
#include <iostream>using namespace std;namespace hx{	int rand = 0;	void Print()	{		cout << "哈哈哈" << endl;	}	struct Node	{		int val;		struct Node* next;	};}int rand = 10;int main(){	int rand = 10;	cout << ::rand << endl;	cout << rand << endl;	hx::Print();	struct hx::Node node;		return 0;}
展开命名空间
使用using将名称空间全部成员展开，在项目中不推荐，名称之间的冲突很大。
全局变量存储静态存储区上，生命周期是永久的，从程序开始执行诞生，到程序终止时消亡。
命名空间域，与全局进行隔离
编译时想要使用变量/函数/结构体/……编译时向上查找过程必须包含对应的代码，先局部查找，然后全局查找。
局部变量存储在栈上，生命周期时临时的，结束函数的调用或作用域结束时消亡。     
函数被编译后是一堆指令需要存储起来执行，内联展开可能会导致可执行程序变大，内存炸开，指令膨胀
C++设计内联函数的设计目的是为了替代C语言的宏函数，C语言里的宏函数容易出错，需要频繁使用括号，不方便调试。scanf，在vs编译器上是这样，其它编译器不一定能支持。
Add(10, 20)，传递了第一个和第二个参数，没有最后一个参数，形参c使用缺省值。否则默认使用，其它地方出现的变量/函数/结构体/……
名称空间只能在全局定义，可以嵌套使用
项目工程里，多文件定义同名namespace会认为是同一个namespace，不会发生冲突
C++标准库都放在一个std的命名空间中。使用流提取运算符（>>）， cin >> 变量名 << endl，
std::cout，是ostream类的对象，主要面向窄字符的标准输出流，不需要使用占位符，%d、
#include <iostream>using namespace std;int main(){    int a = 0;    cin >> a;    cout << a << endl;	return 0;}
使用using展开后，就不需要频繁使用 std::，方便了许多。
‘\n’，这种换行方法，在不同的系统上可能不兼容，无法通过换行符进行换行，使用endl更加多用。枚举等进行重命名。比如土豆、
C++初识
文章目录
C++ hello world
namespace，命名空间
命名空间的使用
域作用限定符
展开命名空间
指定展开命名空间成员
C++的域
C++的输入和输出
缺省参数
函数重载
引用（reference）
引用概念
引用的特性
引用的使用
const引用
inline
nullptr
C++ hello world
#include <iostream>//test.cppusing namespace std;int main(){	std::cout << "hello world" << std::endl;    cout << "haha" << endl;	return 0;}
使用using将命名空间展开，使用cout标准输出流，和流插入运算符 << 将hello world输出到控制台。
Add(10)，传递了第一个参数，没有后续两个参数，形参b和c使用缺省值。马铃薯，不同的称呼，指向的都是同一个东西。全局域、
std::cin，是 istream 类的对象，主要面向窄字符的标准输出，与C语言的不同，它不需要使用占位符，可以自动识别任意类型的变量。namespace关键字，是针对名称冲突而出现的。含有递归语句、
C++兼容C语言，头文件< iostream >，间接包含了printf、含代码量大，满足这三点其一，都不能称之为内联函数，加上inline后会被编译器忽略。C++是在C语言之上发展出来的，在C++的编译器里是兼容C语言的，两者可以混合使用。普通对象、结构体、int& rd = d;对一个浮点数进行引用，先对变量d进行类型转换，这个类型转换的结果也会被存放在临时对象中。
参数列表不同
返回类型可以相同，也可以不同，只凭借返回类型无法实现函数重载
作用域必须在同一个
#include <iostream>int Add(int left, int right){	return left + right;}double Add(double left, double right){	return left + right;}int main(){	Add(1, 2);	Add(1.2, 5.2);	return 0;}
这里实际上调用了两个函数
这里同时使用了函数重载和缺省参数，语法上没问题，当直接调用 test()，编译器直接傻眼了不知道到的用那个函数，有歧义。
使用cout进行输出时，输出内容不会第一时间输出，而是先将这些东西装换为字符串，然后放在cout的缓冲区，需要遇见一些刷新标志才会出缓冲区，比如换行、
namespace，命名空间
在C/C++中，变量、scanf输入输出时那样，需要使用占位符手动指定格式，C++的输入输出可以自动的识别变量的类型。
inline函数不支持声明和定义分离到两个文件，因为编译器一旦将一个函数作为内联函数处理，就会在调用位置展开，即该函数是没有地址的，也不能在其他源文件中调用，所以一般都是直接在源文件中定义内联函数的。
案例1：
#include <iostream>namespace hx//命名空间的名字{	int range = 6;	void swap(int x, int y)	{		std::cout << "void swap(int x, int y)" << std::endl;	}    struct Node    {      	int val;     	struct Node* next;	};}void swap(int& x, int& y){	int temp = x;	x = y;	y = temp;}int main(){	int a = 5;	int b = 10;	int range = 1;	printf("%d %d\n", range, hx::range);    	swap(a, b);    printf("%d %d\n", a, b);	hx::swap(a, b);	return 0;}
案例2（嵌套定义）：
namespace xyz{	namespace xy	{		int range = 6;		void swap(int x, int y)		{			std::cout << "void swap(int x, int y)" << std::endl;		}	}	namespace yz	{		int range = 3;		void swap()		{			std::cout << "void swap()" << std::endl;		}	}}int main(){	int range = 66;	std::cout << xyz::xy::range << std::endl;	std::cout << xyz::yz::range << std::endl;}
命名空间的使用
域作用限定符
::，域作用限定符。编译器的防御手段
若有1w次调用一个100行的内联函数的地方，内联函数展开后，代码量变为 10000 * 100 = 100w行。洋芋、

int& StackTop(Stack& ps){	assert(ps.top > 0);	return ps.arr[ps.top - 1];}int main(){	Stack sk;	StackInit(&sk);	StackPush(&sk, 1);	StackPush(&sk, 2);	StackTop(sk)++;	return 0;}
无法使用引用进行返回的场景
//指针int* test(){	int ret = 10;		//……		return &ret;//返回的是局部变量，函数调用完成后被销毁，返回地址的是一个野指针。数据类型进行输出，使用流插入运算符（<<）。const引用也可以引用普通对象，因为对象的访问权限在引用过程中可以缩小，但不能放大。