目录

一. 前言

二. 什么是C++

三. C++关键字初探

四. 命名空间

4.1 为什么要引入命名空间

4.2 命名空间的定义

4.3 命名空间使用

五. C++的输入输出

六. 缺省参数

6.1 缺省参数的概念

6.2 缺省参数的分类

七. 函数重载 

7.1 函数重载的概念

7.2 函数重载的条件

7.3 C++支持函数重载的原因

一. 前言

        旧坑未填，新坑又起。今天我们又要开启一个新的系列：C++深入浅出。振奋人心的C++学习终于来了在本系列中，你能感受到C++相比C语言特有的魅力，尽管学习的过程中可能会充满坎坷，但风雨之后，仰望天空，即使没有彩虹，也会是睛空。学完C++后，你甚至可以在C++中用短短几行代码就搞定C语言几十上百行的代码，是不是很神奇，这还只是C++其中的一个强大之处哦。所以，不要恐惧，让我们一起怀着激动的心情打开C++的大门吧

二. 什么是C++

        C语言是结构化和模块化的语言，适合处理较小规模的程序。对于复杂的问题，规模较大的
程序，需要高度的抽象和建模时，C语言则不合适。为了解决软件危机， 20世纪80年代， 计算机
界提出了OOP(object oriented programming：面向对象)思想，支持面向对象的程序设计语言
应运而生。
        1982年，Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念，发明了一
种新的程序语言。为了表达该语言与C语言的渊源关系，命名为C++。因此：C++是基于C语言而
产生的，它既可以进行C语言的过程化程序设计(C++兼容C语言)，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。

三. C++关键字初探

        在C语言的学习过程中，我们前前后后一共学到了32个关键字。而C++作为C语言的扩展，一共多达63个关键字，如下表所示：

 注：这里稍微知道一下有这些关键字即可，后面学到具体应用时再进行细讲

四. 命名空间

4.1 为什么要引入命名空间

在写C语言代码时，你是否写过类似这样的代码：

#include<stdio.h>
#include<stdlib.h>

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

当你Ctrl+F5兴冲冲的编译运行时，发现不解情的编译器报出了重定义的错误：

由于预处理阶段会将头文件进行展开，而在我们的stdlib.h头文件中存在着名为rand的随机数函数，而C语言是不允许在相同作用域下定义多个同名符号的，因此会报出重定义的错误。

#include<stdio.h>
#include<stdlib.h>

int rand = 0; //前面已经将rand全局定义为函数，这里又定义为全局变量，顾重定义
int main()
{
	int rand = 0; //这里rand是局部变量，作用域不同，局部优先，因此不会报错
	rand(); //由于rand是局部优先，这里的rand是个局部变量，顾无法作为函数使用，报错
	printf("%d", rand);
	return 0;
}

在上面的代码中，我们无论将rand定义成全局变量还是局部变量，都无法实现我们想要的效果，那怎么办呢？将rand变量的名字换一个呗，得不到就不要强求啦

---

但是在C++中，新增了命名空间来对标识符的名称进行本地化，以避免命名冲突或名字污染，上面的问题就被很好的解决了。

所以说，努力拓展提升自己，能力够了自然也就得到了

4.2 命名空间的定义

定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可。{}中的内容即为命名空间的成员。命名空间内的成员可以是变量，也可以是函数、类型，甚至可以是另一个命名空间。

namespace Dream //namespace关键字 + 命名空间名称
{
	//命名空间内定义变量
	int a;
	int b = 10;

	//命名空间内定义函数
	int add(int x,int y)
	{
		return x + y;
	}

	//命名空间内定义类型
	struct Stack
	{
		int* a;
		int top;
		int capacity;
	};

	//命名空间嵌套定义
	namespace other
	{
		int a;
		int b = 10;
	}

}

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

此外， 如果我们在同一工程中定义了两个相同名称的命名空间(无论在哪个文件)，编译器最终会合并到同一个命名空间中

//test1.cpp
namespace Dream
{
	int a = 5;
	int b = 10;
}

