参考：

C++ 命名空间 | 菜鸟教程 (runoob.com)

命名空间

假设这样一种情况，当一个班上有两个名叫 Zara 的学生时，为了明确区分它们，我们在使用名字之外，不得不使用一些额外的信息，比如他们的家庭住址，或者他们父母的名字等等。

同样的情况也出现在 C++ 应用程序中。例如，您可能会写一个名为 xyz() 的函数，在另一个可用的库中也存在一个相同的函数 xyz()。这样，编译器就无法判断您所使用的是哪一个 xyz() 函数。

因此，引入了命名空间这个概念，专门用于解决上面的问题，它可作为附加信息来区分不同库中相同名称的函数、类、变量等。使用了命名空间即定义了上下文。本质上，命名空间就是定义了一个范围。

我们举一个计算机系统中的例子，一个文件夹(目录)中可以包含多个文件夹，每个文件夹中不能有相同的文件名，但不同文件夹中的文件可以重名。

定义命名空间

命名空间的定义使用关键字namespace，后跟命名空间的名称，如下所示：

namespace namespace_name { // 代码声明 }

为了调用带有命名空间的函数或变量，需要在前面加上命名空间的名称，如下所示：

name::code; // code 可以是变量或函数

注意，这里又看到了范围解析运算符的另一种用法，那就是用来调用某个属于对应变量空间的变量或者函数。

让我们来看看命名空间如何为变量或函数等实体定义范围：

#include <iostream> using namespace std; // 第一个命名空间 namespace first_space{ void func(){ cout << "Inside first_space" << endl; } } // 第二个命名空间 namespace second_space{ void func(){ cout << "Inside second_space" << endl; } } int main () { // 调用第一个命名空间中的函数 first_space::func(); // 调用第二个命名空间中的函数 second_space::func(); return 0; }

当上面的代码被编译和执行时，它会产生下列结果：

Inside first_space Inside second_space

可以多个C++文件中声明同一个命名空间吗？

在 C++ 中，可以（且常见）在多个文件中声明同一个命名空间。命名空间的定义是允许分散在多个源文件（.cpp）或头文件（.h）中的，编译器最终会将同一命名空间的所有内容合并。这是 C++ 模块化设计的重要特性之一。

基本规则

同一命名空间的内容会被自动合并，即使分布在不同的文件中。

可以多次声明同一命名空间，每次声明都是向该命名空间添加新成员。

通常做法：

在头文件（.h）中声明命名空间及其接口。

在源文件（.cpp）中实现命名空间内的函数/类。

注意事项

避免重复定义：

同一命名空间的成员定义（如函数实现）只能出现在一个源文件中（否则链接错误）。

声明（如函数原型）可以重复出现在多个头文件中。

命名污染风险：

不同库的命名空间可能冲突（如MyLib::Logger和YourLib::Logger）。

解决方法：使用嵌套命名空间或更独特的名称（如Company::Project::Module）。

大型项目的组织：

推荐按模块划分命名空间：

在 C++ 中，若类在头文件中被命名空间包裹，则实现文件中必须使用相同的命名空间，以确保函数定义与声明匹配。以下是详细说明：

一、必须保持命名空间一致

头文件中的类声明位于命名空间内，实现文件中必须用相同的命名空间包裹实现，否则会导致链接错误（Linker Error）。

示例：正确做法

// MyClass.h（头文件） namespace MyNamespace { class MyClass { public: void func(); }; } // MyClass.cpp（实现文件） #include "MyClass.h" namespace MyNamespace { // 必须使用相同的命名空间 void MyClass::func() { /* 实现 */ } }

错误示例

// MyClass.cpp（错误写法） #include "MyClass.h" // 未使用命名空间 void MyClass::func() { /* 实现 */ } // 错误！定义了全局命名空间的 MyClass::func

为什么必须使用命名空间？

C++ 编译器将函数签名视为命名空间::类名::函数名(参数)。若实现文件中未指定命名空间，编译器会认为你在定义一个全局命名空间中的同名函数，而非头文件中声明的那个。

using 指令

您可以使用using namespace指令，这样在使用命名空间时就可以不用在前面加上命名空间的名称。这个指令会告诉编译器，后续的代码将使用指定的命名空间中的名称。

#include <iostream> using namespace std; // 第一个命名空间 namespace first_space{ void func(){ cout << "Inside first_space" << endl; } } // 第二个命名空间 namespace second_space{ void func(){ cout << "Inside second_space" << endl; } } using namespace first_space; int main () { // 调用第一个命名空间中的函数 func(); return 0; }

当上面的代码被编译和执行时，它会产生下列结果：

Inside first_space

using 指令也可以用来指定命名空间中的特定项目。例如，如果您只打算使用 std 命名空间中的 cout 部分，您可以使用如下的语句：

using std::cout;

注意，这中间没有namespace，不是using namespace std::cout，后面的std::cout并不是命名空间，别搞混了！！！

随后的代码中，在使用 cout 时就可以不用加上命名空间名称作为前缀，但是std命名空间中的其他项目仍然需要加上命名空间名称作为前缀，如下所示：

实例

#include <iostream> using std::cout; int main () { cout << "std::endl is used with std!" << std::endl; return 0; }

当上面的代码被编译和执行时，它会产生下列结果：

std::endl is used with std!

using指令引入的名称遵循正常的范围规则。名称从使用using指令开始是可见的，直到该范围结束。此时，在范围以外定义的同名实体是隐藏的。

实际开发中，需要在开头写上using namespace std;吗，一般一个文件中应该会用到很多命名空间的吧？

先说结论

大型工程、正式项目：尽量不要写using namespace std;；小型 Demo、测试脚本、单文件小程序可以随便写。而且：C++ 里并不会 “用到一大堆命名空间”，绝大多数业务代码日常打交道的就一个std；其他嵌套子命名空间（std::chrono、std::filesystem）使用频率低，有更优雅的写法。

核心矛盾：using namespace xxx是把这个命名空间里所有名字全部导入到当前作用域，会带来名字污染（命名冲突）。

---

几种写法对比，按推荐优先级排序

方案 1：全限定名（✅ 大型项目首选，推荐）

直接写std::，不导入：

#include <iostream> #include <vector> int main() { std::vector<int> vec; std::cout << "hello\n"; return 0; }

优点：

• 完全没有名字冲突风险，一眼就能分清这个符号来自标准库；
• 别人读代码，立刻知道std::cout是标准库，不是自己写的函数；缺点：多敲几个字符。

方案 2：using 单独导入你需要的符号（⭐折中方案，最常用！）

只导入你真正要用的那几个，而不是整个 std：

#include <iostream> #include <vector> using std::cout; using std::vector; int main() { vector<int> vec; cout << "hello\n"; return 0; }

✅ 这个是工业界很受欢迎的折中：既不用到处写std::，又不会把 std 几千个名字全拉进来，污染范围很小。如果还要用std::chrono::seconds：

using std::chrono::seconds;

方案 3：using namespace std;（⚠️ 慎用）

using namespace std;

坏处举例：名字撞车假设你自己写了一个函数 / 类叫count、list、sort、max：

#include <algorithm> using namespace std; void sort() { // 完蛋！std::sort 也存在，名字冲突，编译报错/行为诡异 }

std 里面包含非常多通用单词：list, map, set, sort, find, count, swap, min, max，这些词业务代码里太容易起名撞上。

什么时候可以放心写using namespace std;

• 刷题、LeetCode、练习 Demo、单文件小测试；
• 简单的 main 程序，代码很短，不会有复杂自定义类型；
• 教学示例（为了简化代码）。

什么时候绝对不要写

• 头文件 (.h/.hpp) 里面！！重点红线如果头文件写了using namespace std;，任何#include这个头的文件，都会强制被导入 std，污染扩散到整个项目，灾难级。👉 头文件里，永远禁止using namespace xxx！

方案 4：别名 namespace（长命名空间简化，适合 std 子空间）

碰到std::filesystem、std::ranges::views这种很长的嵌套命名空间：

namespace fs = std::filesystem; namespace views = std::ranges::views;

之后直接用fs::path、views::filter。✅ 这个非常推荐！只起别名，不导入任何名字，没有污染，是处理长嵌套命名空间的最佳实践。

---

回答你第二个疑问：会不会用到很多命名空间？

正常业务代码：

1. 标准侧：主体就是std，它下面的子命名空间chrono/filesystem/ranges按需单独引入，不会一次性一大堆；
2. 自己项目：一般会给自己模块定义专属命名空间，比如namespace app {}、namespace net {}；
3. 第三方库：比如boost::xxx、opencv::cv、nlohmann::json，也是独立命名空间。

对于第三方库，同样遵循上面规则：

• 优先写cv::Mat；
• 或者namespace cv = cv;别名；
• 尽量避免using namespace cv;（OpenCV 里面名字巨多，冲突高发）

嵌套的命名空间

命名空间可以嵌套，您可以在一个命名空间中定义另一个命名空间，如下所示：

namespace namespace_name1 { // 代码声明 namespace namespace_name2 { // 代码声明 } }

您可以通过使用::运算符来访问嵌套的命名空间中的成员：

// 访问 namespace_name2 中的成员 using namespace namespace_name1::namespace_name2; // 访问 namespace_name1 中的成员 using namespace namespace_name1;

在上面的语句中，如果使用的是 namespace_name1，那么在该范围内 namespace_name2 中的元素也是可用的，如下所示：

#include <iostream> using namespace std; // 第一个命名空间 namespace first_space{ void func(){ cout << "Inside first_space" << endl; } // 第二个命名空间 namespace second_space{ void func(){ cout << "Inside second_space" << endl; } } } using namespace first_space::second_space; int main () { // 调用第二个命名空间中的函数 func(); return 0; }

更多待补充。

std是什么？

std其实就是个是个命名空间，C++标准库中的函数或者对象都是在命名空间std中定义的，所以我们要使用标准函数库中的函数或对象都要使用std来限定。

标准库在名字空间中被指定为std，所以在使用标准库中的函数或者对象的时候要加上std::，这样编译器就会明白我们调用的函数或者对象是名字空间std中的。

一种更简单的方法，不需要写std::

直接使用using namespace std来代替std::。

using namespace std 告诉编辑器我们将要使用空间std中的函数或者对象。如：

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

C++ 标准只有一个顶层标准命名空间：std；剩下全是嵌套在 std 里面的子命名空间，另外还有一个隐式的全局命名空间（::），不是写出来的名字，是默认的。

编译器自带的那些带下划线__xxx的命名空间（__gnu_cxx、std::__detail）属于实现内部私有空间，标准不规定，业务代码不要碰GCC。

1. 全局命名空间（隐式）

没有名字，所有不在任何 namespace 里的符号都在这里，用::func显式访问。main()就必须放在全局命名空间。

2. std（顶层标准命名空间，核心）

所有 C++ 标准库（iostream、vector、string、algorithm）都在std下。

std::cout; std::vector<int> v;

3. std 下面常用嵌套标准命名空间（重点，你写代码会用到）

命名空间	头文件	作用	示例
std::chrono	<chrono>	时间、时长、时钟（C++11）	std::chrono::seconds
std::literals	多个头	字面量总入口（inline 命名空间）	包含下面几个 xxx_literals
std::literals::chrono_literals	<chrono>	时间字面量后缀：10s、5ms	using namespace std::literals::chrono_literals; auto t = 30s;
std::literals::string_literals	<string>	字符串字面量""s，生成 std::string	auto str = "abc"s;
std::literals::complex_literals	<complex>	复数字面量i
std::placeholders	<functional>	bind 的占位符_1, _2, _3（C++11）	std::bind(func, std::placeholders::_1)
std::filesystem	<filesystem>	文件系统（C++17）	std::filesystem::path，别名std::fs
std::ranges	<ranges>	范围库（C++20），视图、管道	std::ranges::views，别名std::views
std::numbers	<numbers>	数学常量 π、e（C++20）	std::numbers::pi
std::pmr	<memory_resource>	多态内存分配器（C++17）	内存池
std::execution	<execution>	并行执行策略（C++17）	std::execution::par

4. 容易混淆：不是标准规定、编译器扩展的命名空间（GCC/Clang 特有，不要写业务代码依赖）

• __gnu_cxx：GNU 扩展
• __gnu_pbds：GCC policy-based data structure（红黑树等扩展容器）
• __gnu_debug：调试版本 STL
• std::__cxx11、std::__detail：STL 内部实现细节，标准没定义，版本一变就炸，禁止直接使用GCC

5. 补充几个误区

• ❌ 没有单独叫iostream、vector的命名空间！它们只是类型 / 类名，不是命名空间，都属于 std。
• ❌namespace std不是关键字内置硬编码，是标准库头文件里面定义出来的；你不 include 标准头，std 里面是空的。
• inline 命名空间（literals 系列）：它的特点是里面的东西自动可以当成父命名空间成员，主要给字面量设计。
• C 语言库（<cstdio>）的函数也放在std；老式<stdio.h>会放到全局命名空间。

命名空间可以放哪些内容

在C++中，命名空间（namespace）确实可以用来组织代码，防止命名冲突，以下是命名空间的主要特性和限制：

可以包含的内容

变量和常量

namespace MyNS { int x = 42; const double PI = 3.14159; }

函数

namespace MyNS { void foo() { /* ... */ } }

类和结构体

namespace MyNS { class MyClass { /* ... */ }; struct MyStruct { /* ... */ }; }

其他命名空间（嵌套命名空间）

namespace MyNS { namespace Inner { void bar() { /* ... */ } } }

模板

namespace MyNS { template<typename T> T max(T a, T b) { return a > b ? a : b; } }

类型别名（typedef/using）

namespace MyNS { typedef std::vector<int> IntVec; using Str = std::string; }

枚举（enum/enum class）

namespace MyNS { enum Color { Red, Green, Blue }; enum class Status { Ok, Error }; }

不能直接包含的内容

非声明性语句（如直接执行的代码）

namespace MyNS { int a = 10; a++; // 错误！不能直接写可执行代码 void func() { a++; } // 正确：函数内可以包含逻辑 }

预处理指令（如#include、#define）

#include <iostream> // 正确 namespace MyNS { #include "file.hpp" // 极不推荐！可能引发混乱 }

显式的内存管理（如new/delete语句）
这些必须放在函数或类方法中。

总结

命名空间可以包含变量、函数、类、模板、嵌套命名空间等声明性内容，但不能直接包含可执行代码或预处理指令。它是逻辑上的代码组织工具，而非运行时实体。总体来说，就是不要放过程性的内容。 所以，命名空间后面跟着的可能是类，也可能是函数，也可能是变量，命名空间只是限定对象的范围，而不是限定具体是什么内容。

异常处理

异常是程序在执行期间产生的问题。C++ 异常是指在程序运行时发生的特殊情况，比如尝试除以零的操作。

异常提供了一种转移程序控制权的方式。C++ 异常处理涉及到三个关键字：try、catch、throw。

• throw:当问题出现时，程序会抛出一个异常。这是通过使用throw关键字来完成的。

• catch:在您想要处理问题的地方，通过异常处理程序捕获异常。catch关键字用于捕获异常。

• try:try块中的代码标识将被激活的特定异常。它后面通常跟着一个或多个 catch 块。

如果有一个块抛出一个异常，捕获异常的方法会使用try和catch关键字。try 块中放置可能抛出异常的代码，try 块中的代码被称为保护代码。使用 try/catch 语句的语法如下所示：

抛出异常

您可以使用throw语句在代码块中的任何地方抛出异常。throw 语句的操作数可以是任意的表达式，表达式的结果的类型决定了抛出的异常的类型。

以下是尝试除以零时抛出异常的实例：

double division(int a, int b) { if( b == 0 ) { throw "Division by zero condition!"; } return (a/b); }

异常抛出后，就可以让调用者去捕获处理。

捕获异常

catch块跟在try块后面，用于捕获异常。您可以指定想要捕捉的异常类型，这是由 catch 关键字后的括号内的异常声明决定的。

try { // 保护代码 }catch( ExceptionName e ) { // 处理 ExceptionName 异常的代码 }

上面的代码会捕获一个类型为ExceptionName的异常。如果您想让 catch 块能够处理 try 块抛出的任何类型的异常，则必须在异常声明的括号内使用省略号 ...，如下所示：

try { // 保护代码 }catch(...) { // 能处理任何异常的代码 }

下面是一个实例，抛出一个除以零的异常，并在 catch 块中捕获该异常。

#include <iostream> using namespace std; double division(int a, int b) { if( b == 0 ) { throw "Division by zero condition!"; } return (a/b); } int main () { int x = 50; int y = 0; double z = 0; try { z = division(x, y); cout << z << endl; }catch (const char* msg) { cerr << msg << endl; } return 0; }

由于我们抛出了一个类型为const char*的异常，因此，当捕获该异常时，我们必须在 catch 块中使用 const char*。当上面的代码被编译和执行时，它会产生下列结果：

Division by zero condition!

更多待补充

动态内存

了解动态内存在 C++ 中是如何工作的是成为一名合格的 C++ 程序员必不可少的。C++ 程序中的内存分为两个部分：

• 栈：在函数内部声明的所有变量都将占用栈内存。

• 堆：这是程序中未使用的内存，在程序运行时可用于动态分配内存。

很多时候，您无法提前预知需要多少内存来存储某个定义变量中的特定信息，所需内存的大小需要在运行时才能确定。

在 C++ 中，您可以使用特殊的运算符为给定类型的变量在运行时分配堆内的内存，这会返回所分配的空间地址。这种运算符即new运算符。

如果您不再需要动态分配的内存空间，可以使用delete运算符，删除之前由 new 运算符分配的内存。

new 和 delete 运算符

下面是使用 new 运算符来为任意的数据类型动态分配内存的通用语法：

new data-type;

在这里，data-type可以是包括数组在内的任意内置的数据类型，也可以是包括类或结构在内的用户自定义的任何数据类型。让我们先来看下内置的数据类型。例如，我们可以定义一个指向 double 类型的指针，然后请求内存，该内存在执行时被分配。我们可以按照下面的语句使用new运算符来完成这点：

double* pvalue = NULL; // 初始化为 null 的指针 pvalue = new double; // 为变量请求内存

如果自由存储区已被用完，可能无法成功分配内存。所以建议检查 new 运算符是否返回 NULL 指针，并采取以下适当的操作：

double* pvalue = NULL; if( !(pvalue = new double )) { cout << "Error: out of memory." <<endl; exit(1); }

malloc()函数在 C 语言中就出现了，在 C++ 中仍然存在，但建议尽量不要使用 malloc() 函数。new 与 malloc() 函数相比，其主要的优点是，new 不只是分配了内存，它还创建了对象。

在任何时候，当您觉得某个已经动态分配内存的变量不再需要使用时，您可以使用 delete 操作符释放它所占用的内存，如下所示：

delete pvalue; // 释放 pvalue 所指向的内存

下面的实例中使用了上面的概念，演示了如何使用 new 和 delete 运算符：

#include <iostream> using namespace std; int main () { double* pvalue = NULL; // 初始化为 null 的指针 pvalue = new double; // 为变量请求内存 *pvalue = 29494.99; // 在分配的地址存储值 cout << "Value of pvalue : " << *pvalue << endl; delete pvalue; // 释放内存 return 0; }

更多待补充。

数组的动态内存分配

假设我们要为一个字符数组（一个有 20 个字符的字符串）分配内存，我们可以使用上面实例中的语法来为数组动态地分配内存，如下所示：

char* pvalue = NULL; // 初始化为 null 的指针 pvalue = new char[20]; // 为变量请求内存

要删除我们刚才创建的数组，语句如下：

delete [] pvalue; // 删除 pvalue 所指向的数组

下面是 new 操作符的通用语法，可以为多维数组分配内存，如下所示：

一维数组

// 动态分配,数组长度为 m int *array=new int [m]; //释放内存 delete [] array;

二维数组

int **array; // 假定数组第一维长度为 m， 第二维长度为 n // 动态分配空间 array = new int *[m]; for( int i=0; i<m; i++ ) { array[i] = new int [n]; } //释放 for( int i=0; i<m; i++ ) { delete [] array[i]; } delete [] array;

更多待补充。

对象的动态内存分配

对象与简单的数据类型没有什么不同。例如，请看下面的代码，我们将使用一个对象数组来理清这一概念：

#include <iostream> using namespace std; class Box { public: Box() { cout << "调用构造函数！" <<endl; } ~Box() { cout << "调用析构函数！" <<endl; } }; int main( ) { Box* myBoxArray = new Box[4]; delete [] myBoxArray; // 删除数组 return 0; }

如果要为一个包含四个 Box 对象的数组分配内存，构造函数将被调用 4 次，同样地，当删除这些对象时，析构函数也将被调用相同的次数（4次）。

当上面的代码被编译和执行时，它会产生下列结果：

调用构造函数！ 调用构造函数！ 调用构造函数！ 调用构造函数！ 调用析构函数！ 调用析构函数！ 调用析构函数！ 调用析构函数！

更多待补充。

根据以上内容，我们不要以为new只能用来创建对象，new是一个通用的分配内存空间的机制。

new和malloc的区别

基本区别

特性	new(C++)	malloc(C)
语言	C++ 运算符	C 标准库函数 (<cstdlib>)
返回类型	返回具体类型的指针（如int*）	返回void*（需强制类型转换）
内存大小计算	自动计算类型大小（如new int）	需手动计算字节数（如malloc(sizeof(int))）
初始化	支持构造函数初始化（如new int(5)）	仅分配内存，不初始化内容
失败处理	抛出std::bad_alloc异常	返回NULL（C11 后可用aligned_alloc）
内存来源	可重载（自定义operator new）	不可重载

---

关键差异总结

类型安全

new返回类型化指针，无需强制转换；malloc返回void*，需显式转换。

初始化

new可初始化对象（调用构造函数）；malloc仅分配原始内存。

错误处理

new抛异常；malloc返回NULL（需检查）。

重载能力

new/delete可重载；malloc/free不可重载。

---

何时使用？

用new/delete：

C++ 代码中优先使用（尤其是类对象）。

需要自动构造/析构、类型安全或自定义内存管理时。

用malloc/free：

与 C 代码交互时。

需要直接操作原始内存（如实现底层数据结构）。

---

在 C++ 中，优先使用new/delete，除非有特殊需求（如兼容 C 或手动管理原始内存）。new更安全、更符合面向对象的设计，而malloc更接近底层操作。