目录

一.C++关键字

二.命名空间

1.命名空间定义

2.命名空间的使用

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

（2）使用using将命名空间中成员引入

（3）使用using namespace命名空间名称引入

三.输入，输出（cin，cout）

四.缺省参数

1.缺省参数概念

2.缺省参数分类

（1）全缺省参数

（2）半缺省参数

五.函数重载

1. 函数重载概念

2. 名字修饰※

（1）g++编译

（2）gcc编译

3. C++调用C（extern "C"）※

 4. C调用C++※

六.引用

1. 概念

2. 特性

3. 常引用

4. 使用场景

①做参数

②做返回值

5. 引用和指针的区别

七.内联函数

1. 概念

2.特性

3.宏的优缺点

八.atuo关键字

1.auto介绍

2.auto使用方式（意义）

（1）类型长时，可以用auto自动推导

（2）范围for

3.auto使用（注意）

（1）auto与指针和引用结合起来使用

（2）同一行要定义同一变量类型

4.auto的错误使用

（1）auto不能作为函数的参数

（2）auto不能作为函数的返回值

（3）auto不能直接用来声明数组

九.基于范围的for循环（范围for循环）

1.范围for的语法

2.范围for的使用条件

（1）for循环迭代的范围必须是确定的

十.空指针nullptr

前言：这是c++的第一篇，这个是下一篇学习类和对象的基础，我们应该好好理解。

同时在理解的基础上，我们也要去关注c++的底层实现，这里的函数重载就通过对c++的底层原理进行分析，来得到函数重载的原理。这里相对比较难理解一些，但是我们依旧要去掌握。

一.C++关键字

C++一共有63个关键字，其中包括了C语言的32个关键字。

asm	do	if	return	try	continue
auto	double	inline	short	typedef	for
bool	dynamic_cast	int	signed	typeid	public
break	else	long	sizeof	typename	throw
case	enum	mutable	static	union	wchar_t
catch	explicit	namespace	static_cast	unsigned	default
char	export	new	struct	using	friend
class	extern	operator	switch	virtual	register
const	false	private	template	void	true
const_cast	float	protected	this	volatile	while
delete	goto	reinterpret_cast

二.命名空间

        使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。

        因为在C/C++中，变量、函数和类很多，这些如果都存在于全局作用域中，可能会导致很多冲突，所以可以使用命名空间。

1.命名空间定义

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

//1. 普通的命名空间
namespace N1 // N1为命名空间的名称
{
	// 命名空间中的内容，既可以定义变量，也可以定义函数
	int a;
	int Add(int left, int right)
	{
		return left + right;
	}
}

//2. 命名空间可以嵌套
namespace N2
{
	int a;
	int b;
	int Add(int left, int right)
	{
		return left + right;
	}

	namespace N3
	{
		int c;
		int d;
		int Sub(int left, int right)
		{
			return left - right;
		}
	}
}

//3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。
namespace N1
{
	int Mul(int left, int right)
	{
		return left * right;
	}
}

 注意：一个命名空间就定义了新的作用域，命名空间中的所有内容都局限于该命名空间中。

2.命名空间的使用

比如这个命名空间N：

namespace N {
	int a = 10;
	int b = 20;
	int Add(int left, int right)
	{
		return left + right;
	}
	int Sub(int left, int right)
	{
		return left - right;
	}
}

int main()
{
	printf("%dn", a); // 该语句编译出错，无法识别a
	return 0;
}

命名空间的使用有三种方式：

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

int main()
{
	printf("%dn", N::a);
	return 0;
}

（2）使用using将命名空间中成员引入

        只放出来某些常用的成员

using N::b;
int main()
{
	printf("%dn", N::a);
	printf("%dn", b);
	return 0;
}

这个就是放出来了N命名空间中的b变量，其它变量都无法直接使用。

（3）使用using namespace命名空间名称引入

using namespce N;
int main()
{
	printf("%dn", N::a);
	printf("%dn", b);
	Add(10, 20);
	return 0;
}

