namespace

C++ 命名空间 | 菜鸟教程

C++命名空间（名字空间）详解

作用：多写在头文件中
    
    
    
，用于多个头文件的变量函数出现重命名    
    
    
。

namespace中可以定义变量     


     


     


，函数 




 




 




 ，类等等

   

   

   
，也可以写声明     

     

     

，来防止与其他文件重复（就只有这一个作用  




  




  




 ，没有其他的特殊点） 


     


     


     。

使用示例：

main.cpp

#include <iostream> #include "main.h" int main(){ int a=1; Diy::Student stu1; stu1.name = "小明"; stu1.age = 15; stu1.score = 92.5f; stu1.say(); return 0; }

main.h

#ifndef UNTITLED1_MAIN_H #define UNTITLED1_MAIN_H #include <cstdio> namespace Diy{ int a=1; class Student{ public: char *name; int age; float score; public: void say(){ printf("%s的年龄是 %d


  


  


  
，成绩是 %f\n", name, age, score); } }; } #endif //UNTITLED1_MAIN_H

main.h里面定义了a和Student（不是声明）     
     
     
，这是不规范的   




   




   




 ，很容易造成类的重复定义



 



 



 
，变量的重复定义

使用 using namespace

通常我们会用到using namespace std这种               ，std命名空间本在iostream标准库中被定义    




    




    




 ，using namespace std的意思就是将std中的东西全部拆出来















，放到本文件中               ，可以直接调用

 




 




 



。

比如之前写成

std::cout

现在写成

cout就行   

   

   

。

using 指令引入的名称遵循正常的范围规则  

     

     

    。名称从使用 using 指令开始是可见的     



     



     



 ，直到该范围结束


  




  




  


。此时














，在范围以外定义的同名实体是隐藏的  


  


  


。

不连续的命名空间

就是命名空间可以是多次添加东西的

比如a文件

namespace Diy{ int a=1; }

b文件

namespace Diy{ int b=1; }

分别引入a和b最终就会自动合成为

namespace Diy{ int a=1;    int b=1; }

头文件

下面正式介绍头文件

内容参考自理解 C++ 中的头文件和源文件的作用 | 菜鸟教程

一
    
    
    
、C++ 编译模式与为什么使用头文件

背景

通常
    
    
    
，在一个 C++ 程序中     


     


     


，只包含两类文件—— .cpp 文件和 .h 文件   
     
     
   。其中 




 




 




 ，.cpp 文件被称作 C++ 源文件

   

   

   
，里面放的都是 C++ 的源代码；而 .h 文件则被称作 C++ 头文件     

     

     

，里面放的也是 C++ 的源代码



   




   




   

。

C++ 语言支持"分别编译"（separatecompilation） 



 



 



。也就是说  




  




  




 ，一个程序所有的内容


  


  


  
，可以分成不同的部分分别放在不同的 .cpp 文件里                。.cpp 文件里的东西都是相对独立的     
     
     
，在编译（compile）时不需要与其他文件互通   




   




   




 ，只需要在编译成目标文件后再与其他的目标文件做一次链接（link）就行了




    




    




    
。比如



 



 



 
，在文件 a.cpp 中定义了一个全局函数 "void a(){}"               ，而在文件 b.cpp 中需要调用这个函数














。即使这样    




    




    




 ，文件 a.cpp 和文件 b.cpp 并不需要相互知道对方的存在















，而是可以分别地对它们进行编译               ，编译成目标文件之后再链接     



     



     



 ，整个程序就可以运行了                。

这是怎么实现的呢？从写程序的角度来讲














，很简单



     



     



     。在文件 b.cpp 中
    
    
    
，在调用 "void a()" 函数之前     


     


     


，先声明一下这个函数 "void a();" 




 




 




 ，就可以了















。这是因为编译器在编译 b.cpp 的时候会生成一个符号表（symbol table）

   

   

   
，像 "void a()" 这样的看不到定义的符号     

     

     

，就会被存放在这个表中    
    
    
。再进行链接的时候  




  




  




 ，编译器就会在别的目标文件中去寻找这个符号的定义 


     


     


     。一旦找到了


  


  


  
，程序也就可以顺利地生成了

 




 




 



。

注意这里提到了两个概念     
     
     
，一个是"定义"   




   




   




 ，一个是"声明"   

   

   

