【C++初阶】C++基础（上）——C++关键字、命名空间、C++输入&输出、缺省参数、函数重载

末蓝、 2023-10-13 22:36 55阅读 0赞

**目录**

1. C++关键字

2. 命名空间

2.1 命名空间的定义

2.2 命名空间的使用

3. C++输入&输出

4. 缺省参数

4.1 缺省参数概念

4.2 缺省参数分类

5. 函数重载

5.1 函数重载概念

5.2 C++支持函数重载的原理——名字修饰（name Mingling）

5.3 extern "C"

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

**❀❀❀**没有坚持的努力，本质上并没有多大的意义。

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

## 1. C++关键字 ##

C++总计63个关键字，C语言32个关键字

![6f41079cc0d54d55aed2543db2722f24.png][]

> \#include <iostream> 相当于C语言中的 \#include<stdio.h>

## 2. 命名空间 ##

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

同一个作用域里面，是不能有同名变量的。

**命名冲突**，在C语言没有很好的解决这个问题，但是CPP引入了**namespace**来解决这个问题。

使用 **命名空间**的目的是 **对标识符的名称进行本地化**，以 **避免命名冲突或名字** **污染（一个命名空间就定义了一个新的作用域）**

> ::域作用限定符

**命名空间可以定义变量**

#include <iostream>
    //这是一个命名空间，可以定义变量、函数、类型
    namespace ky
    {
    	int a = 0;
    	int c = 2;
    }
    
    int b = 0;
    int c = 1;
    
    int main()
    {
    	int b = 1;
    	int a = 1;
    	printf("%d\n", b);//b = 1,访问局部变量
    	printf("%d\n", ::b);//b = 0, 访问全局变量//::域作用限定符
    	printf("%d\n", a);//a = 1;
    	printf("%d\n", ky::a);//a = 0;
    	printf("%d\n", c);//1
    	printf("%d\n", ::c);//1
    	printf("%d\n", ky::c);//2
    	return 0;
    }

**命名空间可以定义函数、类型**

#include <iostream>
    namespace yyqx
    {
    	//定义函数
    	void f()
    	{
    		printf("void f()\n");
    	}
    	//定义结构
    	struct ListNode
    	{
    		int val;
    		struct ListNode* next;
    	};
    
    }
    
    namespace ky
    {
    	struct ListNode
    	{
    		int val;
    		struct ListNode* next;
    	};
    
    }
    
    int f = 0;
    int main()
    {
    	printf("%d\n", f);//0
    	printf("%p\n", yyqx::f);//结构体的地址
    	yyqx::ListNode* n1 = NULL;
    	ky::ListNode*  n2 = NULL;
    	return 0;
    }

**命名空间可以嵌套而且同名的命名空间是可以同时存在的，编译器编译时会将其合并。**

**代码1展示：**

#include <iostream>
    
    namespace yyqx
    {
    	int a = 1;
    	namespace A
    	{
    		struct Node
    		{
    			int val = 0;
    			struct Node* next= NULL;
    		};
    	}
    	
    }
    
    namespace yyqx
    {
    	int b = 1;
    	namespace B
    	{
    		struct Node
    		{
    			int val = 0;
    			struct Node* next = NULL;
    		};
    	}
    	
    }
    
    int main()
    {
    	struct yyqx::A::Node n1;
    	struct yyqx::B::Node n2;
    
    	return 0;
    }

命名空间不影响生命周期，是全局变量还是全局变量，只是命名发生冲突时，进行隔离的作用。【命名空间只能放在全局】

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

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

> （1）**加命名空间名称及作用域限定符**
> 
> **（2）使用****using****将命名空间中某个成员引入** 
> 
>     using yyqx::a;//代码1//释放yyqx命名空间里面的变量a
>     //释放的是命名空间就加namespace，如果释放的不是命名空间而是命名空间里的数据，就不用加namespace
> 
> **（3）使用****using namespace** **命名空间名称引入**
> 
> **\[我们经常使用第二种，既不会容易发生冲突，又不会特别麻烦\]**

using namespace yyqx;//意思是把yyqx这个命名空间定义的内容释放出来
    int main()
    {
    	struct A::Node n1;
    	struct B::Node n2;
    
    	return 0;
    }