三.输入，输出（cin，cout）

1.C++的标准输入为cin（键盘输入），标准输出为cout（控制台输出），需要包含头文件以及std标准命名空间。

注意：早期标准库将所有功能在全局域中实现，声明在.h后缀的头文件中，使用时只需包含对应头文件即可，后来将其实现在std命名空间下，为了和C头文件区分，也为了正确使用命名空间，规定C++头文件不带.h；旧编译器(vc 6.0)中还支持格式，后续编译器已不支持，因此推荐使用 +std的方式。

2.使用C++的输入输出更加方便，不需增加数据格式控制。

但有时使用C语言的scanf和printf会更加方便。

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

四.缺省参数

1.缺省参数概念

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

void TestFunc(int a = 0) 
{
	cout << a << endl;
}

int main()
{
	TestFunc(); // 没有传参时，使用参数的默认值
	TestFunc(10); // 传参时，使用指定的实参
}

 打印出来的结果分别是0   10.

2.缺省参数分类

（1）全缺省参数

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

（2）半缺省参数

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

 注意：

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

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

//a.h
void TestFunc(int a = 10);

// a.c
void TestFunc(int a = 20)
{}

// 注意：如果声明与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该用那个缺省值

因此我们要在声明和定义中选择一个使用缺省。

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

        4.C语言不支持缺省参数

五.函数重载

1. 函数重载概念

函数重载是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表（参数个数 或 参数类型 或参数顺序）必须有一个不同。

函数重载常用来处理实现功能类似但数据类型不同的问题。

int Add(int left, int right) 
{
	return left + right;
}

double Add(double left, double right)
 {
	return left + right;
}

long Add(long left, long right) 
{
	return left + right;
}

int main()
{
	Add(10, 20);
	Add(10.0, 20.0);
	Add(10L, 20L);

	return 0;
}

这3个Add就构成了函数重载

short Add(short left, short right) 
{
	return left + right;
}

int Add(short left, short right) 
{
	return left + right;
}

这两个Add不构成函数重载，返回类型不同，不是函数重载

2. 名字修饰※

为什么C++支持函数重载，而C语言不支持函数重载呢？

在C/C++中，一个程序要运行起来，需要经历以下几个阶段：预处理、编译、汇编、链接

这几个阶段分别进行的操作：

①预处理：头文件展开、宏替换、条件编译，删除注释

②编译：检查语法，生成汇编代码

③汇编：把汇编代码转换成二进制的机器码、生成符号表 

④链接：合并段表、符号表的合并和重定位（找调用函数的地址，链接对应上，合并到一起）

详细可以看这一篇：C语言程序的编译（预处理）【C】_糖果雨滴a的博客-CSDN博客

1.实际我们的项目通常是由多个头文件和多个源文件构成，通过C语言阶段学习的编译链接，我们可以知道在（a.cpp中调用了b.cpp中定义的Add的函数时），编译后链接前，a.o文件中没有Add的函数地址，因为Add时在b.cpp中定义的，所有Add的地址在b.o中。那应该怎么办。

2.链接阶段就是专门处理这种问题的，链接器看到A.o调用Add，但是没有Add的地址，就会到b.o的符号表中找Add的地址，然后链接到一起。

3.那么链接时，面对Add函数，链接器会使用哪个名字去找呢？这个取决于编译器，每个编译器都有自己的函数名修饰规则。

4.因为window下vs的修饰规则很复杂，所有这里用Linux下gcc和g++来演示修饰后的名字。

5.通过下面，我们可以看出gcc（C语言编译器）的函数修饰名字不变（与原函数名一样），而g++的函数修饰后变成了【_Z+函数名长度+函数名+函数参数类型首字母】。

（1）g++编译

结论：在linux下，采用g++编译完成后，函数名字的修饰发生改变，编译器将函数参数类型的信息添加到修改后的名字中。

这里我们比较void和int两种返回类型的函数，会发现修饰后的名字相同，因此返回类型不同不能构成重载函数。

