Parallel_社区达人页_阿里云开发者社区

详解C++中的命名空间（namespace）

C++关键字(C++98)在C++中，总共有63个关键字，大家还记得在C语言中有多少个关键字吗，没错，在C语言中总共有32个关键字。下面是C++的关键字：asmdoifautoreturntrycontinuedoubleinlineshorttypedefforbooldynamic_castintsignedtypeidpublicbreakelselongsizeoftypenamethrowcaseenummutablestaticunionwchar_tcatchexplicitnamespacestatic_castunsigneddefaultcharexportnewstructusingfriendclassexternoperatorswitchvirtualregisterconstfalseprivatetemplatevoidtrueconst_castfloatprotectedthisvolatilewhiledeletegotoreinterpret_cast命名冲突可以看到：上述代码我们可以通过。那现在这段代码呢？请看：我们发现rand出现了重定义的错误：那为什么rand发生了冲突了呢？其实rand这里是跟库发生了冲突。std中有一个函数也叫rand，所以就会发生命名冲突的问题。发生命名冲突的原因有两种：1.跟库里发生冲突。2.互相之间发生冲突。其实命名冲突这个问题挺麻烦的，我们并不知道库中是否有这个变量，在这个基础上，如果我们又重新定义了这个变量，此时就会出现命名冲突的问题。为了解决命名冲突的问题，就引出了命名空间。命名空间嗯，namespace就是命名空间的意思，也是C++中的一个关键字，就是用来解决命名冲突的问题的。这里，我们先来引出一个问题，请看下面代码： #include<iostream> using namespace std; int main() { return 0; }在C++中，为什么我们一般要加上using namespace std;呢？命名空间的定义命名空间，即namespace，后面跟着命名空间的名字，然后接一对{}，{}中的内容就是命名空间的成员。命名空间namespace可以定义一个域出来。举个例子：我们可以看到上图的代码出现了rand重定义的问题，我们如果不想出现这个问题，就可以用namespace定义一个域出来以解决重定义这个问题。请看解决方法： #include<stdio.h> #include<stdlib.h> //域 namespace hello { //hello这个域就会把域中的内容(rand)进行一个隔离 //这里要注意，域中的rand与主函数中的rand不是一回事。 int rand = 0; } int main() { printf("%d\n", rand); return 0; }这个运行结果也说明了域中的rand与主函数中的rand不是一回事。局部域和全局域的关系 #include<stdio.h> #include<stdlib.h> int a = 0; int main() { int a = 1; printf("%d\n", a); return 0; }上面这个代码中的两个a就可以同时存在。我们把主函数外面的a看作是全局域中的a，把主函数里面中的a看作是局部域中的a。同时，我们还要知道一个点局部域和全局域既影响访问，也影响生命周期。域分为好几种，作用域只是域中的一种。域总共分为下面四种：类域命名空间域局部域全局域我们来运行上面的代码：因为局部域中的a优先，所以这里打印出来的是局部域中变量a的值，即打印出来的是1，如果我们想打印全局域中的a中的值怎么办呢？我们可以这样： #include<stdio.h> #include<stdlib.h> int a = 0; int main() { int a = 1; printf("%d\n", a); // ::称为域作用限定符 printf("%d\n",::a); return 0; }运行结果如上图，我们看到我们打印出来的0就是全局域中的a的值。关于局部域和全局域的关系是这样的：我们是默认从局部域开始搜索的，即局部优先；当然，如果局部没有的话，我们就会去全局域进行搜索，所以有局部先访问局部，没有局部才会去访问全局。我们通过域作用限定符::可以去直接访问全局域。即上面的代码，注意观察，::的前面是不加任何东西的（注意前面不需要我们加空格），意思就是我们直接去访问全局域。命名空间域上图代码中总共有三个域（局部域、全局域、命名空间域），每个域中都有一个变量a，我们如何去访问这三个作用域中的a呢，请看下面：我们现在把全局域中的变量a注释掉看看运行结果，所以来看下面这段代码的运行结果：我们发现程序根本运行不了，所以这里就报错了。所以我们通过这个程序发现，这个程序并不会去到命名空间里去进行搜索；那这里就会引出一个新的问题，程序什么时候才会去到命名空间域中去进行搜索呢？这里有两种可能性会去搜索命名空间域中的内容：1.我们展开了命名空间域2.指定访问命名空间我们先来看第一种（展开命名空间）：如果我们不展开的话： #include<stdio.h> #include<stdlib.h> int a = 2; namespace hello { int a = 1; } //展开命名空间 //using namespace hello; int main() { int a = 0; printf("%d\n", a); return 0; }上面就是我们不对命名空间进行展开，上面代码中的3个变量a依然可以同时存在。补充一点，我们C++中常用的using namespace std;展开的是std标准库中的命名空间。现在如果我们想访问命名空间中的变量a，我们可以采用第二种方式（指定访问命名空间）： #include<stdio.h> #include<stdlib.h> int a = 2; namespace hello { int a = 1; } //展开命名空间 //using namespace hello; int main() { int a = 0; printf("%d\n", a); printf("%d\n", ::a); printf("%d\n", hello::a); return 0; }上面的代码中我们虽然没有对命名空间进行展开，但是我们指定了命名空间。现在新的问题来了，如果我们把命名空间展开会发生什么呢？请看：上述代码中，我们把命名空间里的内容进行展开，展开的意思就是编译时把命名空间里的内容暴露到全局，是是否会到命名空间里面去搜索，，而此时全局域中已经有一个变量a了，所以会出现上图a不明确的问题。所以我们现在再来看namespace这个关键字发现它并不友好，它会把我们的命名空间进行展开，而我们为什么要把命名空间进行展开呢？命名空间进行展开的意义何在？命名空间就是为了防止自己的内容与其它域发生冲突而设立的。小结我们虽然可以指定指定命名空间里面的内容，但是这样不是很方便，所以有些地方有些时候我们会把命名空间进行展开，一旦我们把命名空间进行展开，就可能会出现一系列问题。比如，重定义问题、某个变量不明确等等问题。所以，我们以后不要轻易使用using namespace。现在，我们再来看开头还没有解决的问题：我们既然无法把rand定义在全局域中，那就直接把rand定义在一个命名空间域并不对这个域进行展开就好了，请看：所以我们利用命名空间就可以解决开头rand重定义的问题，但是这个问题C语言无法解决，而C++中的命名空间就可以解决。命名空间中可以定义哪些内容在命名空间中，我们可以定义很多东西，比如结构体类型、定义变量、定义函数等都是可以的。请看举例： #include<stdio.h> #include<stdlib.h> namespace hello { int rand = 10; int Add(int left, int right) { return left + right; } struct Node { struct Node* next; int data; }; } int main() { return 0; }嵌套命名空间命名空间是可以进行嵌套的，比如： //嵌套命名空间 #include<stdio.h> #include<stdlib.h> namespace N1 { int a = 0; int b = 1; int Add(int left, int right) { return left + right; } namespace N2 { int a = 1; int c = 0; int d = 0; int Sub(int left, int right) { return left - right; } } }补充一点：C++中的C++库里的所有东西都会被分装在std命名空间中。stl是C++标准库的一部分，cout等都在C++标准库中。我们如何访问嵌套命名空间呢？请看举例：我们知道不同的域可以有同名名变量，但是同一个域不能有同名变量。我们同一个命名空间如若给非要给同样的变量，这个时候嵌套命名空间就派上用场了。我们在平常最常见的C++代码大体是长这样的，请看： #include<iostream> using namespace std; int main() { return 0; }其实这样直接展开的话会有风险，我们定义的如果跟库中的重名，就报错了。所以项目里面尽量不要去进行展开。注意，展开不一定会报错。如果是日常练习的话（代码少），就可以直接展开；那如果是项目中的话，前往不要随意对命名空间进行展开。建议直接访问指定命名空间，比如：但是如果我们一个项目中有非常多cout的话，我们不可能要输入非常多次的std::，所以这里推荐一种非常实用的方式，请看：这样的话，我们就不需要把整个命名空间进行展开了，我们直接把最常用的展开就可以了。总结命名空间的存在是为了解决C语言的一个缺陷，我们知道C语言存在命名冲突的问题，为了解决命名冲突问题，于是C++就引入了命名空间的内容。命名空间是对全局域的比如变量、函数、类型就行分装，以防止之间发生冲突。再次强调命名空间解决的是全局域的冲突，局部域基本上没有命名空间的问题，局部域的话就相当于在函数里面，函数本身就是一个局部域，不同的函数之间可以定义同名的变量（因为不同的域里面可以定义同名的变量）。我们对命名空间进行搜索主要有三种方式：第一：展开命名空间；第二：直接访问命名空间；第三：访问某个。（其中第二种第三种都是通过域作用限定符来进行操作的）。同时，我们在对命名空间进行展开的时候需要格外小心，不要轻易的对命名空间进行展开。好了，以上就是C++中命名空间的内容，算是C++中的开头。就到这里吧，下次见喽各位，再见啦！！！