using namespace yyqx;//意思是把yyqx这个命名空间定义的内容释放出来
    using namespace A;//第二层释放
    //因为A在yyqx里面，所以上面两行的内容不能进行交换
    int main()
    {
    	struct Node n1;
    	struct B::Node n2;
    
    	return 0;
    }

这里代码释放A，就不能释放B，否则就发生命名冲突（using相当于没有命名空间）

>     using namespace yyqx::A；
> 
> 这个代码相当于释放A,但是并没有释放yyqx;

>      using namespace std;//std 封C++库的命名空间

## 3. C++输入&输出 ##

#include <iostream>
    using namespace std;
    
    int main()
    {
    	int a = 0;
    	cin >> a;// >>流提取运算法，相当于scanf
    	cout << a;// << 流插入运算法
    
    	return 0;
    }

![f736304fbe4348ea8c5d80e0a7fd6aa4.png][]

#include <iostream>
    using namespace std;
    
    int main()
    {
    	int a = 0;
    	double b = 0;
    	cin >> a >> b;// >>流提取运算法，相当于scanf
    	cout << a << " " << b << endl;// << 流插入运算法 endl相当于换行
    	cout << a << ":" << b << '\n';
    	cout << "hello world" << endl;
    	return 0;
    }

![7d77ecd32319495e8b30df747217fb16.png][]

> （1）endl相当于换行'\\n'
> 
> （2）<assert.h>在C++中也可以用，但是没有命名空间，<cassert>就有命名空间了
> 
> （3）使用 **cout** **标准输出对象** **(** **控制台** **)**和 **cin** **标准输入对象** **(** **键盘** **)**时，必须 **包含** **< iostream >** **头文件**以及 **按命名空间使用方法使用std**。
> 
> （4）C++的输入输出可以自动识别变量类型。
> 
> （5）旧编译器(vc 6.0)中还支持<iostream.h>格式，<iostream.h>格式没有命名空间

## 4. 缺省参数 ##

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

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

#include <iostream>
    using namespace std;
    
    //缺省参数(默认参数)
    void Test(int a = 0)
    {
    	cout << a << endl;
    }
    
    int main()
    {
    	Test();//没有传参时，使用参数的默认值a = 0
    	Test(1);//传参时，使用指定的实参 a = 1;
    }

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

**（1）全缺省参数（全默认参数）**

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

**（2）半缺省参数**

void Test(int a , int b = 20, int c = 30)//必须从右向左缺省，并且是连续的
    {
    	cout << "a = " << a << endl;
    	cout << "b = " << b << endl;
    	cout << "c = " << c << endl;
    }

> 1. 半缺省参数必须 **从右往左依次**来给出，不能间隔着给
> 
> 2. 缺省参数不能在函数声明和定义中同时出现（最好在声明给；声明不给，定义给也不可以）
> 
> 3.缺省值必须是常量或者全局变量
> 
> 4. C语言不支持（编译器不支持）

## 5. 函数重载 ##

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

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

**函数重载的条件：函数名相同、参数不同**

**（1）参数类型不同**

int Add(int left, int right)
    {
    	return left + right;
    }
    double Add(double left, double right)
    {
    	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;
    }

> C语言不支持同名函数，CPP支持同名函数。要求：参数名相同，参数不同

代码：

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

上述代码不是函数重载，因为函数进行调用的时候，并不知道要调用哪一个函数。（仅仅只有返回值不同是不能构造函数重载的）函数重载要求参数不同。而跟返回值没关系。

### 5.2 C++支持函数重载的原理——名字修饰（name Mingling） ###

C语言不支持重载，C++支持重载。C++是如何支持的？为什么C语言不支持？

> 在C/C++中，一个程序要运行起来，需要经历以下几个阶段： **预处理（预编译）、编译、汇编、链接**。
> 
> **预处理**：头文件展开、宏替换、条件编译、去掉注释
> 
> **编译**：检查语法、生成汇编代码
> 
> **汇编**：把汇编代码转换成二进制的机器码
> 
> **链接**：找调用函数的地址，链接对应上，合并到一起

