C++祖师爷在使用C语言时感觉到了不方便的一些点，于是一步一步改进优化，最后形成了C++

本文将盘点一下基于C的语法优化

命名空间：

我们在C语言中学过，对于一个变量有全局域与局部域

那么对于一个变量的搜索的原则：

编译器是从局部到全局的的过程寻找，没有就会报错

先来看这样一段代码：

#include <stdio.h>

int rand = 10;

int main()
{
	printf("%d\n", rand);

	return 0;
}

运行时并不会报错，但是在包含头文件#include <stdlib.h>后

原因：
由于展开头文件后有rand函数与我们定义的全局变量在全局域重名了，造成报错

这就引出了命名空间域的概念

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

在C++中，不仅有命名空间域，还有类域（本文不做讨论）

C++中搜索的原则：
不指定域：1、当前局部域 2、全局域
指定域 3、如果指定了，直接去指定域搜索

命名空间定义：

---

1. 命名空间中可以定义变量,函数与类型:

namespace test
{
	//
	int rand = 10;
	
	int Add(int x, int y)
	{
		return x + y;
	}

	struct Node
	{
		struct Node* next;
		int val;
	};
}

2. 命名空间可以嵌套：

namespace test
{
	int rand = 10;
	namespace _test
	{
		int Add(int x, int y)
		{
			return x + y;
		}
	}
}

3. 同一个工程中允许存在多个命名空间，最后会合并到一个命名空间中

---

命名空间使用：

这就要引出作用域限定符的概念了::
共有三种使用场景：
注意：
当::左值为空时，为指定全局去寻找，会跳过局部域

1. 加命名空间名称及作用域限定符

namespace test
{
	int rand = 10;
}

int main()
{
	printf("%d\n", test::rand);
	return 0;
}

优缺点：
这种使用方式安全，但过于麻烦

2. 使用using namespace 命名空间名称 引入

namespace test
{
	int rand = 10;
}

using namespace test;

int main()
{
	printf("%d\n", rand);
	return 0;
}

优缺点：
这种使用方式有隐患：

就比如上图代码这种场景下namespace就失去了意义

但胜在方便，我们平时做练习时只要避免重名就可以使用，但是做项目时是不可以展开的

那有没有推荐的一种呢

3. 使用using将命名空间中某个成员引入

我们不将命名空间全部展开，只引入部分成员

using std::cout;
using std::endl;

int main()
{
	int val = 10;
	cout << val << endl;
	return 0;
}

我们可以将iostream中常用的部分展开

C++输入&输出：

对于C++的输入输出在这里我们只能浅显认识，只知道怎么使用就可以了

cout：

相当于C语言的printf

我们可以理解cout就像是我们的控制台， << 像是水流，
感性的理解就像是我们将想要输出的内容流向控制台

int main()
{
	cout << "hello world\n";
	return 0;
}

也支持多次写入

endl：

endl可以理解为一个换行

int main()
{
	cout << "hello world" << endl;
	return 0;
}

cin：

相当于我们的C语言的scanf
感性的理解就像是我们将想要输入的内容从控制台流入目标变量

	int a = 0;
	int b = 10;
	cin >> a >> b;

	//scanf("%d%d", &a, &b);

这两行代码可以达到一样的效果

优缺点：
无需类型的识别
对于小数精度的控制有些麻烦，可以直接使用printf进行替代

缺省函数：

缺省函数是什么呢

void Func(int a = 0)
{
	cout << a << endl;
}
int main()
{
	Func();   // 没有传参时，使用参数的默认值
	Func(10);  // 传参时，使用指定的实参
	return 0;
}

为什么会有这个概念呢？

假设我们有个场景，当前我们有个顺序表
A需要100个字节空间，但是B只要4个字节空间
若按照C语言的方法100字节空间的需要频繁扩容，影响效率，而使用缺省函数便可以解决这方便困扰

typedef struct SeqList
{
	int* a;
	int size;
	int capacity;
}SeqList;

void InitList(SeqList* list, int cy = 4)
{
	list->a = NULL;
	list->capacity = cy;
	list->size = 0;
}

int main()
{
	//需要100字节的
	SeqList list1;
	InitList(&list1, 100);
	//需要4字节的
	SeqList list2;
	InitList(&list2);

	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;
}

半缺省函数：

意味着只有部分参数时缺省的

void Func(int a, int b = 10, int c = 20)
{
  cout<<"a = "<<a<<endl;
  cout<<"b = "<<b<<endl;
  cout<<"c = "<<c<<endl;
}

注意：

1. 半缺省参数必须从右往左依次来给出，不能间隔着给
2. 缺省参数不能在函数声明和定义中同时出现

第二个注意点是什么意思呢？
例如在test.cpp：int func(int x = 10)
head.h：int func(int x = 10)
在声明与定义分离的情况下，会出现报错