（2）gcc编译

 结论：在linux下，采用gcc编译完成后，函数名字与原函数名字相同，没有发生修饰，所以C语言不支持函数重载。

6.因此，到这里我们就可以理解C语言不支持重载，就是因为同名函数无法区分；而C++时通过函数修饰规则来进行区分，只要函数参数不同，修饰出来的名字就不一样，就支持重载。

7.我们也可以理解，为什么函数重载要求参数不同，而跟返回类型无关。

3. C++调用C（extern "C"）※

有时候在C++工程中，可能需要将某些函数按照C的风格来进行编译，这时在函数前加extern "C"，意思就是告诉编译器，将该函数按照C语言规则来编译。

这里我们通过C++调用C的静态库来演示：

①将C改为静态库：

---

 ②让C++链接上刚才的C的静态库

通过这几个操作之后我们就用C++链接上了C的静态库。

这里我们在C++随便写一个需要用到C的静态库的代码，会发现运行报错，这就是因为C++和C语言的函数名修饰的关系，这时我们可以使用extern "C"来解决。

这里include包括的头文件是通过相对位置进行寻找的，找的就是C的静态库的头文件。

下面这两个分别是C++调用的C静态库和C静态库的头文件

 

 4. C调用C++※

前面的步骤与（3）的相同，只是这次是创建C++的静态库，让C去调用C++的静态库，具体操作步骤看（3）.

 这里我们是让C去调用C++的静态库的头文件。

在这里我们不需要修改这个C文件，需要修改C++静态库文件。（上一个也是修改C++文件，而不需要修改C的静态库）

 

① 这里我们有两种方法，先看第一种方法：

这里我们需要用到之前学的条件编译。这个条件编译的意思是：如果是cpp文件就让EXTERN_C去代替extern "C"，如果不是cpp文件就让EXTERN_C无实际意义。

这时我们在C++的静态库里就通过extern "C"让这个C++里的函数按C的函数规则在符号表里生成。

而在C中调用该静态库时，因为条件编译的存在，C不是cpp文件，所以EXTERN_C无实际意义，就不会生效。（因为C语言没有extern "C"，如果不使用条件编译，让C中出现extern "C"就会报错）。

②第二种方法：

这种方法相比于第一种方法更方便，但是总体上与第一种方法一样。

如果是cpp文件就extern "C"下面这些函数，让这些函数按C的函数修饰规则去生成符号表。

如果不是，就相当于不存在extern "C"。

六.引用

1. 概念

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

类型& 引用变量名（对象名） = 引用实体

int main()
{
	int a = 10;
	int& ra = a;//定义引用类型

	printf("%pn", &a);
	printf("%pn", &ra);
}

注意:引用类型和引用实体必须是同种类型的。 

2. 特性

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

②一个变量可以有多个引用

③引用一旦引用一个实体，再不能引用其它实体

int main()
{
	// 1、引用在定义时必须初始化
	// int& d;

	// 2、一个变量可以有多个引用
	int a = 10;
	int& b = a;
	int& c = b;

	int* p = &b;
	
	// 3、引用一旦引用一个实体，再不能引用其他实体
	int e = 20;
	// e赋值给b
	b = e;

	p = &e;

	return 0;
}

3. 常引用

int main()
{
	int a = 10;
	int& b = a; // 不变

	// 取别名原则:对原引用变量，权限只能缩小，不能放大
	const int x = 20;	//对常量引用要加const
	//int& y = x;       // 放大
	const int& y = x;   // 不变


	int c = 30;
	const int& d = c;  // 缩小

	//cout << d << endl;
	//d = 40;

	return 0;
}

int main()
{
	double d = 2.2;

	int f = d;//赋值时，先产生一个临时变量，把2.2的整数2放到临时变量中，再给f
	const int& e = d;//引用的时临时变量，临时变量不能修改，所以要加const

	return 0;
}

4. 使用场景

①做参数

