[C++] C++入门第一篇 -- 命名空间，输入输出，缺省函数，函数重载底层原理

桃扇骨 2023-10-13 22:49 121阅读 0赞

![8686df0d75284aecb900036c03bf663c.gif][]

**目录**

1、关键字

2、命名空间

2.1 命名空间的定义

2.2 命名空间的使用方式

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

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

2.2.3 使用using namespace 命名空间名称引入

3、C++输入与输出

4、缺省参数

4.1 缺省参数的概念

4.2 缺省参数分类

4.2.1 全缺省参数

4.2.2 半缺省参数

5、函数重载

5.1 函数重载概念

5.2 C++支持函数重载的原理--名字修饰(name Mangling)

--------------------

## 1、关键字 ##

C++总计63个关键字，C语言32个关键字，下面图中就是C++的关键字。我们现在不去细说，后面都会用到，持续关注，在使用中会讲解。

![f57ac13dcee89cd306ce351d27aa7260.png][]

## 2、命名空间 ##

我们先来写一个C++代码，来看一下。

#include <iostream>
    using namespace std;
    
    int main()
    {
        cout << "Hello world!" << endl;
        
    	return 0;
    }

这个代码中第一句 \#include <iostream>，与C语言的\#include <stdio.h>是一样的，是调用输入输出库函数要包含的头文件，在C++中，使用后者也是可以的，C++全面兼容C语言的。

了解了输入输出头文件后，我们发现还多了第二句 using namespace std;，这个是干什么的？

关键字 namespace 就是命名空间，这是对C语言的一些问题的优化，具体是什么，我们往下看。

在C语言中，我们知道存在一个**命名冲突**的问题

#include <stdio.h>
    int main()
    {
    	int a = 10;
    	int a = 20;
    	
    	printf("%d %d", a, a);
    	return 0;
    }

![12d773c99a600d6d501e041f187fa95e.png][]

这里的问题是重定义，这就是命名冲突。但是我们要是在工作中，一个小组多个程序员同时做开发，肯定会出现命名冲突的问题。

而C++引入了 namespace 命名空间的概念。

### 2.1 命名空间的定义 ###

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

我们这里来写一个命名空间代码。

namespace lcx //命名空间名字叫lcx
    {
    	int a = 10;//成员变量
    
    	int Add(int x, int y)//成员函数
    	{
    		return x + y;
    	}
    }

此命名空间名字叫lcx，a是命名空间的成员变量，Add是命名空间的成员函数。

**命名空间还可以嵌套写：**

namespace l1
    {
    	int a = 10;
    	int b = 20;
    	namespace l2
    	{
    		int a = 30;
    		int b = 40;
    	}
    
    }

运行结果：

![3e6e44ba211242d8b729e6b5aee7373f.png][]

**同一个工程中，可以有多个相同名称的命名空间，编译器最后会合成一个命名空间：**

namespace l1
    {
    	int a = 10;
    }
    namespace l1
    {
    	int b = 40;
    }

**这里两个l1最后会合并为一个命名空间，所以两个同名命名空间内不能定义同名的变量，会发生冲突的。**

运行结果：

![93fbf92fd85612be12290d1884d2fe6b.png][]

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

### 2.2 命名空间的使用方式 ###

命名空间中定义的变量，函数该如何使用呢？

#### 2.2.1 加命名空间名称及作用域限定符 ####

namespace lcx
    {
    	int a = 10;
    
    	int Add(int x, int y)
    	{
    		return x + y;
    	}
    }

我们现在想打印a，并且调用Add函数，这里就需要用**域作用限定符:: ，命名空间名称+此符号+变量名/函数名，****就可以使用命名空间的变量/函数。**

举例：我们来打印上面代码的变量a，并调用函数Add。

namespace lcx
    {
    	int a = 10;
    
    	int Add(int x, int y)
    	{
    		return x + y;
    	}
    }
    int main()
    {
    	int ret = lcx::Add(2, 3);
    
    	cout << lcx::a << " " << ret << endl;
    
    	return 0;
    }

运行结果：

![b81a4834d7fa7c3888edbb9d96817d63.png][]

#### 2.2.2 使用using将命名空间中某个成员引入 ####

namespace lcx
    {
    	int a = 10;
    	int b = 20;
    
    	int Add(int x, int y)
    	{
    		return x + y;
    	}
    }

如果我们在平时练习的时候，我们多次使用变量a，每次打印的时候都使用 **lcx::a 这样打印太麻烦了，我们就可以用using+命名空间名称+ :: +变量名，这样展开某一个变量，后面在用的时候，就不用 lcx::a 这种形式写了。**

