前言

在正式进入C++之前，我们首先要对C++有一个基本的认知。这里我就不过多的进行描述了，有兴趣的可以去网络搜索一番。总而言之，从名称上面我们也可以看得出来，C++是在C的基础上进行不断地优化发展。事实上确实是这样，C语言中90％以上的语法在C++中都适用。

同时我们还要知道C++作为众多编程语言中的一种，它的排名始终是位于前列的，并且涉及到的领域也是非常的多，就比如以下几个领域：操作系统以及大型系统软件开发、服务器端开发、嵌入式和物联网领域、游戏开发、人工智能、分布式应用......由此我们可见C++的重要性。接下来我们话不多说，进入正题。

命名空间

首先我们来看C语言中的下面这一段代码：

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

int rand = 10;
int main()
{
    printf("%d ", rand);
    return 0;
}
//运行后会报错：error C2365 : “rand”: 重定义；以前的定义是“函数”

这里报错是因为我们定义的变量rand，它与库函数里的rand函数名称发生了冲突，在C语言中，对于此类问题是无法得到有效解决的，除非就是自己换一个名称，但是在C++中针对此类问题是可以通过命名空间（关键字：namespace）得到解决的。

域

在了解命名空间之前，我们先来了解一下域这个概念，我们目前所知的域就是全局作用域以及局部作用域，局部域与全局域的使用以及生命周期都是不同，局部域作用于局部，只能在局部使用（一般都是自己所在的{}内），生命周期出了作用域就会自动销毁。而全局域则是作用于整个工程，生命周期也是随着工程的结束而结束。 并且当局部与全局冲突时，局部优先。

就比如下面这段代码：

#include<stdio.h>
int a = 10;//作用于全局
void test()
{
    int a = 20;//只能在{}内使用
    printf("%d ", a);//局部与全局冲突时，局部优先，这里的a优先在局部域内查找，
                     //如果找不到再去全局查找a进行匹配，如果全局还是没找到，则报错
                     //这里优先在局部匹配到了20，所以打印结果为20
}

int main()
{
    test();
    return 0;
}

但是假如一定要在test（）中打印的a是位于全局的a，而不是局部a，应如何做呢？这里就涉及到了：：（作用域限定符）如下：

#include<stdio.h>
int a = 10;//作用于全局
void test()
{
    int a = 20;//只能在{}内使用
    printf("%d ", a);//局部与全局冲突时，局部优先，这里的a优先在局部域内查找，
                     //如果找不到再去全局查找a进行匹配，如果全局还是没找到，则报错
                     //这里优先在局部匹配到了20，所以打印结果为20
    printf("%d ", ::a);
    // ::前面有个空格，意思为在全局域中查找a进行匹配，这里的印出来的是10
}

int main()
{
    test();
    return 0;
}

命名空间

了解域后，接下来我们来讲一下命名空间，它的关键字为namespace，具体使用namespace{}，花括号内为命名空间的成员。它的作用是命名空间域，也就是说将命名空间内的所有成员作为一个域，但是注意一点，就是命名空间域只影响成员的使用，但是不影响生命周期。如下：

namespace qdy
{
    // 命名空间中可以定义变量/函数/类型
    int rand = 10;
    int Add(int x, int y)
    {
        return x + y;
    }
    struct Node
    {
        struct Node* next;
        int val;
    };
}

了解它的用法后，接下来我们该怎么使用命名空间呢？具体有三种方法：

1. 用using将命名空间全局展开（在做项目时不建议使用，做练习时可以）

2. 利用：：指定命名空间（ 一般做项目时使用此方式）

3. 用using +：：将命名空间常用展开

//命名空间全局展开
using namespace std;//std为C++标准库
//指定命名空间
std::cout << "hellow world\n" << std::endl;
//命名空间常用展开
using std::cout;
using std::endl;

举个例子，还是上面的rand，假如我想自己使用自己的rand，避免和库函数中的rand发生命名冲突，可以这么来用：

#include<iostream>
#include<stdlib.h>
namespace qdy
{
    int rand = 10;
}
int main()
{
    qdy::rand++;//这里的rand与qdy域里的rand进行匹配，也就是10++，即11
    printf("%d ", qdy::rand);//打印结果为11
    return 0;
}

同样，假如我们在与他人同时进行某一项工程时，最后为了避免与他人发生命名冲突，我们就可以利用命名空间来完美解决这个问题，但是假如放在C语言的环境下，这个问题是解决不了的，只能有一方主动服软，改成不一样的名字才行。如下：

#include<iostream>
struct Node
{
    struct Node* left;
    struct Node* right;
    int val;
};
namespace qdy
{
    struct Node
    {
        struct Node* next;
        int val;
    };
}