//test2.cpp
namespace Dream
{
	int Add(int x, int y)
	{
		return x + y;
	}
}

//上面两个同名命名空间编译器最终会进行合并，结果如下：
namespace Dream
{
	int a = 5;
	int b = 10;

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

4.3 命名空间使用

那么，定义了命名空间后，我们要如何使用它呢？如果我们直接对命名空间的成员进行访问，编译器会报错：

#include<stdio.h>
namespace Dream
{
	int b = 10;
}
int main()
{
	printf("%d", b); //报错，b只在Dream作用域内有效
	return 0;
}

 我们一般有一下三种使用方法：

1、变量名前加命名空间名称及作用域限定符

namespace Dream
{
	int b = 10;
	namespace other
	{
		int b = 5;
	}
}

int main()
{
	printf("%d", Dream::b); //表示Dream命名空间内的b，即输出10
    printf("%d", Dream::other::b); //表示Dream命名空间内的other命名空间内的b，即输出5
	return 0;
}

分析：两个变量b虽然名称相同，但被划分到了两个命名空间中，作用域不同，因此不会出现重定义的问题。并且，通过在前面加上对应的命名空间我们可以实现对这两个变量b的访问。

2、使用using将命名空间中某个成员展开

      但是如果命名空间中的某个变量需要在程序中频繁的进行使用，每次都要在前面加上命名空间未免显得过于繁琐，因此C++还允许我们使用using关键字将命名空间中某个成员展开

namespace Dream
{
	int a = 5;
	int b = 10;
}

using Dream::a;

//int a = 10;  //由于上方将变量a展开，a的作用域相当于全局，这里如果再定义a会重定义
int main()
{
	a += 10; //引入了a，顾不需要再前面加上命名空间
	printf("%d\n", a);
	printf("%d", Dream::b); //而变量b没有展开，故需加上命名空间
	return 0;
}

3、使用using naespace 将整个命名空间展开

      当然，如果你愿意的话，你也可以将整个命名空间展开，这样整个命名空间的东西都将暴露在全局。具体方式如下

namespace Dream
{
	int a = 5;
	int b = 10;
}

using namespace Dream; //展开后使用命名空间内的变量就无需再加前缀
int main()
{
	a += 10;
	printf("%d\n", a);
	printf("%d", b);
	return 0;
}

        下面，我们再来看看许多C++程序中经常出现的写法就很清楚了：

#include<iostream>
using namespace std;
int main()
{
	return 0;
}

• 第一条语句的作用是包含输入输出流，下面我们会进行说明，这里我们可以暂且将理解为C语言的#include<stdio.h>
• 第二条语句是不是很熟悉啦，没错，就是用来展开命名空间std的。std的英文全拼是Standard，即标准的意思。C++标准程序库中的所有标识符都被定义在这个命名空间中。顾这里将整个命名空间引入是为了后续更方便的使用C++标准程序库的标识符，如函数、类型等等。

---

但是，虽然方便，但在实际工程中并不建议直接将整个命名空间展开。原因是在大规模工程中，定义的变量太多，可能会出现定义的变量名与std命名空间的标识符出现重复的情况，此时如果将std全部展开就会出现重定义的BUG。

---

故比起将命名空间全部展开，我们更推荐使用第一种或者第二种使用方式。

 五. C++的输入输出

在学习C语言时，我们写的第一个代码就是hello world，那么在我们第一次接触C++时，是不是也应该使用C++对美好的世界打个招呼呢？我们来试试C++是怎么实现输入输出的吧！

#include<iostream>
using namespace std; //展开std命名空间
int main()
{
	cout << "hello world!!!" << endl; //打印输出
	return 0;
}

