【C++ 入门】：从语言发展脉络到实战细节 —— 详解命名空间、输入输出、缺省参数与函数重载

一、什么是C++

​

C 语言是结构化和模块化的语言，适合处理较小规模的程序。对于复杂的问题，规模较大的程序，需要高度的抽象和建模时，C 语言则不合适。为了解决软件危机， 20 世纪 80 年代， 计算机界提出了 OOP(objectoriented programming：面向对象) 思想 ，支持面向对象的程序设计语言应运而生。

1982 年 ， Bjarne Stroustrup 博士在 C 语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言。为了表达该语言与C 语言的渊源关系，命名为 C++ 。因此： C++ 是基于 C 语言而产生的，它既可以进行 C 语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程 序设计 。

二、C++发展史

1979年，贝尔实验室的本贾尼等人试图分析unix内核时候，试图将内核模块化，于是在C语言的基础上进行扩展，增加了类的机制，完成了一个可以运行的预处理程序，称之为C with classes。

C++基于C语言进一步扩充和完善，容纳进去了面向对象编程思想，并增加了许多有用的库，以及编程范式等。

三、命名空间

3.1 命名空间的定义

在 C++ 中，变量、函数和类等实体数量众多，若都置于全局作用域，可能引发严重的命名冲突问题，导致程序出错。命名空间可将这些实体的名称限定在特定范围内，避免不同代码模块间的命名冲突，提高代码的可维护性和可复用性。

C语⾔项⽬类似下⾯程序这样的命名冲突是普遍存在的问题，C++引⼊namespace就是为了更好的解决这样的问题：

#include <stdio.h>
#include <stdlib.h>
int rand = 10;
int main()
{
    // 编译报错：: “rand”: 重定义；以前的定义是“函数” 
    printf("%d\n", rand);
    return 0;
}

因为在标准库里有rand这个函数，在预处理阶段把头文件拷贝过来，在全局域就有两个rand了，所以编译器认为rand“重定义”

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

// 1. 正常的命名空间定义
namespace ayj
{
     // 命名空间中可以定义变量/函数/类型
     int rand = 10;
     int Add(int left, int right)
     {
         return left + right;
     }
 

//2. 命名空间可以嵌套
// test.cpp
namespace N1
{
    int a;
    int b;
    int Add(int left, int right)
    {
        return left + right;
    }
    namespace N2
    {
         int c;
         int d;
         int Sub(int left, int right)
         {
             return left - right;
         }
    }
}

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

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

问题：为啥namespace只能定义在全局 ？ 因为命名空间解决的就是全局域里名字冲突的情况，而局部域本来自带就有隔离，所以没有必要使用

3.2 命名空间的访问

编译查找⼀个变量的声明/定义时，默认只会在局部或者全局查找，不会到命名空间⾥⾯去查找。所以我们要使⽤命名空间中定义的变量/函数，有三种⽅式：

namespace N
{
 // 命名空间中可以定义变量/函数/类型
     int a = 0;
     int b = 1;
     int Add(int left, int right)
     {
         return left + right;
 
     }