。简单地说



 



 



 
，"定义"就是把一个符号完完整整地描述出来：它是变量还是函数               ，返回什么类型    




    




    




 ，需要什么参数等等  

     

     

    。而"声明"则只是声明这个符号的存在















，即告诉编译器               ，这个符号是在其他文件中定义的     



     



     



 ，我这里先用着














，你链接的时候再到别的地方去找找看它到底是什么吧


  




  




  


。定义的时候要按 C++ 语法完整地定义一个符号（变量或者函数）
    
    
    
，而声明的时候就只需要写出这个符号的原型了  


  


  


。需要注意的是     


     


     


，一个符号 




 




 




 ，在整个程序中可以被声明多次

   

   

   
，但却要且仅要被定义一次   
     
     
   。试想     

     

     

，如果一个符号出现了两种不同的定义  




  




  




 ，编译器该听谁的？

这种机制给 C++ 程序员们带来了很多好处


  


  


  
，同时也引出了一种编写程序的方法



   




   




   

。考虑一下     
     
     
，如果有一个很常用的函数 "void f() {}"   




   




   




 ，在整个程序中的许多 .cpp 文件中都会被调用



 



 



 
，那么               ，我们就只需要在一个文件中定义这个函数    




    




    




 ，而在其他的文件中声明这个函数就可以了 



 



 



。一个函数还好对付















，声明起来也就一句话                。但是               ，如果函数多了     



     



     



 ，比如是一大堆的数学函数














，有好几百个
    
    
    
，那怎么办？能保证每个程序员都可以完完全全地把所有函数的形式都准确地记下来并写出来吗？

很显然     


     


     


，答案是不可能




    




    




    
。但是有一个很简单地办法 




 




 




 ，可以帮助程序员们省去记住那么多函数原型的麻烦：我们可以把那几百个函数的声明语句全都先写好

   

   

   
，放在一个文件里     

     

     

，等到程序员需要它们的时候  




  




  




 ，就把这些东西全部 copy 进他的源代码中














。

总结

这个方法固然可行


  


  


  
，但还是太麻烦     
     
     
，而且还显得很笨拙                。于是   




   




   




 ，头文件便可以发挥它的作用了



     



     



     。所谓的头文件



 



 



 
，其实它的内容跟 .cpp 文件中的内容是一样的               ，都是 C++ 的源代码















。但头文件不用被编译（通过宏替换到cpp文件    




    




    




 ，跟着cpp文件被编译）    
    
    
。我们把所有的函数声明全部放进一个头文件中















，当某一个 .cpp 源文件需要它们时               ，它们就可以通过一个宏命令 "#include" 包含进这个 .cpp 文件中     



     



     



 ，从而把它们的内容合并到 .cpp 文件中去 


     


     


     。当 .cpp 文件被编译时














，这些被包含进去的 .h 文件的作用便发挥了

 




 




 



。

意思也就是更方便地实现不同cpp文件的方法
    
    
    
，变量的互用     


     


     


，哪些方法我想暴露到外面 




 




 




 ，直接在头文件中声明

   

   

   
，其他人直接include（前提是include能找到该h文件）     

     

     

，之后他引用这个文件的函数编译就不会报错  




  




  




 ，链接之后他就知道上哪找声明的具体实现了   

   

   

。

二     


     


     


、头文件中应该写什么

通过上面的讨论


  


  


  
，我们可以了解到     
     
     
，头文件的作用就是被其他的 .cpp 包含进去的  

     

     

    。它们本身并不参与编译   




   




   




 ，但实际上



 



 



 
，它们的内容却在多个 .cpp 文件中得到了编译


  




  




  


。通过"定义只能有一次"的规则               ，我们很容易可以得出    




    




    




 ，头文件中应该只放变量和函数的声明















，而不能放它们的定义  


  


  


。因为一个头文件的内容实际上是会被引入到多个不同的 .cpp 文件中的               ，并且它们都会被编译   
     
     
   。放声明当然没事     



     



     



 ，如果放了定义














，那么也就相当于在多个文件中出现了对于一个符号（变量或函数）的定义
    
    
    
，纵然这些定义都是相同的     


     


     


，但对于编译器来说 




 




 




 ，这样做不合法



   




   




   

。

所以

   

   

   
，应该记住的一点就是     

     

     