void Swap(int& x, int& y)
{
	int tmp = x;
	x = y;
	y = tmp;
}

void Swap(double& x, double& y)
{
	double tmp = x;
	x = y;
	y = tmp;
}


#include 
struct A
{ 
	int a[10000]; 
};

void TestFunc1(A aa){}

void TestFunc2(A& aa){}

void TestFunc3(A* paa){}

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();

	size_t begin3 = clock();
	for (size_t i = 0; i < 10000; ++i)
		TestFunc3(&a);
	size_t end3 = clock();

	// 分别计算两个函数运行结束后的时间
	cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
	cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
	cout << "TestFunc3(A*)-time:" << end3 - begin3 << endl;

	//这里通过输出结果可以发现，引用和指针的运行时间差不多，
	//都比直接传值所需的时间要少
}

 传引用或指针都可以提高效率

②做返回值

这里我们先比较两种引用返回的方式

第一种：

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

int main()
{
	const int& ret = Count();

	return 0;
}

第二种：

int& Count()
{
	static int n = 0;
	n++;
	cout <<"&n:"<<&n << endl;
	// ...
	return n;
}

int main()
{
	int& ret = Count();
	cout << ret << endl;
	cout << "&ret:" << &ret << endl;
	cout << ret << endl;


	return 0;
}

        第一种传引用返回是错误的，第一种n是函数中的临时变量，出了函数作用域就要还给系统，这时候用引用，让ret是返回的n的别名，这时候这个ret就类似于一种野引用（像指针中的野指针）。

        而第二种n是静态变量，出函数作用域不需要还给系统，因此可以使用引用返回，这里我们还可以看到这个n和ret的地址是相同的。

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

下面再比较一下传值和传引用的效率：

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

这里我们比较一下传值返回，和传引用返回所需要的时间，可以发现传引用返回所需要的时间更少，效率更高。

总结：以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时拷贝。因此用值作为参数或者返回值类型，效率较低，尤其时当参数或者返回值类型非常大时，效率更低。

所以，能用引用传参和引用返回时，尽量使用引用，效率高。

5. 引用和指针的区别

int main()
{
	//int& r;
	//int* p;

	double d = 2.2;
	double& r = d;
	cout << sizeof(r) << endl;

	return 0;
}

引用sizeof的大小是类型的大小。

int main()
{
	int a = 10;
	// 语法角度而言：ra是a的别名，没有额外开空间
	// 底层的角度：他们是一样的方式实现的
	int& ra = a;
	ra = 20;

	// 语法角度而言：pa存储a的地址，pa开了4/8byte空间
	// 底层的角度：他们是一样的方式实现的
	int* pa = &a;
	*pa = 20;

	return 0;
}

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

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

引用和指针的不同点：

①引用在定义时必须初始化，指针没有要求

②引用在初始化时引用一个实体后，就不能再引用其它实体，而指针可以再任何时候指向任何一个同类型的实体

③没有NULL引用，但有NULL指针

④在sizeof中的含义不同：引用的结果为引用类型的大小，而指针始终是地址空间所占字节个数（32位下4个字节，64位下8个字节）

⑤引用自加：即引用的实体+1；指针自加：即指针向后偏移一个类型的大小

⑥没有多级引用，但有多级指针

⑦访问实体方式不同，指针需要显示解引用，而引用编译器会自己处理

⑧引用比指针使用起来相对更安全

七.内联函数 1. 概念

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

//C语言宏的方式：

#define ADD(x, y) ((x)+(y))
// 为什么C++要出inline？解决宏函数晦涩难懂，容易写错的问题

// inline ： 1.debug支持调试  2.不容写错，就是普通函数的写法

//内联函数：前面加上inline即可
inline void f(int i)
{
	cout << i << endl;
}

2.特性

①inline时一种以空间换时间的做法，省去了调用函数的额外开销。所以代码很长或者有循环/递归的函数不适宜使用作为内联函数。

②inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归，或者代码很长时（一般时大于10行）编译器优化时会忽略掉内联。