int main()
{
    struct qdy::Node Q;//这里上面两个结构体命名发生冲突都是叫Node
                       //但是我们想要用下面的Node，就可以利用命名空间
                       //这里的    Q就是指下面的结构体
    return 0;
}

C++输入/输出

相信在我们入门C语言时的hello world是梦开始的地方，在C语言中的输入输出为scanf与printf，接下来我们看下面这样一段简单的代码：

#include<iostream>
using namespace std;

int main()
{
    int n = 0;
    cin >> n;
    for (int i = 0; i < n; i++)
    {
        cout << "hello world" << endl;
    }
    return 0;
}

这段代码执行后的结果是这样的：

在这里我们要知道：

1. cout标准输出对象（写到控制台）以及cin标准输入对象（从键盘中读取）它们两个的作用正是对应着C语言里的printf以及scanf。而endl的作用就相当于C语言里的\n（换行符）

2. <<是流插入运算符，>>是流提取运算符

3. 在C语言中我们使用scanf与printf时，要手动加上固定的格式，比如输入一个字符串，要加上%s，输入一个整形，要加%d，浮点型%f等。但是C++中的输入输出则不需要手动输入格式，C++中的输入输出会自动识别类型。

4. 在使用cout以及cin与endl时需要包含头文件<iostream>,并且要按照命名空间的使用方式来使用std，std为C++标准库。

缺省参数

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

参则采用该形参的缺省值，否则使用指定的实参。(C语言不支持缺省参数)

具体是咋回事呢？我们通过一段代码即可理解：

#include<iostream>
using namespace std;
void test(int a = 10)
{
    cout << a << endl;
}

int main()
{
    test();//10，这里我没有传参数，但是函数形参里定义了int a=10,所以输出的就是10
    test(20);//20，这里我们传送参数20，虽然形参里定义了a=10，但是由于我们传了参数，所以a=10就相当于形同虚设
                   //因此这里打印的是20
}

是不是很好理解，（举个不起恰当的例子，缺省参数有点类似生活中的”备胎“，当没有别的选择时，才用的到你，但是只要有人出现，你就gg了）

另外缺省参数还分为全缺省参数以及半缺省参数，所谓全缺省参数就是函数的形参全都有指定的值，而半缺省参数则是只有一部分的形参有指定值。如下：

//全缺省参数
void Func(int a = 10, int b = 20, int c = 30);
//半缺省参数
void Func(int a,int b=10, int c=20);

//这里需要注意，半缺省参数必须从右往左依次来给出，不能间隔着给，即不可以写成（int a=10,int b,int c=30）这种形式
//另外：缺省参数不能在函数声明和定义中同时出现（切记）

函数重载

首先我们先了解一下什么是重载，中国语言博大精深，往往同一个词在不同的情况下有不同的意义，就比如说，我们在夸赞一个人时对他说：你可真行，但是当一个人把事情搞砸时，我们再对他说：你可真行。

这里，同样的语句却截然不同的意义，这就是重载。

函数重载则是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这

些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同，常用来处理实现功能类似数据类型

不同的问题。就比如下面的代码：

1. 参数类型不同

// 1、参数类型不同
//都为int
int Add(int left, int right)
{
 cout << "int Add(int left, int right)" << endl;
 return left + right;
}
//都为double
double Add(double left, double right)
{
 cout << "double Add(double left, double right)" << endl;
 return left + right;
}
int main()
{
    Add(1,2);//3
    Add(1.1.2.2);//3.3
//不会报错，但如果是在C语言的环境下，则会报错：Add重定义，具体原因后面会讲
    return 0;
}

2. 参数个数不同

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

3. 形参的类型顺序不同

//int 在前char在后
void f(int a, char b)
{
    cout << "f(int a,char b)" << endl;
}
//char在前，int 在后
void f(char b, int a)
{
    cout << "f(char b, int a)" << endl;
}

可能我们会有个疑问，为什么C语言不支持，而C++却支持呢？这里涉及到了函数名修饰规则，这里由于windows下的命名规则太过繁杂，我们在Linux环境下进行演示。我们知道，一个程序要运行起来要经历以下几个阶段：预处理、编译、汇编、链接，而在链接阶段，链接器是如何来寻找我们调用的Add函数呢？答案是通过编译器的函数名修饰规则，这里我们分别演示C和C++两种环境下链接器是如何查找Add的。

因此我们得出结论：在linux下，采用gcc编译完成后，函数名字的修饰没有发生改变。

接下来我们观察C++环境下：

通过这里就理解了C语言没办法支持重载，因为同名函数没办法区分。而C++是通过函数修

饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。另外：

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

法区分。

---

end

生活原本沉闷，但跑起来就会有风！ 🌹