     struct Node
     {
         struct Node* next;
         int val;
     };
}


// 1、指定命名空间访问
int main()
{
    printf("%d\n", N::a);
    return 0; 
}


// 2、using将命名空间中某个成员展开
using N::b;
int main()
{
    printf("%d\n", N::a);
    printf("%d\n", b);
    return 0; 
}


// 3、展开命名空间中全部成员 
using namespce N;
int main()
{
    printf("%d\n", a);
    printf("%d\n", b);
    return 0; 
}

:: 域作用限定符使用规则： 1、::左边是空白，默认优先访问全局域 2、::左边是类，默认优先访问类域 3、::左边是命名空间，默认优先访问命名空间域 4、不加::默认优先访问局部域

四、C++输入、输出

要使用 C++ 进行输入输出操作，首先需要引入<iostream>头文件，这个头文件包含了实现输入输出功能的核心工具，比如cout（用于标准输出，也就是将内容显示到控制台）、cin（用于标准输入，即从键盘接收数据）以及endl（用于输出时换行）。这些工具都属于std（标准库）命名空间，所以通常会加上using namespace std;` 这句话，简化代码书写。

最经典的 “Hello World” 程序示例：

#include <iostream>
using namespace std;

int main() {
    cout << "Hello world!!!" << endl;
    return 0;
}

这里cout作为标准输出对象，配合<<（流插入运算符）将字符串传递到输出流，endl实现换行。

输入输出综合示例（处理多种类型变量）：

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

这段代码中，cin配合>>（流提取运算符）从输入流提取数据，自动识别变量类型（如int、double、char），无需手动指定格式符，输出时也同理。

关于using namespace std;的使用：日常练习可直接使用，简化代码；大型项目建议显式指定（如std::cout）或单独展开所需工具（如using std::cin;），避免命名冲突。cout和cin还有控制精度、进制等进阶用法，可按需查阅文档深入学习。

五、缺省参数

在 C++ 函数设计中，缺省参数是一项提升灵活性的特性，它允许我们为函数参数指定默认值，让函数调用更加便捷。

5.1 缺省参数概念

缺省参数是在声明或定义函数时为函数的参数指定一个缺省值。调用该函数时，若未指定实参，则采用形参的缺省值；若指定了实参，则使用指定的实参。

示例代码：

#include <iostream>
using namespace std;

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

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

5.2 缺省参数分类

缺省参数主要分为以下两类：

5.2.1 全缺省参数

函数的所有参数都指定了缺省值。示例：

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

5.2.2 半缺省参数

函数的部分参数指定缺省值，且必须从右往左依次给出，不能间隔着给。示例：

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

5.3 缺省参数的注意事项

使用缺省参数时，需注意以下几点：

• 半缺省参数的顺序：必须从右往左依次给出，不能间隔着给。
• 声明与定义的冲突：缺省参数不能在函数声明和定义中同时出现。若同时出现且缺省值不同，编译器无法确定使用哪个值。示例：

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

// a.cpp
void Func(int a = 20)
{}

• 缺省值的类型：缺省值必须是常量或者全局变量。
• 语言支持性：C 语言不支持缺省参数（编译器不支持）
• 函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省值。

六、函数重载

在 C++ 中，函数重载是一项强大的特性，它允许我们在同一作用域中定义多个功能类似的同名函数，通过参数的差异来区分它们。

6.1 函数重载概念

函数重载是指在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表（参数个数、类型或类型顺序）不同，常用于处理功能类似但数据类型不同的场景。

示例代码：

#include <iostream>
using namespace std;

// 1. 参数类型不同
int Add(int left, int right)
{
    cout << "int Add(int left, int right)" << endl;
    return left + right;
}

double Add(double left, double right)
{
    cout << "double Add(double left, double right)" << endl;
    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;
}

int main()
{
    Add(1, 2);
    Add(1.1, 2.2);
    f();
    f(10);
    f(10, 'a');
    f('a', 10);
    return 0;
}

6.2 C++是如何支持函数重载的？

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

【程序编译过程概述】：

在 C/C++ 领域，一个程序从代码走向可执行文件，需历经预处理、编译、汇编、链接这几个关键阶段。预处理主要负责处理诸如 #include 指令、宏定义等内容；编译则是将高级语言代码转换为汇编语言；汇编把汇编语言进一步转化为机器语言，生成目标文件；链接阶段会把多个目标文件以及链接库整合起来，形成最终的可执行程序。实际项目往往由多个头文件和源文件构成，不同源文件生成的目标文件中函数地址分散，链接器的重要任务就是将它们正确关联起来。

【名字修饰规则差异】：

Linux 下 gcc 与 g++ 的表现：采用 C 语言编译器 gcc 编译时，函数名字的修饰基本不会发生改变。而 C++ 编译器 g++ 则不同，它会将函数参数类型信息添加到修改后的名字中。例如，在 Linux 环境下对简单的 Add 函数和 func 函数进行编译分析，通过 objdump 工具查看编译后的符号表，能清晰看到 g++ 修饰后的函数名呈现出 【Z + 函数长度 + 函数名 + 类型首字母】 的形式。这使得编译器和链接器能够依据参数类型来区分同名函数。

Windows 下名字修饰规则：Windows 下 Visual C++ 的名称修饰规则相对复杂。以 int N::func(int) 函数签名为例，修饰后的名字包含了函数调用类型、名称空间、参数类型等诸多信息。函数名以 “?” 开头，接着是函数名 “C” 和名称空间 “N” 等相关标识，函数调用类型 “_cdecl” 以 “A” 表示 ，参数类型及返回值等信息也融入其中，最后以 “Z” 结尾。这种复杂的修饰方式同样是为了让编译器和链接器能有效区分不同函数。

结论1 （采用C语言编译器）： 在 linux 下，采用 gcc 编译完成后，函数名字的修饰没有发生改变。

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

6.3 为啥c++支持函数重载，C语言不支持函数重载？