 下面我们来分析分析上面的代码

---

1、使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含<iostream>头文件
以及按命名空间使用方法使用std。是的，iostream也是一个头文件噢。

2、cout和cin是全局的流对象，它们分别是ostream和istream类型的对象。而endl是特殊的C++符号，表示换行输出，他们都包含在包含在<iostream>头文件中。

3、<<是流插入运算符，>>是流提取运算符。它们是不是和我们C语言学到的左移和右移一模一样？是的，这实际上是一种运算符重载，我们后续会提到。

4、使用C++输入输出更方便，不需要像printf/scanf输入输出时那样需要手动控制格式，即%d、%f等等。C++的输入输出可以自动识别变量类型。

---

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

六. 缺省参数

6.1 缺省参数的概念

      缺省参数是声明或定义函数时为函数的参数指定一个缺省值(默认值)。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参。具体形式如下：

#include<iostream>
using namespace std;

void Func(int a = 0) //给定缺省值0
{
	cout << a << endl;
}

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

6.2 缺省参数的分类

       缺省参数分为全缺省参数和半缺省参数

       全缺省参数

       即所以参数都带有缺省值

void Func(int a = 10, int b = 20, int c = 30)
{
    cout<<"a = "<<a<<endl;
    cout<<"b = "<<b<<endl;
    cout<<"c = "<<c<<endl;
}
int main()
{
	Func(); 
	Func(10); 
    Func(20,30,40); 
	return 0;
}

       半缺省参数

        即部分参数都带有缺省值

void Func(int a, int b = 10, int c = 20) //除了a其余参数都有缺省值
{
    cout<<"a = "<<a<<endl;
    cout<<"b = "<<b<<endl;
    cout<<"c = "<<c<<endl;
}

int main()
{
	Func();  //错误调用，第一个参数没有缺省值，需要传参
	Func(10); //第一个参数传入10，其余参数用缺省值
    Func(20,30,40); //全部用指定的实参
	return 0;
}

        注意事项

• 规定半缺省参数必须从右往左依次给出，不能间隔着给。示例如下：

  //错误写法，必须从右往左不间断
  void Func(int a = 10, int b, int c) {};
  void Func(int a = 10, int b = 20, int c) {};
  void Func(int a = 10, int b, int c = 30) {};
  
  //正确写法
  void Func(int a, int b, int c = 30) {};
  void Func(int a, int b = 20, int c = 30) {};

• 缺省参数不能在函数声明和定义中同时出现。其目的是为了防止我们在声明和定义中给出了不同的缺省值，从而导致歧义。

  //错误的写法
  //test.h
  void Func(int a = 10);
  // a
  test.cpp
  void Func(int a = 20)
  {}

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

• C语言不支持带缺省参数的函数（编译器不支持）

七. 函数重载 

7.1 函数重载的概念

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

假设我们要写一个Add函数实现两个整型以及两个浮点型的相加，在C语言中，我们应该这么写：

//C语言写法
int iAdd(int x, int y)
{
	return x + y;
}
double dAdd(double x, double y)
{
	return x + y;
}
int main()
{
	iAdd(1, 2);
	dAdd(1.0, 2.0);
	return 0;
}

由于实参的类型不同，我们需要写两个Add函数分别实现整形和浮点型的相加，并且为了避免重定义，两个函数名必须不同，难道这不觉得很别扭吗

而C++引入了函数重载，我们就能很舒服的使用相同名称来定义这两个参数不同的函数：

//C++写法，两个Add函数构成函数重载
int Add(int x, int y)
{
	return x + y;
}

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

int main()
{
	Add(1, 2);
	Add(1.0, 2.0);
	return 0;
}

7.2 函数重载的条件

       C++构成函数重载的条件是形参列表必须不同。形参列表不同分为以下三种：

        1、参数个数不同

#include<iostream>
using namespace std;
//2、参数个数不同
void Fun(int x)
{
	cout << "void Fun(int x)" << endl;
}
void Fun()
{
	cout << "void Fun()" << endl;
}

int main()
{
	Fun(1); //调用第一个
	Fun(); //调用第二个
}

        2、参数类型不同

#include<iostream>
using namespace std;
//2、参数类型不同
int Add(int x, int y)
{
	cout << "int Add(int x, int y)" << endl;
	return x + y;
}
double Add(double x, double y)
{
	cout << "double Add(double x, double y)" << endl;
	return x + y;
}

int main()
{
	Add(1, 2); //调用第一个
	Add(1.0, 2.0); //调用第二个
}

