命名空间
在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是防止与全局作用域冲突
#include <stdio.h>
#include <stdlib.h>
int rand = 10;//与stdlib库里面有一个函数rand冲突了
// C语言没办法解决类似这样的命名冲突问题，所以C++提出了namespace来解决
int main()
{
printf("%d\n", rand);
return 0;
}
编译后后报错：error C2365: “rand”: 重定义；以前的定义是“函数”
关于命名冲突问题
1、我们自己定义的变量、函数可能跟库里面重名冲突
2、在公司项目组，多人协作一个比较大的项目，出现命名冲突很正常
C语言没有办法很好的解决这个问题
所以为了解决这个问题 ，C++提出一个新语法：命名空间–关键字namespace
编译器搜索顺序：
局部域 > 全局域 >展开了命名空间域 or 指定访问命名空间域
局部域有 ，编译器就去局部域搜索 ，如果局部域没有 ，编译器就去全局域搜索 ，如果全局域和局部域都没有 ，编译器也不会去命名空间域去搜索 ，除非将命名空间域展开 or 指定访问命名空间域
展开了命名空间域
//全局域
//int a = 0;
//命名空间域
namespace cxq
{
int a = 1;
}
//展开命名空间域
using namespace cxq;
//局部域
int main()
{
/*int a = 2;*/
printf("%d\n", a);
return 0;
}
指定访问命名空间域
//全局域
int a = 0;
//命名空间域
namespace cxq
{
int a = 1;
}
//局部域
int main()
{
int a = 2;
printf("%d\n", a);//访问局部域
printf("%d\n", ::a);//访问全局域
printf("%d\n", cxq::a);//指定访问命名空间域
return 0;
}
域作用限定符
#include <stdio.h>
#include <stdlib.h>
int a = 0;
int main()
{
int a = 1;
printf("%d\n", a);
// ::域作用限定符
printf("%d\n", ::a);//域作用限定符的左边是空白 ，空白代表全局域
return 0;
}
上述代码增加了域作用限定符，有了域作用限定符，编译器会去域作用限定符的左边这个域访问，左边的域是空白 ，空白代表全局域
//全局域
int a = 0;
//命名空间域
namespace cxq
{
int a = 1;
}
using namespace cxq;//展开了命名空间域
int main()
{
printf("%d\n", a);
return 0;
}
展开了命名空间域 ，相当于暴露到全局中 ，如果此时也没有局部域 ，只有全局域，编译器就无法识别 ，不知道是去全局域中搜索还是去展开的命名空间域中搜素，编译器就会报错
解决C语言命名冲突的最好方式 ，我们采用指定访问命名空间域这种方式
#include <stdio.h>
#include <stdlib.h>
namespace cxq
{
int rand = 10;
}
int main()
{
printf("%d\n", cxq::rand);//指定访问命名空间域
printf("%p\n", rand);
return 0;
}
命名空间定义
命名空间中可以定义变量/函数/类型
#include <stdio.h>
#include <stdlib.h>
//命名空间域
namespace cxq
{
int rand = 10;
struct ListNode
{
struct ListNode* next;
int val;
};
int Add(int x, int y)
{
return x + y;
}
}
int main()
{
//指定访问命名空间域
cxq::rand = 20;
struct cxq::ListNode node;
cxq::Add(3, 5);
return 0;
}
命名空间可以嵌套
#include <stdio.h>
#include <stdlib.h>
//命名空间嵌套
namespace N1
{
int a = 0;
int b;
int Add(int x, int y)
{
return x + y;
}
namespace N2
{
int a = 1 ;
int c;
int d;
int Sub(int x, int y)
{
return x - y;
}
}
}
//使用
int main()
{
printf("%d\n", N1::a);
printf("%d\n", N1::N2::a);
printf("%d\n", N1::Add(3, 5));
return 0;
}
在同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中
我们在一个工程中，我们可以将函数声明和定义分开来写，如下：
//在List.h头文件中只写声明
namespace cxq
{
int rand;
struct ListNode
{
//...
};
void ListInit();
void ListPushBack(struct ListNode* phead, int x);
}
//在List.cpp源文件中写定义
namespace cxq
{
void ListInit()
{
// ...
}
void ListPushBack(struct ListNode* phead, int x)
{
//...
}
}
//在test.cpp源文件中使用
int main()
{
struct cxq::ListNode ln;
cxq::ListPushBack(NULL, 1);
return 0;
}
注意：一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中
C++输入&输出
早期标准库将所有功能在全局域中实现，声明在.h后缀的头文件中，使用时只需包含对应头文件即可，后来将其实现在std命名空间下，为了和C头文件区分，也为了正确使用命名空间，规定C++头文件不带.h；旧编译器(vc 6.0)中还支持<iostream.h>格式，后续编译器已不支持，因此推荐使用+std的方式
注意几点：
1. 使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含< iostream >头文件以及按命名空间使用方法使用std
2. cout和cin是全局的流对象，endl是特殊的C++符号，表示换行输出，他们都包含在包含< iostream >头文件中。
3. <<是流插入运算符，>>是流提取运算符。
4. 使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动控制格式。C++的输入输出可以自动识别变量类型。
5. 实际上cout和cin分别是ostream和istream类型的对象，>>和<<也涉及运算符重载等知识点
#include<iostream>
int main()
{
std::cout << "hello world" <<std::endl ;//指定访问命名空间域
return 0;
}
#include<iostream>
using namespace std;//展开命名空间域, 但是直接展开会有风险，我们如果定义的与库里的重名，就会报错,建议项目不要展开
int main()
{
cout << "hello world" << endl;
return 0;
}
std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中
在一个项目里，建议指定访问命名空间域，不要轻易展开命名空间 ，我们在项目中将常用的关键字展开 ，将常用的展开就不会和c++库里的冲突 ，将不常用的指定访问命名空间
#include<iostream>
#include<list>
#include<vector>
//将常用的展开
using std::cout;
using std::endl;
int main()
{
cout << "hello world" << endl;
cout << "hello world" << endl;
cout << "hello world" << endl;
cout << "hello world" << endl;
cout << "hello world" << endl;
//不常用的指定访问
std::list<int> lt;
return 0;
}
为什么cout能够自动识别变量的类型？
可以自动识别类型
1、可以直接支持内置类型是库里面实现了
2、可以直接支持自定识别类型是因为会去转换为调用对应的运算符重载函数（如上图中的运算符重载函数），这些运算符重载函数彼此之间构成函数重载
缺省参数
缺省参数是声明或定义函数时为函数的参数指定一个缺省值。
没有传参时 ，使用函数的默认值 ，传参时，使用指定的实参
#include<iostream>
//展开命名空间
using namespace std;
void Func(int a = 0)
{
cout << a << endl;
}
int main()
{
Func(); //没有传参时 ，使用函数的默认值
Func(10);//传参时，使用指定的实参
return 0;
}
缺省参数不能在函数声明和定义中同时出现，声明给缺省参数 ，定义不能给缺省参数
全缺省参数
全缺省参数就是为函数的所有参数都设置一个默认参数
例如：
#include<iostream>
//展开命名空间
using namespace std;
void Func(int a = 10, int b = 20, int c = 30)
{
cout << "a = " << a <<endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl;
}
int main()
{
Func();
Func(1);
Func(1, 2);
Func(1, 2, 3);
return 0;
}
从左到右，依次传参，不能跳跃传参
比如以下传参方法就是错误的
Func(,10,);//错误，传参必须是从左往右，连续传参
半缺省参数
半缺省参数必须从右往左依次来给出，不能间隔着给
缺省参数不能在函数声明和定义中同时出现
缺省值必须是常量或者全局变量
半缺省参数必须从右往左缺省，因为传参是从左往右传 ，
缺省参数应用
#include<iostream>
struct Stack
{
int* a;
int top;
int capacity;
};
void StackInit(struct Stack * pst , int defaultcapacity = 4)
{
pst->a = (int * )malloc(sizeof(int)*defaultcapacity);
pst->capacity = defaultcapacity;
pst->top = 0;
}
int main()
{
struct Stack st;
StackInit(&st);
//不知道需要插入多少数据 ，使用缺省参数
return 0;
}
函数重载
是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数
的形参列表(参数个数 或 类型 或 类型顺序)不同，常用来处理实现功能类似数据类型不同的问题
注意：对返回值没有要，返回值不同不能判断是否为函数重载
参数类型不同
//展开命名空间
using namespace std;
//参数类型不同
int Add(int x, int y)
{
cout << "int Add(int x ,int y ) " << endl;
return x + y;
}
double Add(double x, double y)
{
cout << "double Add(double x ,double y ) " << endl;
return x + y;
}
int main()
{
cout<< Add(1, 1)<<endl;
cout<< Add(1.1, 1.1)<< endl;
return 0;
}
参数个数不同
//展开命名空间
using namespace std;
void f()
{
cout << "f()" << endl;
}
void f(int a)
{
cout << "f(int a)" << endl;
}
int main()
{
f();
f(10);
return 0;
}
参数类型顺序不同
//展开命名空间
using namespace std;
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()
{
f(10, 'a');
f('a', 10);
return 0 ;
}
通过这里就理解了C语言没办法支持重载，因为同名函数没办法区分。而C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载
通过这里就理解了C语言没办法支持重载，因为同名函数没办法区分。而C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。
如果两个函数函数名和参数是一样的，返回值不同是不构成重载的，因为调用时编译器没办法区分
引用
引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间
int main()
{
int a = 0;
int& b = a;
return 0;
}
//展开命名空间
using namespace std;
int main()
{
int a = 0;
int& b = a;
int& c = b;
int& d = a;
cout << &a << endl;
cout << &b << endl;
cout << &c << endl;
cout << &d << endl;
b++;
d++;
return 0;
}
如图所示：b， c， d 都是a的别名，，因为别名本身代表的就是a，所以别名值的改变也会影响变量a，并且a ,b, c, d 变量的地址都是同一地址，也就是说引用实体和引用变量共用同一块内存空间。
引用的特性
注意：引用类型必须和引用实体是同种类型的
引用在定义时必须初始化
void func()
{
int a = 10;
//int& b; //err，定义引用必须初始化
int &b = a;//正确处理
}
一个变量可以有多个引用
#include<iostream>
//展开命名空间域
using namespace std;
int main()
{
//一个变量可以有多个引用
int a = 0;
int& b = a;
int& c = b;
return 0;
}
引用一旦引用一个实体，再不能引用其他实体
#include<iostream>
//展开命名空间域
using namespace std;
int main()
{
//一个变量可以有多个引用
int a = 0;
int& b = a;
int& c = b;
return 0;
// 引用一旦引用一个实体，就不能再引用其他实体
int x = 10;
c = x;// x的值赋给c，c依旧是a或者b的对象别名
return 0;
}
引用的使用场景
引用作参数（输出型参数）
//展开命名空间域
using namespace std;
void Swap(int& a, int& b)//引用作参数
{
int tmp = a;
a = b;
b = tmp;
}
int main()
{
int x = 0, y = 1;
Swap(x, y);
cout << x << " "<< y << endl;
return 0;
}
以前单链表中使用二级指针传参
现在我们可以使用选择一级指针的引用代替之前的二级指针传参的写法。phead就是plist的引用，改变phead就是改变plist（形参是实参的别名 ，形参改变就影响实参）
typedef struct ListNode
{
int val;
struct ListNode* next;
}*PNode;
void LTPushBack(PNode& phead, int x);
//int* preorderTraversal(struct TreeNode* root, int* returnSize); //-- c ,形参是实参的地址 ，形参的解引用就改变实参
//int* preorderTraversal(struct TreeNode* root, int& returnSize); -- cpp,形参是实参的别名 ，形参改变就影响实参
//展开命名空间域
using namespace std;
void Swap(int*& a, int*& b) //形参 ，形参是实参的引用 （ 别名）
{
int* tmp = a;
a = b;
b = tmp;
}
int main()
{
int x = 0, y = 1;
int* px = &x, * py = &y;
cout << px << " " << py << endl;
Swap(px, py); //实参
cout << px << " " << py << endl;
return 0;
}
引用做返回值
引用作返回值可以减少拷贝，提高效率
并且还可以修改返回值和获取返回值
代码一：
//引用作返回值
int Count()
{
static int n = 0;
n++;
// ...
return n;
}
int main()
{
int ret= Count();
return 0;
}
代码二：
//传引用返回
int& Count()
{
static int n = 0;
n++;
// ...
return n;
}
int main()
{
int ret = Count();
return 0;
}
代码一的n不能直接返回，会生成临时变量 ，临时变量有可能是寄存器
但是代码二使用引用作为返回值，就不会生成临时变量，减少拷贝，提高效率 ，代码二用n的引用（别名）作为返回值 ,代码二不危险
代码三：
//传引用返回
int& Count()
{
int n = 0;
n++;
// ...
return n;
}
int main()
{
int ret = Count();
cout << ret << endl;
return 0;
}
返回的是n的别名 ，n本来是0 ,当 n的值给ret时 ，n是局部变量 ，出作用域销毁 ，n的使用权归还给操作系统 ，也就是说ret的值是随机值 ，是不确定的
如果Count函数结束 ，函数栈帧销毁，没有清理栈帧 ，那么ret的结果侥幸是正确的
如果Count函数结束 ，函数栈帧销毁，清理栈帧 ，此时再去访问销毁的空间 ，就是非法访问 ，那么ret的结果就是随机值
代码四：
int& Count()
{
int n = 0;
n++;
// ...
return n;
}
int main()
{
int& ret = Count(); //ret是n的别名 ，ret和n共用同一块空间
cout << ret << endl;
Count();
cout << ret << endl;
return 0;
}
总结：
1、基本任何场景都可以用引用传参
2、谨慎用引用做返回值。出了函数作用域，对象不在了，就不能用引用返回，如果对象还在就可以用引用返回
常引用
常引用与权限的放大 、缩小、平移有联系
权限放大
引用的过程中，权限不能放大
#include<iostream>
using namespace std;
int main()
{
//不可以
//引用的过程中，权限不能放大
const int a = 0;
int& b = a;
//可以，c拷贝给d，没有放大权限，因为d的改变不影响c
const int c = 0;
int d = c;
return 0;
}
int func1( )
{
static int x = 0;
return x;
}
int& func2( )
{
static int x = 0;
return x;
}
int main()
{
//可以
int ret1 = func1( );
//不可以 ，权限的放大
//int& ret1 = func1( );
const int & ret1 = func1();//权限平移
return 0;
}
const int a =10 ;
int * pb = &a ;
指针和引用类似，涉及权限放大
权限缩小
权限缩小 ，缩小z作为x的别名的权限 ，缩小的是z的权限 ，不是x的权限,所以x可以改变 ，z不能改变
int main()
{
//可以 ，引用的过程中，权限不可以放大 ，但是可以平移或者缩小
int x = 0;
int& y = x; //权限平移
const int& z = x;//权限缩小 ，缩小z作为x的别名的权限 ，缩小的是z的权限 ，不是x的权限,所以x可以改变 ，z不能改变
x++;
//z++;//err
return 0;
}
int main()
{
const int& m = 10;//可以
return 0;
}
权限平移
#include<iostream>
using namespace std;
int func1()
{
static int x = 0;
return x;
}
int& func2()
{
static int x = 0;
return x;
}
int main()
{
int& ret2 = func2(); //权限平移
const int& ret2 = func2();//权限缩小
return 0;
}
int main()
{
//隐式类型转换
double dd = 1.11;
int ii = dd;
//不可以
//int& rii = dd;
//可以
const int& rii = dd;
return 0;
}
引用在语法层面不开空间， 但是从底层汇编指令实现的角度看 ，引用时类似指针的方式去实现的
引用和指针的不同点:
- 引用概念上定义一个变量的别名，指针存储一个变量地址。
- 引用在定义时必须初始化，指针没有要求
- 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型
实体- 没有NULL引用，但有NULL指针
- 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
- 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
- 有多级指针，但是没有多级引用
- 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
- 引用比指针使用起来相对更安全
int main()
{
//语法层面，不开空间 ,是对a取别名
int a = 10;
int& ra = a;
ra = 20;
//语法层面，不开空间 ，存储a的地址
int* pa = &a;
*pa = 30;
return 0;
}
内联函数
内联 :不需要建立函数栈帧 ，不复杂 ，不容易出错 ，可读性不错，还可以调试 ，那每个函数都变成内联可行吗 ？ 如果每个函数都变成内联 ，会让可执行程序变大
内联适用于短小且频繁调用的函数
inline对于编译器仅仅只是一个建议 ，最终是否成为inline ,编译器自己决定
比较长的函数 和递归函数 ， 加了inline ，也会被编译器否决掉
内联函数声明和定义不能分离 ，内联函数没有函数地址，不会进入编译器的符号表，如果函数声明和定义分离会导致链接失败
如果使用内联 ，函数声明和定义就不要分离 ，直接定义在头文件就行
auto关键字(C++11)
auto是c++11引进的关键字.
C++11中，标准委员会赋予了auto全新的含义即：
auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得
int main()
{
int a = 0;
int b = a;
auto c = a;//根据右边的表达式自动推到c的类型
auto d = 1 + 1.11;//根据右边的表达式自动推到d的类型
cout << typeid (c).name() << endl;
cout << typeid (d).name() << endl;
return 0;
}
int main()
{
int arr[] = { 1,2,3,4,5, };
//范围for 语法糖
//依次取数组中的数据复制给e
// 自动迭代 ，自动结束
for (auto e : arr)
{
cout << e<< " ";
}
cout << endl;
//修改数据
for (auto& e : arr)
{
e *= 2;
cout << e << " ";
}
return 0;
}
auto的使用细则
auto与指针和引用结合起来使用
用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&
int main()
{
int x = 10;
auto a = &x;
auto* b = &x;
auto& c = x;
int arr[] = { 1,2,3 };
for (auto& x: arr)
{
x++;
}
for (auto& x : arr)
{
cout << x << endl;
}
return 0;
}
在同一行定义多个变量
当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量
void TestAuto()
{
auto a = 1, b = 2;
auto c = 3, d = 4.0; // 该行代码会编译失败，因为c和d的初始化表达式类型不同
}
auto不能推导的场景
auto做为函数的参数
// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
void TestAuto(auto a)//err
{}
auto不能直接用来声明数组
void TestAuto()
{
int a[] = {1,2,3};
auto b[] = {4，5，6};//err
}
基于范围的for循环(C++11)
C++11引入范围for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围
:前是循环变量，：后面是循环范围
c++中的范围for 与普通循环类似，也可用continue来结束本次循环，也可以用break来跳出整个循环。
//C
for (int i = 0; i < sz; i++)
{
cout << arr[i] << endl;
}
//C++
for (auto e : arr)
{
cout << e << endl;
}
注意： 范围 for 循环返回的对象是数组元素值的拷贝，需要使用引用
for (int i = 0; i < sz; i++)
{
arr[i] *= 2;
}
for (auto& e : arr)
{
e *= 2;
}
for循环迭代的范围必须是确定的 ,对于数组而言，就是数组中第一个元素和最后一个元素的范围
void func(int arr[])
{
for (auto e : arr)
{
cout << e << endl; //不知道数组的具体范围，err
}
}
范围 for 循环返回的对象是数组元素值的拷贝，所以若要写入数组元素的话，需要使用引用
for (int i = 0; i < sz; i++)
{
arr[i] *= 2;
}
for (auto& e : arr)
{
e *= 2;
}
迭代的对象要实现++和==的操作
指针空值nullptr(C++11)
NULL其实是一个宏，在传统的C头文件(stddef.h)中可以看到如下代码：
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif
可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦，如下代码
#include<iostream>
using namespace std;
void f(int)
{
cout << "f(int)" << endl;
}
void f(int*)
{
cout << "f(int*)" << endl;
}
int main()
{
f(0);//int
f(NULL);//int
f(nullptr);//int*
return 0;
}
程序本意是想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，因此与程序的初衷相悖。
注意：
在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。
在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。
为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr文章来源：https://www.toymoban.com/news/detail-433763.html
如果你觉得这篇文章对你有帮助，不妨动动手指给点赞收藏加转发，给鄃鳕一个大大的关注
你们的每一次支持都将转化为我前进的动力！！！文章来源地址https://www.toymoban.com/news/detail-433763.html
到了这里，关于解决C语言的缺陷【C++】的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
![[C++] C++入门第一篇 -- 命名空间，输入输出，缺省函数，函数重载底层原理](https://imgs.yssmx.com/Uploads/2024/02/611018-1.png)