，.h头文件中  




  




  




 ，只能存在变量或者函数的声明


  


  


  
，而不要放定义 



 



 



。即     
     
     
，只能在头文件中写形如：extern int a;（这才是真的变量声明） 和 void f(); 的句子                。这些才是声明




    




    




    
。如果写上 int a;（ int a;算是声明加定义！！）或者 void f() {} 这样的句子   




   




   




 ，那么一旦这个头文件被两个或两个以上的 .cpp 文件包含的话



 



 



 
，编译器会立马报错














。（关于 extern               ，前面有讨论过    




    




    




 ，这里不再讨论定义跟声明的区别了                。）

但是















，这个规则是有三个例外的:

一               ，头文件中可以写 const 对象的定义



     



     



     。因为全局的 const 对象默认是没有 extern 的声明的     



     



     



 ，所以它只在当前文件中有效















。把这样的对象写进头文件中














，即使它被包含到其他多个 .cpp 文件中
    
    
    
，这个对象也都只在包含它的那个文件中有效     


     


     


，对其他文件来说是不可见的 




 




 




 ，所以便不会导致多重定义    
    
    
。同时

   

   

   
，因为这些 .cpp 文件中的该对象都是从一个头文件中包含进去的     

     

     

，这样也就保证了这些 .cpp 文件中的这个 const 对象的值是相同的  




  




  




 ，可谓一举两得 


     


     


     。同理


  


  


  
，static 对象的定义也可以放进头文件

 




 




 



。 二     
     
     
，头文件中可以写内联函数（inline）的定义   

   

   

。因为inline函数是需要编译器在遇到它的地方根据它的定义把它内联展开的   




   




   




 ，而并非是普通函数那样可以先声明再链接的（内联函数不会链接）



 



 



 
，所以编译器就需要在编译时看到内联函数的完整定义才行  

     

     

    。如果内联函数像普通函数一样只能定义一次的话               ，这事儿就难办了


  




  




  


。因为在一个文件中还好    




    




    




 ，我可以把内联函数的定义写在最开始















，这样可以保证后面使用的时候都可以见到定义；但是               ，如果我在其他的文件中还使用到了这个函数那怎么办呢？这几乎没什么太好的解决办法     



     



     



 ，因此 C++ 规定














，内联函数可以在程序中定义多次
    
    
    
，只要内联函数在一个 .cpp 文件中只出现一次     


     


     


，并且在所有的 .cpp 文件中 




 




 




 ，这个内联函数的定义是一样的

   

   

   
，就能通过编译  


  


  


。那么显然     

     

     

，把内联函数的定义放进一个头文件中是非常明智的做法   
     
     
   。 三  




  




  




 ，头文件中可以写类（class）的定义



   




   




   

。因为在程序中创建一个类的对象时


  


  


  
，编译器只有在这个类的定义完全可见的情况下     
     
     
，才能知道这个类的对象应该如何布局   




   




   




 ，所以



 



 



 
，关于类的定义的要求               ，跟内联函数是基本一样的 



 



 



。所以把类的定义放进头文件    




    




    




 ，在使用到这个类的 .cpp 文件中去包含这个头文件















，是一个很好的做法                。在这里               ，值得一提的是     



     



     



 ，类的定义中包含着数据成员和函数成员




    




    




    
。数据成员是要等到具体的对象被创建时才会被定义（分配空间）














，但函数成员却是需要在一开始就被定义的
    
    
    
，这也就是我们通常所说的类的实现














。一般     


     


     


，我们的做法是 




 




 




 ，把类的定义放在头文件中

   

   

   
，而把函数成员的实现代码放在一个 .cpp 文件中                。这是可以的     

     

     

，也是很好的办法



     



     



     。不过  




  




  




 ，还有另一种办法















。那就是直接把函数成员的实现代码也写进类定义里面    
    
    
。在 C++ 的类中


  


  


  
，如果函数成员在类的定义体中被定义     
     
     
，那么编译器会视这个函数为内联的 


     


     


     。因此   




   




   




 ，把函数成员的定义写进类定义体



 



 



 
，一起放进头文件中               ，是合法的

 




 




 



。注意一下    




    




    




 ，如果把函数成员的定义写在类定义的头文件中















，而没有写进类定义中               ，这是不合法的     



     



     



 ，因为这个函数成员此时就不是内联的了   

   

   