        3、参数顺序不同

#include<iostream>
using namespace std;
//3、参数顺序不同
void Fun(int x , double y)
{
	cout << "void Fun(int x , double y)" << endl;
}
void Fun(double x, int y)
{
	cout << "void Fun(double x, int y)" << endl;
}

int main()
{
	Fun(1,2.0); //调用第一个
	Fun(2.0,1); //调用第二个
}

注意：是参数类型的顺序不同，而不是变量名顺序不同，即以下写法不构成函数重载：

//变量名顺序不同不构成函数重载，形参的名称只是标识，本质上还是同一个函数
void Fun(int x , double y){};
void Fun(int y , double x){};

         4、缺省函数的重载

         此外，带缺省参数的函数也可以构成函数重载，编译并不会报错，但使用上可能会出现一些很尴尬的问题，举例如下

#include<iostream>
using namespace std;
//4、缺省函数的重载
void Fun(int x, double y = 1.0)
{
	cout << "void Fun(int x , double y = 1.0 )" << endl;
}
void Fun(int x)
{
	cout << "void Fun(int x)" << endl;
}
int main()
{
	Fun(1, 2.0); //这里会调用第一个函数没问题
	Fun(1); //此时既可以调用第一个函数，也可以调用第二个函数，存在歧义，会报错
}

由于缺省函数的重载很容易引发歧义，顾我们一般不也会这么写  

7.3 C++支持函数重载的原因

        可能会有很多小伙伴会疑惑：为什么C++支持函数重载，而C语言不支持函数重载呢？、

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

我们发现，每个.c文件都会生成属于自己的符号表。main.c文件中sum函数只是声明，故在符号表中并没有sum函数的地址。而sum.c文件中的sum函数是定义，故在符号表中存在着sum函数的地址。当链接器进行链接时，就会将两张符号表进行合并，此时符号表中既有main函数的地址，也有sum函数的地址，程序便可以正常运行。

---

但是，如果两个文件中的sum函数都是定义呢？如下： 

由于两个符号表中的sum函数都是有效地址，进行符号表合并后，符号表就会出现上面的相同符号不同地址的情况，会引发符号表的歧义，此时我们就不知道该去哪个地方找sum函数了，会报重定义的错误。

 这就是为什么C语言不能定义同名函数的原因：重定义会引发符号表的歧义。

那就有人会想：C语言不行，那凭什么放到C++就可以呢，搞特殊？

首先要说明的是，上面的两个Add函数放到C++依然不构成函数重载，因为它们的类型相同。那C++为什么类型不同就允许同名函数的存在呢？这是因为C++引入了函数名修饰规则，函数在符号表中除了名称，还一并将参数类型代入修饰。

不同的编译器下的函数名修饰规则可能有所不同，由于VS的函数名修饰规则过于复杂，下面我们采用Linux下的g++来进行演示

源代码清单

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

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

int main()
{
    return 0;
}

采用gcc编译(C语言)

为了正确进行编译，将第一个Add函数改为Add1，第二个改为Add2。编译后查看汇编代码如下：

采用g++编译(C++)

Linux系统下的g++编译器将函数修饰后变成【_Z+函数长度+函数名+类型首字母】的形式，形参的个数、顺序以及类型不同都会使得修饰后的函数名不同

 总结提炼

1. 在linux下，采用gcc编译完成后，函数名字没有发生改变。
2. 在linux下，采用g++编译完成后，函数名字的修饰发生改变，编译器将函数参数类型信息添加到修改后的名字中。
3. C语言没办法支持重载是因为同名函数没办法区分。而C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，顾支持重载。
4. 如果两个函数仅仅是返回值不同是不构成重载的，因为调用时编译器没办法区分。

以上，就是本期的全部内容啦🌸

制作不易，能否点个赞再走呢🙏