③inline不建议声明和定义分离，分离会导致链接错误，因为inline被展开，就没有函数地址了，链接就会找不到。

3.宏的优缺点

优点：

（1）增加了代码的复用性

（2）提高性能

缺点：

（1）宏不支持调试 

（2）代码可读性差，可维护性差，容易误用

（3）没有类型安全的检查

C++有代替宏的技术：

（1）常量定义：换用const

（2）函数定义：换用内联函数

八.atuo关键字

1.auto介绍

早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量。但很少有人用。

C++11中，auto的有了新的含义：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

int TestAuto()
{
	return 10;
}

int main()
{
    //auto可以自动识别类型
	const int a = 10;
	auto b = &a;
	auto c = 'a';
	auto d = TestAuto();

	cout << typeid(b).name() << endl;
	cout << typeid(c).name() << endl;
	cout << typeid(d).name() << endl;

	return 0;
}

注意：

使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型，因此auto并非时一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译时会将auto替换为变量实际的类型。

2.auto使用方式（意义）

（1）类型长时，可以用auto自动推导

#include 

（2）范围for

int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9};

// 范围for
// 依次自动取array中的数据，赋值给e，自动判断结束
for (auto& e : array)
{
    e /= 2;
}

for (auto x : array)
{
	cout << x << " ";
}
cout << endl;

3.auto使用（注意）

（1）auto与指针和引用结合起来使用

用auto声明指针类型时，用auto和auto*没有区别，但用auto声明引用类型时必须加&

int main()
{
	int x = 10, y = 20;
	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;
}

（2）同一行要定义同一变量类型

当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其它变量。

auto c = 3, d = 4.0; // 该行代码会编译失败，因为c和d的初始化表达式类型不同

4.auto的错误使用

（1）auto不能作为函数的参数

void TestAuto(auto a = 10)
{}

（2）auto不能作为函数的返回值

auto Test()
{
	return 10;
}

（3）auto不能直接用来声明数组

auto b[] = {4，5，6};

九.基于范围的for循环（范围for循环）

1.范围for的语法

        for循环后的括号由冒号“:”分为两部分，第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

void TestFor()
{
	int array[] = { 1, 2, 3, 4, 5 };
	//修改时注意加&
	for (auto& e : array)
		e *= 2;

	for (auto e : array)
		cout << e << " ";
}

注意：范围for与普通循环类型，可以用continue和break 

范围for的底层就是迭代器iterator（这里会在之后到STL内说明）

2.范围for的使用条件

（1）for循环迭代的范围必须是确定的

对于数组而言，就是数组中第一个元素和最后一个元素的范围，对于类而言：应该提供begin和end，begin和end就是for循环迭代的范围。

下面这种写法就是有问题的，for的范围不确定：

void TestFor(int array[])
{
	for (auto& e : array)
		cout << e << endl;
}

十.空指针nullptr

在良好的C/C++编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现不可预料的错误，比如未初始化的指针（可能会出错）。如果一个指针没有合法的指向，我们之前在C语言时是按照这种方式初始化的：

int* p1 = NULL; //第一种
int* p3 = 0;    //第二种

NULL实际是一个宏，在C语言中，NULL就是0

#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#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);
	f(nullptr);

	return 0;
}

这里我们是想通过f（NULL）调用指针版本的f（int*）函数，但是由于NULL被定义成0，就去调用了f（int）函数。

在C++98中，0既可以是一个整形数组，也可以是无类型的指针（void*）常量，但是编译器默认情况下会将其看成一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转（void*）0

因为这个原因，C++11中引入的新的关键字nullptr

nullptr：

（1）在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的

（2）在C++11中，sizeof（nullptr）与sizeof（（void*）0）所占的字节数相同

（3）为了提高代码的健壮性，之后表示指针空值建议使用nullptr

（健壮性）：代码在出现预期之外错误情况下的应对能力。

这一篇只是C++的基础语法，是为了下一篇可以展示C++封装特性的类与对象做准备的。