> （1）实际项目通常是由多个头文件和多个源文件构成，【当前a.cpp中调用了b.cpp中定义的Add函数时】，编译**后**链接**前**，a.o的目标文件中没有Add的函数地址，因为Add是在b.cpp中定义的，所以Add的地址在b.o中。那么怎么办呢？
> 
> （2） 所以链接阶段就是专门处理这种问题， **链接器看到** **a.o** **调用** **Add** **，但是没有** **Add** **的地址，就会到** **b.o** **的符** **号表中找** **Add** **的地址，然后链接到一起**。

//函数1
    void f(int a, double b)
    {
    	printf("%d %lf\n", a, b);
    }
    //函数2
    void f(double b, int a)
    {
    	printf("%lf %d\n", b, a);
    }

链接的时候，有符号表和函数调用指令。

C语言中，函数1和函数2，生成的符号表，都是f，所以会发生冲突，所以会发生错误，C语言就不支持函数重载

![7aeefed0ff684eee9d861ca101284f6e.png][]

但是在C++中，函数1和函数2生成的符号表是不同的，所以C++就支持函数重载

![c074e78564e740fda267fa62b960ed56.png][]

![4b515e60b69e46338450fc267853be40.png][]

> 总而言之还是函数修饰后的名字不同，C语言中仍然是函数名，而C++中是【\_Z+函数长度+函数名+类型首字母（如果是指针就多加一个P）】**通过这里就理解了****C****语言没办法支持重载，因为同名函数没办法区分。而****C++****是通过函数修饰规则来区****分，只要参数不同，修饰出来的名字就不一样，就支持了重载**。

### 5.3 extern "C" ###

在C语言中，extern "C" 可以添加在函数声明的前面，也可以extern "C"后添加一个花括号，然后把函数声明括起来

**在函数前加** **extern "C"，作用是告诉编译器，将该函数按照C** **语言规则来编译。**

> C语言是可以调用C++和C语言的静态库和动态库的。C++是可以调用C++和C语言的静态库和动态库的。

> C++调用C静态库：（虽然C++兼容C，为什么需要用到extern "C"呢？因为函数的命名修饰是不一样的，所以想调用C的函数的时候，符号表找不到我们想要的内容）
> 
>     extern "C"
>     {
>         #include "../../Stack_C/Stack_C/stack.h"
>     }
> 
> 然后，右击属性->链接器->常规->附加库目录->找到静态库文件,最后右击属性->链接器->输入->附加依赖项Stack\_C.lib；即可

> C语言调用C++：（C中没有extern "C"，只有C++有）
> 
> 在C++的文件中，函数前面添加EXTERN\_C（这个是随意定义的），然后前面再写一个条件编译（\_\_cplusplus是C++中）\[两个杠\]
> 
> 【（第一种写法）条件编译：当在C++中，函数前面经过宏替换就是extern "C"，在C语言中，就相当于什么也没有】
> 
> ![5c31b9b43684420780f373b0fbfc92d4.png][]
> 
> （第二种写法）
> 
> ![714ce9e48e5a4a5c8842e96671468dd8.png][]
> 
> 然后，右击属性->链接器->常规->附加库目录->找到静态库文件,最后右击属性->链接器->输入->附加依赖项Stack\_CPP.lib；即可

[6f41079cc0d54d55aed2543db2722f24.png]: https://img-blog.csdnimg.cn/6f41079cc0d54d55aed2543db2722f24.png
[f736304fbe4348ea8c5d80e0a7fd6aa4.png]: https://img-blog.csdnimg.cn/f736304fbe4348ea8c5d80e0a7fd6aa4.png
[7d77ecd32319495e8b30df747217fb16.png]: https://img-blog.csdnimg.cn/7d77ecd32319495e8b30df747217fb16.png
[7aeefed0ff684eee9d861ca101284f6e.png]: https://img-blog.csdnimg.cn/7aeefed0ff684eee9d861ca101284f6e.png
[c074e78564e740fda267fa62b960ed56.png]: https://img-blog.csdnimg.cn/c074e78564e740fda267fa62b960ed56.png
[4b515e60b69e46338450fc267853be40.png]: https://img-blog.csdnimg.cn/4b515e60b69e46338450fc267853be40.png
[5c31b9b43684420780f373b0fbfc92d4.png]: https://img-blog.csdnimg.cn/5c31b9b43684420780f373b0fbfc92d4.png
[714ce9e48e5a4a5c8842e96671468dd8.png]: https://img-blog.csdnimg.cn/714ce9e48e5a4a5c8842e96671468dd8.png