正确写法：
test.cpp：int func(int x）
head.h：int func(int x = 10)

那么可不可以如下所示呢？
test.cpp：int func(int x = 10）
head.h：int func(int x)
但是否定的，原因在于我们在预处理时会展开头文件，编译时会检查你使用的函数有没有声明或定义，若是使用缺省函数，就会产生找不到声明的情况，最终导致报错

函数重载：

重载的大白话就是重名函数，

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

#include<iostream>
using namespace std;

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

// 2、参数个数不同
void f()
{
	cout << "f()" << endl;
}
void f(int a)
{
	cout << "f(int a)" << endl;
}

// 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()
{
	Add(10, 20);
	Add(10.1, 20.2);
	f();
	f(10);
	f(10, 'a');
	f('a', 10);
	return 0;
}

背后的原理：

我们在实际的项目工程中会有多个头文件和源文件，
在程序的翻译过程中汇编阶段会形成每个项目文件相应的符号表，

由于我们在链接前都没有sum函数真正的地址，故需要再链接时去到对应的文件符号表去寻找合并，而C语言在形成符号表时是以函数名形成的，因为同名函数没办法区分，并不能应对函数重载的的机制。

而C++为了对应此问题将产生的符号表以使用前缀+函数名+变量名第一个字符构成，这样就能应对函数重载的问题

另外：如果两个函数函数名和参数是一样的，返回值不同是不构成重载的，因为调用时编译器没办法区分。

---

引用：

引用的概念：

C语言的灵魂是指针，那么C++有没有能与之相应的功能呢？
答案是引用。

语法：类型& 引用变量名(对象名) = 引用实体；

void TestRef()
{
  int a = 10;
  int& ra = a;//<====定义引用类型
  printf("%p\n", &a);
  printf("%p\n", &ra);
}

我们对a变量引用，得到ra变量，都进行&打印得到相同的地址，故引用

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

引用特性：

1. 引用在定义时必须初始化
2. 一个变量可以有多个引用
3. 引用一旦引用一个实体，再不能引用其他实体

void TestRef()
{
	 int a = 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; // 该语句编译时会出错，b为常量
	 const int& b = 10;
	 double d = 12.34;
	 //int& rd = d; // 该语句编译时会出错，类型不同
	 const int& rd = d;
}

使用场景：

1. 做参数：

void Swap(int& left, int& right)
{
	int temp = left;
	left = right;
	right = temp;
}

2. 做返回值：

int& Count()
{
	static int n = 0;
	n++;
	// ...
	return n;
}

---

int& Add(int a, int b)
{
  int c = a + b;
  return c;
}
int main()
{
  int& ret = Add(1, 2);
  Add(3, 4);
  cout << "Add(1, 2) is :"<< ret <<endl;
  return 0;
}

注意：如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。

引用与指针的区别：

语法上：

在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。

int main()
{
	int a = 10;
	int& ra = a;
	cout<<"&a = "<<&a<<endl;
	cout<<"&ra = "<<&ra<<endl;
	return 0;
}

底层上：

在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

int main()
{
	int a = 10;
	int& ra = a;
	ra = 20;
	int* pa = &a;
	*pa = 20;
	return 0;
}

我们来看下引用和指针的汇编代码对比：
那么引用可以代替指针吗？

答案是否定的。

例如在双向链表的场景中：我们要删除一个节点，因为引用是不能改变指向的。
更详细的一点说：当第一个next为下一个节点地址的引用时，如果我们要更改next，实际上是在修改下一个节点的地址，由于地址是个常量，不能被修改最终导致报错

总结：

1. 语法上引用是别名，不开空间；指针是变量，需要开空间
2. 引用必须初始化；指针可以不初始化
3. 引用不可以改变指向；指针可以改变指向
4. 引用更安全，很少出现野引用的现象；指针相比之下更危险，会有野指针，空指针的出现。
5. sizeof ++ 解引用等方面的区别。

注意：
底层上引用就是指针

---

内联函数：

在C语言的学习中，我们学习过宏，但是宏有比较多的缺点。
宏的缺点：
1、语法复杂，坑很多，不容易控制
2、不能调试
3、没有类型安全的检查

但是有时候宏又会很好用，在执行一些代码很短但又需多次调用的会很依赖。

概念：

所以有了内联函数的概念，他的用法与函数一样，但是会按函数中你定义的逻辑在你调用的地方展开（减少栈栈帧创建的过程），与宏函数直接替换是不一样的

使用时用inline修饰函数即可

特性：

1. inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。
2. inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：
3. 将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。下图为
   《C++prime》第五版关于inline的建议：
4. 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 __cdeclf(int)" (?f@@YAXH@Z)，该符号在函数 _main 中被引用

关于最后一点，还有部分扩展。
当我们函数定义没有分离，都在F.h中时；

int Add(int x, int y)
{
	return x + y;
}

若我们在别的源文件#include，会报重定义的错误，

原因在于头文件在预处理会展开，汇编时生成的符号表会由于函数相同而造成部分符号表相同，链接时就会报重定义的错误。

那么解决办法呢？

1. 声明定义分离，这个就不过多解释了
2. 使用static修饰，会改变当前函数在当前文件的链接属性，使得这个函数只能在本源文件内使用，不能在其他源文件内使用。
3. 使用inline修饰，与static同理