namespace lcx
    {
    	int a = 10;
    	int b = 20;
    
    	int Add(int x, int y)
    	{
    		return x + y;
    	}
    }
    using lcx::a;
    int main()
    {
    	cout << a << " " << lcx::b << endl;
    
    	return 0;
    }

运行结果：

![43e6c24e31c91797d60012d6932d9c79.png][]

#### 2.2.3 使用using namespace 命名空间名称引入 ####

我们在输出某个变量的值时，用到的cout，以及输入cin，其实是用的库函数，人家已经写好的，我们直接用就可以。

在我们平时练习的过程中，我们会大量的使用cin，cout，所以我们在开始的时候，直接就将含有这两个函数的命名空间展开，后面直接用就好了。

using namespace std;
    int main()
    {
    	int a = 10;
    	int b = 20;
    	cout << a << " " << b << endl;
    
    	return 0;
    }

我们这里打印局部变量a与b的时候用到了cout，endl，这都是C++标准模板库命名空间的函数，因此我们练习的时候直接把标准模板库的命名空间直接展开。

using namespace std;

**std就是C++标准模板库命名空间。**

## 3、C++输入与输出 ##

我们这里先简单学习一下C++的输入输出，先学会怎么使用，后面我们专门学习输入输出流。

我们用代码来看看：

#include <iostream>
    using namespace std;
    int main()
    {
    	int a = 0;
    	float b = 0.0f;
    
    	cin >> a >> b;//输入多个
    	cout << a << " " << b << endl;//输出多个
    
    	return 0;
    }

这里我们知道cin与cout分别是输入输出，那>>, <<两个符号是什么？

在C++中，>>是流提取运算符，<<是流插入运算符，输入和输出都是可以输入多个，输出多个的。endl就是C语言中'\\n'，是换行的意思。

![99cc16534a68795e94e0b569c7740af0.png][]

**说明：**

> 1. 使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含< iostream >头文件以及按命名空间使用方法使用std。  
> 2. cout和cin是全局的流对象，endl是特殊的C++符号，表示换行输出，他们都包含在包含<iostream >头文件中。  
> 4. 使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动控制格式。C++的输入输出可以自动识别变量类型。就像上面的代码，我们输入的时候直接cin>>a>>b，不用使用%d，%f。  
> 5. 实际上cout和cin分别是ostream和istream类型的对象，>>和<<也涉及运算符重载等知识，这些知识我们我们后续才会学习，所以我们这里只是简单学习他们的使用。后面我们还有有一个章节更深入的学习IO流用法及原理。

## 4、缺省参数 ##

### 4.1 缺省参数的概念 ###

在C语言中没有缺省参数一说，C++中的缺省参数是什么呢？

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

我们举例来看一下：

void func(int n = 10)
    {
    	cout << n << endl;
    }
    int main()
    {
    	func();  //不传参数的时候，使用func函数形参的默认值
    	func(1); //传参数，使用实参
    
    	return 0;
    }

> 这段代码中，第一次调用func函数的时候我们没有传参数，C语言中，这就会报错，但是C++是支持这样的，因为如果函数的形参有默认值的时候，调用函数不传参，就会使用形参的默认值。但在调用函数的时候，我们传了实参，这时就会以实参为准。缺德的来说，缺省参数就像是一个备胎一样。

### 4.2 缺省参数分类 ###

#### 4.2.1 全缺省参数 ####

> 全缺省参数就是函数的每个形参都有一个默认值，所以在调用函数的时候不用传实参，要传实参的话就必须从左到右依次去传。但是在传参的时候不能跳着传，例如下面：

void func(int a = 10, int b = 20, int c = 30)
    {
    	cout << a << " " << b << " " << c << endl;
    }
    int main()
    {
    	func(1);        //可以传一个
    	func(1, 2);     //可以传两个
    	func(1, 2, 3);  //可以全部传
    	//我们传参是从左到右依次传
    
    	return 0;
    }

运行结果：

![147d961b0120a25479a0422a61a3f33e.png][]

**跳着传参：**

![35786c5430c3457f4f1f18542c905d54.png][]

![ed27b2250880fbafc9d7b5764ae426aa.png][]

**C++缺省函数的调用压根就没有跳过传的概念，这样是不可以的。**

#### 4.2.2 半缺省参数 ####

> 半缺省是多个形参一部分给缺省值，但是给缺省值的时候必须从右往左缺省，也是不能跳着缺省。

![bc48b7095e2f0268d76575ebfa15272c.png][]

我们写一个代码来看看半缺省：

//半缺省
    void func(int a, int b = 20, int c = 30)
    {
    	cout << a << " " << b << " " << c << endl;
    }
    int main()
    {
    	func(1);        //第一个必须传
    	func(1, 2);     //第二个可以传，可以不传
    	func(1, 2, 3);  //后两个都是可传，可不传
    	//我们传参是从左到右依次传
    
    	return 0;
    }