【数据结构入门】-链表之双向循环链表

链表初始化 LTNode* ListInit(LTNode* phead) { //哨兵位头节点 phead = (LTNode*)malloc(sizeof(LTNode)); phead->next = phead; phead->prev = phead; return phead; //利用返回值的方式 }首先，我们需要一个哨兵头节点，该头节点的next和prev均指向该头节点本身，最后，返回这个头节点的地址。打印链表 void ListPrint(LTNode* phead) { assert(phead); LTNode* cur = phead->next;//从phead->开始遍历链表 while (cur != phead)//为了防止死循环，所以终止条件为cur=phead { printf("%d ", cur->data); cur = cur->next; } printf("\n"); }由于链表是双向循环链表，双向循环链表自身的结构很容易在打印时造成死循环，所以我们在打印链表时需要注意循环终止的条件，否则，程序就会陷入死循环。再次提醒，这是一个双向循环链表。当我们循环打印完链表的最后一个数据的时候，此时cur就是指向链表中最后一个节点的，而cur->next是指向链表的哨兵头节点的，所以，循环终止条件就是cur=phead。尾插 void ListPushBack(LTNode* phead, LTDateType x) { //链表为空时，依然可以处理 assert(phead); LTNode* tail = phead->prev;//找到尾节点 LTNode* newnode = (LTNode*)malloc(sizeof(LTNode)); newnode->data = x; //phead tail->next = newnode; newnode->prev = tail; newnode->next = phead; phead->prev = newnode; }尾删 //尾删 void ListPopBack(LTNode* phead) { assert(phead); assert(phead->next != phead);//当链表为空时，就表示不能再删除了 //找到尾 LTNode* tail = phead->prev; phead->prev = tail->prev; tail->prev->next = phead; //最后释放空间 free(tail); }既然是尾删，我们首先要先找到尾，即LTNode* tail = phead->prev;这样会方便很多，同时尾删的时候一定要注意**free（）**的释放时机。注意一种特殊情况：当phead->next==phead的时候，此时链表为空，就不能继续删除了。所以需要加上 assert(phead->next != phead);。新建一个节点 LTNode* BuyListNode(LTDateType x) { LTNode* newnode = (LTNode*)malloc(sizeof(LTNode)); newnode->data = x; newnode->prev = NULL; newnode->next = NULL; return newnode; }该函数功能就是新建一个节点，把该节点的数据进行赋值（即newnode->data = x;），并把指针均变成空指针（newnode->prev = NULL; newnode->next = NULL;）。最后返回这个新节点的地址即可。头插 void ListPushFront(LTNode* phead, LTDateType x) { assert(phead); LTNode* newnode = BuyListNode(x); LTNode* next = phead->next; phead->next = newnode; newnode->prev = phead; newnode->next = next; next->prev = newnode; }还是看一下特殊情况，即如果链表是一个空链表，我们来简单分析一下：链表为空时phead->next就是phead本身。我们只需要处理phead、next、newnode三者之间的链接关系即可。最后发现，链表为空时依然可以进行处理。头删 void ListPopFront(LTNode* phead) { assert(phead); //链表为空就不需要头删了 LTNode* next = phead->next; LTNode* nextNext = next->next; phead->next = nextNext; nextNext->prev = phead; free(next); }链表为空时就不要进行头删操作了，故加上assert(phead);我们最好还是提前定义好next和nextNext即LTNode* next = phead->next;LTNode* nextNext = next->next;这样后面会很方便，可以减少不必要的麻烦，接下来处理phead、next、nextNext三者之间的链接关系就好了。查找查找的实现与打印的实现差不太多，提前定义一个cur指向phead的next，即LTNode* next = phead->next;循环终止条件依然是cur = phead，其它按部就班即可。 LTNode* ListFind(LTNode* phead, LTDateType x) { assert(phead); LTNode* cur = phead->next; while (cur != phead) { if (cur->data == x) { return cur; } cur = cur->next; } //没找到就返回NULL return NULL; }在pos之前插入* void ListInsert(LTNode* pos, LTDateType x) { assert(pos); LTNode* posPrev = pos->prev; LTNode* newnode = BuyListNode(x); //处理posPrev newnode pos三者之间的链接关系 posPrev->next = newnode; newnode->prev = posPrev; newnode->next = pos; pos->prev = newnode; } 一定要提前定义一个posPrev即LTNode* posPrev = pos->prev;，然后进行newnode、pos、posPrev之间的链接就好。在这里，我们还可以利用ListInsert这个函数来完成头插尾插的操作。首先，我们先利用ListInsert来完成尾插的操作。当pos是我们的哨兵位节点phead的时候，由于这个函数是在pos之前插入，所以此时就相当于尾插了（因为phead->prev就是尾）。 void ListPushBack(LTNode* phead, LTDateType x) { //链表为空时，依然可以处理 assert(phead); //LTNode* tail = phead->prev;//找到尾节点 //LTNode* newnode = (LTNode*)malloc(sizeof(LTNode)); //newnode->data = x; phead //tail->next = newnode; //newnode->prev = tail; //newnode->next = phead; //phead->prev = newnode; ListInsert(phead, x); }现在再来看头插：当phead->next和pos相等时，此时就相当于头插。 void ListPushFront(LTNode* phead, LTDateType x) { assert(phead); //LTNode* newnode = BuyListNode(x); //LTNode* next = phead->next; //phead->next = newnode; //newnode->prev = phead; //newnode->next = next; //next->prev = newnode; ListInsert(phead->next, x); }所以我们以后想要快速的写双向循环链表的时候，头插、尾插、或者任意位置的插入都可以利用ListInsert这个函数来快速的实现双向循环链表。把phead->prev传给pos就是尾插，把phead->next传给pos就变成了头删。所以双向链表只需要实现两个函数（ListInsert和ListErase）就都搞定了，这也是双向链表结构的一个优势。删除pos位置 void ListErase(LTNode* pos) { assert(pos); LTNode* posPrev = pos->prev; LTNode* posNext = pos->next; posPrev->next = posNext; posNext->prev = posPrev; free(pos); }一般来说，我们想要删除某个数据先是调用ListFind来返回一个地址，然后才调用ListErase继而把该数据删除，请看： void TestList2() { LTNode* plist = NULL; plist = ListInit(plist); ListPushFront(plist, 1); ListPushFront(plist, 2); ListPushFront(plist, 3); ListPushFront(plist, 4); ListPrint(plist); ListPushBack(plist, 1); ListPushBack(plist, 2); ListPushBack(plist, 3); ListPushBack(plist, 4); ListPrint(plist); LTNode* pos = ListFind(plist, 2); if (pos != NULL) { ListErase(pos); } ListPrint(plist); }我们可以看到运行结果成功把第一个2删除了。然而ListErase的功能不仅仅只有这些，我们还可以利用ListErase来完成头删尾删的操作。请看： //尾删 void ListPopBack(LTNode* phead) { assert(phead); assert(phead->next != phead);//当链表为空时，就表示不能再删除了找到尾 //LTNode* tail = phead->prev; //phead->prev = tail->prev; //tail->prev->next = phead; 最后释放空间 //free(tail); ListErase(phead->prev); } //头删 void ListPopFront(LTNode* phead) { assert(phead); 链表为空就不需要头删了 //LTNode* next = phead->next; //LTNode* nextNext = next->next; //phead->next = nextNext; //nextNext->prev = phead; //free(next); ListErase(phead->next); }现在我们来测试一下： void TestList2() { LTNode* plist = NULL; plist = ListInit(plist); ListPushFront(plist, 1); ListPushFront(plist, 2); ListPushFront(plist, 3); ListPushFront(plist, 4); ListPrint(plist); ListPushBack(plist, 1); ListPushBack(plist, 2); ListPushBack(plist, 3); ListPushBack(plist, 4); ListPrint(plist); LTNode* pos = ListFind(plist, 2); if (pos != NULL) { ListErase(pos); } ListPrint(plist); ListPopBack(plist); ListPopBack(plist); ListPopFront(plist); ListPopFront(plist); ListPrint(plist); } 销毁链表最后，我们再来实现一下销毁链表。 //销毁链表 void ListDestroy(LTNode* phead) { assert(phead); LTNode* cur = phead->next; while (cur != phead) { LTNode* next = cur->next; free(cur); cur = next; } free(phead); //想要把phead置为空，需要再函数外部进行置空，当然如果传二级指针也可以在函数内部把 //phead置为空，不过因为我们这个双向链表都是传的一级指针，所以为了保持接口一致性， //我们在函数外部把phead置为空即可 } 以上就是双向循环链表所以接口函数的实现。总代码test.c#include"List.h" void TestList1() { LTNode* plist = NULL;//初始化 plist = ListInit(plist); ListPushBack(plist, 1); ListPushBack(plist, 2); ListPushBack(plist, 3); ListPushBack(plist, 4); ListPrint(plist); ListPushFront(plist, 1); ListPushFront(plist, 2); ListPushFront(plist, 3); ListPushFront(plist, 4); ListPrint(plist); } void TestList2() { LTNode* plist = NULL; plist = ListInit(plist); ListPushFront(plist, 1); ListPushFront(plist, 2); ListPushFront(plist, 3); ListPushFront(plist, 4); ListPrint(plist); ListPushBack(plist, 1); ListPushBack(plist, 2); ListPushBack(plist, 3); ListPushBack(plist, 4); ListPrint(plist); LTNode* pos = ListFind(plist, 2); if (pos != NULL) { ListErase(pos); } ListPrint(plist); ListPopBack(plist); ListPopBack(plist); ListPopFront(plist); ListPopFront(plist); ListPrint(plist); ListDestroy(plist); plist = NULL; } int main() { //TestList1(); TestList2(); return 0; } list.h#pragma once #include<stdio.h> #include<stdlib.h> #include<assert.h> typedef int LTDateType; typedef struct ListNode { LTDateType data; struct ListNode* next; struct ListNode* prev; }LTNode; LTNode* ListInit(LTNode* phead);//初始化 void ListPrint(LTNode* phead); //打印链表 //尾插 void ListPushBack(LTNode* phead, LTDateType x); //尾删 void ListPopBack(LTNode* phead); //头插 void ListPushFront(LTNode* phead, LTDateType x); //头删 void ListPopFront(LTNode* phead); //创建新节点 LTNode* BuyListNode(LTDateType x); //查找 LTNode* ListFind(LTNode* phead, LTDateType x); //pos位置之前插入 void ListInsert(LTNode* pos, LTDateType x); //删除pos位置 void ListErase(LTNode* pos); //销毁聊表 void ListDestroy(LTNode* phead); list.c#include"List.h" //初始化 LTNode* ListInit(LTNode* phead) { //哨兵位头节点 phead = (LTNode*)malloc(sizeof(LTNode)); phead->next = phead; phead->prev = phead; return phead; //利用返回值的方式 } void ListPushBack(LTNode* phead, LTDateType x) { //链表为空时，依然可以处理 assert(phead); //LTNode* tail = phead->prev;//找到尾节点 //LTNode* newnode = (LTNode*)malloc(sizeof(LTNode)); //newnode->data = x; phead //tail->next = newnode; //newnode->prev = tail; //newnode->next = phead; //phead->prev = newnode; ListInsert(phead, x); } void ListPrint(LTNode* phead) { assert(phead); LTNode* cur = phead->next;//从phead->开始遍历链表 while (cur != phead)//为了防止死循环，所以终止条件为cur=phead { printf("%d ", cur->data); cur = cur->next; } printf("\n"); } //尾删 void ListPopBack(LTNode* phead) { assert(phead); assert(phead->next != phead);//当链表为空时，就表示不能再删除了找到尾 //LTNode* tail = phead->prev; //phead->prev = tail->prev; //tail->prev->next = phead; 最后释放空间 //free(tail); ListErase(phead->prev); } LTNode* BuyListNode(LTDateType x) { LTNode* newnode = (LTNode*)malloc(sizeof(LTNode)); newnode->data = x; newnode->prev = NULL; newnode->next = NULL; return newnode; } void ListPushFront(LTNode* phead, LTDateType x) { assert(phead); //LTNode* newnode = BuyListNode(x); //LTNode* next = phead->next; //phead->next = newnode; //newnode->prev = phead; //newnode->next = next; //next->prev = newnode; ListInsert(phead->next, x); } //头删 void ListPopFront(LTNode* phead) { assert(phead); 链表为空就不需要头删了 //LTNode* next = phead->next; //LTNode* nextNext = next->next; //phead->next = nextNext; //nextNext->prev = phead; //free(next); ListErase(phead->next); } //查找 LTNode* ListFind(LTNode* phead, LTDateType x) { assert(phead); LTNode* cur = phead->next; while (cur != phead) { if (cur->data == x) { return cur; } cur = cur->next; } //没找到就返回NULL return NULL; } //pos位置之前插入 void ListInsert(LTNode* pos, LTDateType x) { assert(pos); LTNode* posPrev = pos->prev; LTNode* newnode = BuyListNode(x); //处理posPrev newnode pos三者之间的链接关系 posPrev->next = newnode; newnode->prev = posPrev; newnode->next = pos; pos->prev = newnode; } //删除pos位置 void ListErase(LTNode* pos) { assert(pos); LTNode* posPrev = pos->prev; LTNode* posNext = pos->next; posPrev->next = posNext; posNext->prev = posPrev; free(pos); } //销毁链表 void ListDestroy(LTNode* phead) { assert(phead); LTNode* cur = phead->next; while (cur != phead) { LTNode* next = cur->next; free(cur); cur = next; } free(phead); //想要把phead置为空，需要再函数外部进行置空，当然如果传二级指针也可以在函数内部把 //phead置为空，不过因为我们这个双向链表都是传的一级指针，所以为了保持接口一致性， //我们在函数外部把phead置为空即可 } 好了，双向循环链表的实现就到这里了，其实在这里面最重要的两个接口函数就是ListErase和ListInser，这两个函数可以帮助我们快速的实现这个链表，剩余的就是一些边边角角的问题了。这块的内容还是要多画图，来帮助我们更好的理解。

Parallel_社区达人页

【数据结构入门】-堆的实现以及堆排序（2）

C++中引用的基本内容

详解C++中的命名空间（namespace）

【数据结构入门】二叉树的遍历（前序、中序、后序、层序）

【数据结构入门】-链表之双向循环链表

【数据结构入门】-堆的实现以及堆排序（2）

动态内存管理(万字讲解)（2）

leetcode26.删除有序数组中的重复项

leetcode27.移除元素

【C++】类和对象（中）---拷贝构造函数、赋值运算符重载

leetcode225.用队列实现栈

【C++】类和对象（中）---构造函数和析构函数

leetcode232. 用栈实现队列

leetcode20.有效的括号

【C++】类和对象（上）

【C++入门】内联函数

【C++入门】一篇搞懂auto关键字

C++中引用的基本内容

C++函数重载的简单介绍

C++缺省参数的具体使用

leetcode876.链表的中间节点

【牛客】二叉树遍历

十大排序算法之插入排序、希尔排序、选择排序

详解C++中的命名空间（namespace）

字符串匹配算法(BF&&KMP)