。一旦头文件被两个或两个以上的 .cpp 文件包含














，这个函数成员就被重定义了  

     

     

    。

三 




 




 




 、#include

与宏定义很类似
    
    
    
，就是完全的替换     


     


     


，比如上面的文件就相当于

main.cpp与main.h拼接到一起了 




 




 




 ，也算是完全替换了


  




  




  


。

#include 是一个来自 C 语言的宏命令

   

   

   
，它在编译器进行编译之前     

     

     

，即在预编译的时候就会起作用  


  


  


。#include 的作用是把它后面所写的那个文件的内容  




  




  




 ，完完整整地

   

   

   
、一字不改地包含到当前的文件中来   
     
     
   。值得一提的是


  


  


  
，它本身是没有其它任何作用与副功能的     
     
     
，它的作用就是把每一个它出现的地方   




   




   




 ，替换成它后面所写的那个文件的内容



   




   




   

。简单的文本替换



 



 



 
，别无其他 



 



 



。

编译setup.py时会找include文件夹

通常包的c文件结构

如cuda文件夹举例

\\wsl.localhost\Ubuntu-18.04\usr\local\cuda-11.6\bin 

存储了可执行的文件               ，比如nvcc这种    




    




    




 ，要添加在path中即可调用

\\wsl.localhost\Ubuntu-18.04\usr\local\cuda-11.6\targets\x86_64-linux\include

存储了用于include的文件















，也就是头文件               ，用于编译

\\wsl.localhost\Ubuntu-18.04\usr\local\cuda-11.6\targets\x86_64-linux\lib

是include的具体实现文件     



     



     



 ，都是so文件














，动态链接时找这些文件要能找到
    
    
    
，所以要将他们添加到LD_LIBRARY_PATH上

四     

     

     

、头文件引用可能发生的重复定义的问题见教程

上面已经提到了一点

头文件中不要有对变量或函数或类型的定义     


     


     


，否则可能会报重复引用！！

最好是只有声明 




 




 




 ，尽量不要有定义

   

   

   
，如果a.h中定义了变量int a=1     

     

     

，

b.h中也定义了int a=1  




  




  




 ，

那么如果有一个文件同时引用了a和b两个头文件


  


  


  
，那么根据include是完全替换代码     
     
     
，也就是int a=1会重复定义两次   




   




   




 ，则会报重复定义的错误                。

尤其是全局定义



 



 



 
，定义在命名空间中就还好               ，命名空间不重复就不会算成重复定义




    




    




    
。

同一头文件不能重复引用    




    




    




 ，否则大概率会报重复引用！！

还是根据include是完全替换代码的原理

如果一个文件被连续引用两次















，那么里面的所有东西肯定都是重复了两次被放在引用这个头文件的文件中的               ，那么就会造成重复定义     



     



     



 ，同理声明不会有事














，因为声明可以出现两次














。

除了使用声明
    
    
    
，还可以使用宏定义解决同一头文件不能重复引用（通用手段     


     


     


，所有官方头文件也都在用）

就是为每一个文件定义一个宏变量 




 




 




 ，引入该文件时首先看看宏变量是否存在

   

   

   
，如果宏变量不存在     

     

     

，这时说明还没有被因引入  




  




  




 ，就引入文件


  


  


  
，定义上该宏变量     
     
     
，如果宏变量存在   




   




   




 ，就说明之前被引入过了



 



 



 
，就不再引入了                。

示例：main.h

#ifndef UNTITLED1_MAIN_H #define UNTITLED1_MAIN_H #include <cstdio> namespace Diy{ int a=1; class Student{ public: char *name; int age; float score; public: void say(){ printf("%s的年龄是 %d               ，成绩是 %f\n", name, age, score); } }; } #endif //UNTITLED1_MAIN_H

五  




  




  




 、源文件如何根据 #include 来关联头文件

1


  


  


  
、系统自带的头文件用尖括号括起来    




    




    




 ，这样编译器会在系统文件目录下(通常这些都是include文件夹下)查找



     



     



     。 2     
     
     
、用户自定义的文件用双引号括起来















，编译器首先会在1   




   




   




 、用户目录下查找               ，然后在到2



 



 



 
、 C++ 安装目录（比如 VC 中可以指定和修改库文件查找路径     



     



     



 ，Unix 和 Linux 中可以通过环境变量来设定）中查找