运行结果：

![e936aaaebbfab9fd8086c5aa4623aec8.png][]

我们可以看到上面的代码中，我们写的func函数的第一个形参a是没有给默认值的，因此在调用的时候第一个参数必须传，不传就会出错。

**学会了缺省参数，那它的用途是什么呢？**

在栈中，我们使用的时候就已经知道我们要预先开辟1000个空间的时候，就可以使用缺省参数来写。

struct Stack
    {
    	int* a;
    	int size;
    	int capacity;
    };
    
    void StackInit(Stack* ps, int n = 4)
    {
    	assert(ps);
    	ps->a = (int*)malloc(sizeof(int) * n);
    	if (NULL == ps->a)
    	{
    		perror("malloc fail:");
    		return;
    	}
    
    	ps->size = 0;
    	ps->capacity = n;
    }
    
    int main()
    {
    	Stack st;
    	StackInit(&st, 1000);
    
    	return 0;
    }

这里我们就用到了半缺省参数，如果我们只是初始化，但是不知道多大空间合适，可以选择不传，初始化的时候只会开4个空间，也不会造成浪费。这就是缺省参数的灵活运用了。

## 5、函数重载 ##

### 5.1 函数重载概念 ###

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

a. 我们可以根据形参类型的不同但是函数名相同来调用函数。

int Add(int x, int y)
    {
    	return x + y;
    }
    double Add(double x, double y)
    {
    	return x + y;
    }
    int main()
    {
    	cout << Add(1, 2) << endl;
    	cout << Add(1.1, 2.2) << endl;
    
    	return 0;
    }

运行结果：

![49c695776b91d98de9659f2f4ebbdb91.png][]

上面的代码我们可以看到，虽然它们的名字都是Add，但是参数的类型不同，我们在调用的时候传入的实参会根据类型去调用名字相同但是类型不同的函数，**因此类型不同构成重载。**

b. 还可以根据形参类型顺序的不同但是函数名相同来调用函数。

void func(int x, double y)
    {
    	cout << "void func(int x, double y)" << endl;
    }
    void func(double x, int y)
    {
    	cout << "void func(double x, int y)" << endl;
    }
    int main()
    {
    	func(1, 1.1);
    	func(1.1, 1);
    
    	return 0;
    }

运行结果：

![43c2807806201d19a6d7c5d8983b397e.png][]

这里的两个func函数的形参都是一个整型，一个浮点型，但是两个形参的顺序不同，在函数调用的时候，传的实参会根据类型的不用在调用的时候，调用不同的函数，**因此参数顺序不同构成重载。**  
c. 参数个数不同，但函数名相同来调用函数。

void func(int x, double y)
    {
    	cout << "void func(int x, double y)" << endl;
    }
    void func(int x, double y, int z)
    {
    	cout << "void func(int x, double y, int z)" << endl;
    }
    int main()
    {
    	func(1, 1.1);
    	func(1.1, 1, 2);
    
    	return 0;
    }

运行结果：

![7080ede44c39f5e53b477969fc12341a.png][]

这里的参数个数不同，第一个函数两个参数，第二个函数三个参数，调用的时候传的参数个数不同，所调用的函数也就不同，**因此参数个数不同构成函数重载。**

**写到这了，肯定会有人想，那返回值类型不同是不是也可以构成重载呢？**

**我们先回答一下：不可以。我们来验证一下：**

short func(short x, short y)
    {
    	return x + y;
    }
    int func(short x, short y)
    {
    	return x + y;
    }

![278babef8f0003e50c02577bbbde637d.png][]

这里可以看到，返回类型不同无法构成重载。

**总结：****函数在名字相同的前提下，参数的类型不同，参数的顺序不同，参数的个数不同，这三个情况下都可以构成函数重载。**

### 5.2 C++支持函数重载的原理--名字修饰(name Mangling) ###

**为什么C++支持函数重载，而C语言不支持函数重载呢？**   
在C/C++中，一个程序运行起来需要经过四个阶段：预处理，编译，汇编，链接。

这四个阶段的流程分别是（以Linux的流程来说）：

> 1、预处理：头文件展开，宏替换，去掉注释，条件编译，生成test.i
> 
> 2、编译：检查语法，生成汇编（指令级代码），生成test.s
> 
> 3、汇编：将汇编代码转为二进制机器码，生成test.o
> 
> 4、链接：合并链接，生成可执行程序，a.out

C++函数重载主要就是在链接的时候用函数的名字找地址，C语言中用也是如此。但是C++引入了函数名修饰规则，这就是C++支持函数重载的根本原因。我们以Linux环境来展开说。

![a3951fa047adcd81fe27397d8e88ff0a.png][]

我们这里写了两个函数，构成函数重载。

在Linux下，g++有自己的一套函数名修饰规则，我们来看一下。

![d570f52a7e3f6940718991ca961732b5.png][]

结合上面的两个截图我们能总结出来，g++下的函数名修饰规则是：

> **\_Z 函数名长度 函数名 形参的首字母**

因此函数名就算相同，但是类型不同，顺序不同，个数不同都会产生不同的函数名。

![fd87802f510b5c3cf790cd01cf140dce.png][]

**函数调用的时候指令就是call 函数名，而修饰过的函数名跳转后会找到对应的函数的地址，这样就能找到对应的函数。这就是为什么函数名修饰规则修饰后，根据不同的函数名在符号便中找到对应的函数名，也就找到了对应的地址，最终跳转过去，调用对应函数的原因。**

C语言不行的原因是没有像C++这样的函数名修饰规则，它的函数名直接存放在符号表中，如果是相同的函数名，一进入符号表就乱了，它不会再加上类型的首字母这样区分函数，因此C语言实现不了函数重载。

[8686df0d75284aecb900036c03bf663c.gif]: https://img-blog.csdnimg.cn/8686df0d75284aecb900036c03bf663c.gif
[f57ac13dcee89cd306ce351d27aa7260.png]: https://img-blog.csdnimg.cn/img_convert/f57ac13dcee89cd306ce351d27aa7260.png
[12d773c99a600d6d501e041f187fa95e.png]: https://img-blog.csdnimg.cn/img_convert/12d773c99a600d6d501e041f187fa95e.png
[3e6e44ba211242d8b729e6b5aee7373f.png]: https://img-blog.csdnimg.cn/img_convert/3e6e44ba211242d8b729e6b5aee7373f.png
[93fbf92fd85612be12290d1884d2fe6b.png]: https://img-blog.csdnimg.cn/img_convert/93fbf92fd85612be12290d1884d2fe6b.png
[b81a4834d7fa7c3888edbb9d96817d63.png]: https://img-blog.csdnimg.cn/img_convert/b81a4834d7fa7c3888edbb9d96817d63.png
[43e6c24e31c91797d60012d6932d9c79.png]: https://img-blog.csdnimg.cn/img_convert/43e6c24e31c91797d60012d6932d9c79.png
[99cc16534a68795e94e0b569c7740af0.png]: https://img-blog.csdnimg.cn/img_convert/99cc16534a68795e94e0b569c7740af0.png
[147d961b0120a25479a0422a61a3f33e.png]: https://img-blog.csdnimg.cn/img_convert/147d961b0120a25479a0422a61a3f33e.png
[35786c5430c3457f4f1f18542c905d54.png]: https://img-blog.csdnimg.cn/img_convert/35786c5430c3457f4f1f18542c905d54.png
[ed27b2250880fbafc9d7b5764ae426aa.png]: https://img-blog.csdnimg.cn/img_convert/ed27b2250880fbafc9d7b5764ae426aa.png
[bc48b7095e2f0268d76575ebfa15272c.png]: https://img-blog.csdnimg.cn/img_convert/bc48b7095e2f0268d76575ebfa15272c.png
[e936aaaebbfab9fd8086c5aa4623aec8.png]: https://img-blog.csdnimg.cn/img_convert/e936aaaebbfab9fd8086c5aa4623aec8.png
[49c695776b91d98de9659f2f4ebbdb91.png]: https://img-blog.csdnimg.cn/img_convert/49c695776b91d98de9659f2f4ebbdb91.png
[43c2807806201d19a6d7c5d8983b397e.png]: https://img-blog.csdnimg.cn/img_convert/43c2807806201d19a6d7c5d8983b397e.png
[7080ede44c39f5e53b477969fc12341a.png]: https://img-blog.csdnimg.cn/img_convert/7080ede44c39f5e53b477969fc12341a.png
[278babef8f0003e50c02577bbbde637d.png]: https://img-blog.csdnimg.cn/img_convert/278babef8f0003e50c02577bbbde637d.png
[a3951fa047adcd81fe27397d8e88ff0a.png]: https://img-blog.csdnimg.cn/img_convert/a3951fa047adcd81fe27397d8e88ff0a.png
[d570f52a7e3f6940718991ca961732b5.png]: https://img-blog.csdnimg.cn/img_convert/d570f52a7e3f6940718991ca961732b5.png
[fd87802f510b5c3cf790cd01cf140dce.png]: https://img-blog.csdnimg.cn/img_convert/fd87802f510b5c3cf790cd01cf140dce.png