，3               、最后在系统文件中查找















。（看看就好）

#include "xxx.h"（我一直以为 "" 和 <> 没什么区别
    
    
    
，但是 tinyxml.h 是非系统下的都文件     


     


     


，所以要用 ""）

比如pytorch的系统头文件 




 




 




 ，这些头文件一般都存在include/torch文件夹下

   

   

   
，比如 

Ubuntu-18.04 > home > zxy > mambaforge > ens > sphere > lib > python3.7 > site-packages > torch > incude > torch > csrc > api > incude > torch > all.h

 Ubuntu-18.04 〉home 〉 zxy〉 mambaforge > envs 〉 sphere > lib > python3.7 > site-packages 〉 torch 〉 include > torch > C extension.h

 到时候使用#include <torch/all.h>即可调用

 会报红     

     

     

，不知道为什么  




  




  




 ，但是执行setup.py能够正常执行编译成功


  


  


  
，说明找到了torch的·include文件夹     
     
     
，只是pycharm找不到   




   




   




 ，所以这个就不知道如何解决

六    




    




    




 、头文件如何来关联源文件（重要）

这个问题实际上是说



 



 



 
，已知头文件 "a.h" 声明了一系列函数               ，"b.cpp" 中实现了这些函数    




    




    




 ，那么如果我想在 "c.cpp" 中使用 "a.h" 中声明的这些在 "b.cpp"中实现的函数















，通常都是在 "c.cpp" 中使用 #include "a.h"               ，那么 c.cpp 是怎样找到 b.cpp 中的实现呢？

其实 .cpp 和 .h 文件名称没有任何直接关系     



     



     



 ，很多编译器都可以接受其他扩展名    
    
    
。比如偶现在看到偶们公司的源代码














，.cpp 文件由 .cc 文件替代了 


     


     


     。（因为只是宏定义
    
    
    
，因此文件名随意）

谭浩强老师的《C 程序设计》一书中提到     


     


     


，编译器预处理时 




 




 




 ，要对 #include 命令进行"文件包含处理"：将 file2.c 的全部内容复制到 #include "file2.c" 处

 




 




 



。这也正说明了

   

   

   
，为什么很多编译器并不 care 到底这个文件的后缀名是什么----因为 #include 预处理就是完成了一个"复制并插入代码"的工作   

   

   

。

编译的时候     

     

     

，并不会去找 b.cpp 文件中的函数实现  




  




  




 ，只有在 link 的时候才进行这个工作  

     

     

    。我们在 b.cpp 或 c.cpp 中用 #include "a.h" 实际上是引入相关声明


  


  


  
，使得编译可以通过     
     
     
，程序并不关心实现是在哪里   




   




   




 ，是怎么实现的


  




  




  


。源文件编译后成生了目标文件（.o 或 .obj 文件）



 



 



 
，目标文件中               ，这些函数和变量就视作一个个符号  


  


  


。在 link 的时候    




    




    




 ，需要在 makefile 里面说明需要连接哪个 .o 或 .obj 文件（在这里是 b.cpp 生成的 .o 或 .obj 文件）















，此时               ，连接器会去这个 .o 或 .obj 文件中找在 b.cpp 中实现的函数     



     



     



 ，再把他们 build 到 makefile 中指定的那个可以执行文件中   
     
     
   。

在 Unix下














，甚至可以不在源文件中包括头文件
    
    
    
，只需要在 makefile 中指名即可（不过这样大大降低了程序可读性     


     


     


，是个不好的习惯哦^_^）



   




   




   

。在 VC 中 




 




 




 ，一帮情况下不需要自己写 makefile

   

   

   
，只需要将需要的文件都包括在 project中     

     

     

，VC 会自动帮你把 makefile 写好 



 



 



。

通常  




  




  




 ，C++ 编译器会在每个 .o 或 .obj 文件中都去找一下所需要的符号


  


  


  
，而不是只在某个文件中找或者说找到一个就不找了                。因此     
     
     
，如果在几个不同文件中实现了同一个函数   




   




   




 ，或者定义了同一个全局变量



 



 



 
，链接的时候就会提示 "redefined"




    




    




    
。（在没有指定链接的情况下               ，如果一个头文件的声明在很多文件下都有实现    




    




    




 ，那么就会"redefined"报错














。）