请回答C++-初识C++
在学习过C语言初阶和C语言进阶之后，开始正式学习C++，本文主要涉及C++入门引入的内容是C++的关键字、命名空间、缺省参数、IO、函数重载、内联函数、auto关键字、新型for循环、nullptr、引用为面向对象打好基础
1. 关键字
在关键字中，C++对c语言内容进行了添加和补充，C++对比C新增了31个关键字，达到了63个
下面是所有的关键字，在这里暂时混个眼熟即可未来有了一定基础再尝试理解和使用
2. 命名空间
2.1 认识命名空间
C++和Java的诞生普遍目的都是为了解决C语言的一些缺陷
比如namespace 定义的是一个域，为了避免命名冲突和命名污染问题
C语言的库里面，有两个函数用scanf和strlen名称
假设我的代码里面想用这个两个名称命名变量
int main()
{
int scanf = 10;
int strlen = 20;
// C语言解决不了冲突的问题
scanf("%d", &scanf);
printf("%d\n", scanf);
printf("%d\n", strlen);
return 0;
}
这样就跑不过去
C++可以解决这个问题
通过创建一个命名空间，同时利用::这样一个域作用符来实现名字的隔离,比如下面可以了
namespace allen
{
int scanf=10;
int strlen=20;
}
int main()
{
// Cpp解决冲突
printf("%x\n", scanf);
printf("%x\n", strlen);
scanf("%d", &allen::scanf);
printf("%d\n",allen::scanf);
printf("%d\n",allen::strlen);
return 0;
}
2.2 命名空间的特点
⚡️普通定义
namespace allen
{
int scanf=10;
int strlen=20;
}
⚡️命名空间的嵌套
namespace allen
{
int scanf = 10;
int strlen = 20;
int Add(int left, int right)
{
return left + right;
}
namespace n1
{
int c;
int d;
int Sub(int left, int right)
{
return left - right;
}
// 还可以再套
}
}
int main()
{
allen::n1::Sub(10, 4);
return 0;
}
⚡️如果同一个工程中有多个名称相同的命名空间，最后编译器将其汇合成一个命名空间中
⚡️同一个域中当然也不能同名
2.3 使用命名空间
首先了解：C++库为了防止命名冲突，把自己库里面的东西都定义在一个std的命名空间中
要使用标准库中的东西，有三种方式
⚡️指定命名空间
std::cout << "hello world" << std::endl;
std::vector<int> v;
std::string s;
问题是麻烦，每个地方要用都要指定，但是他是最规范的方式
⚡️把std整个展开，相当于库里面的东西都到全局域了
namespace allen
{
int a = 20;
int b = 10;
}
using namespace allen;//关键字using的使用将命名空间展开到全局
int main()
{
printf("a的值为：%d\n", a);
return 0;
}
看起来方便了，如果我们自己定义的东西跟库冲突了就没办法解决了。一夜回到解放前，所以规范的工程项目中是不推荐这种方式的。
⚡️对部分常用的库里面的东西展开
using std::cout;
using std::endl;
int main()
{
cout << "hello world" << endl;
return 0;
}
针对1和2折中方案，项目中也会经常用
最后再举一个例子熟悉一下
int a = 0;
int main()
{
int a = 1;
printf("%d\n", a);
printf("%d\n", ::a);//空白表示全局域
return 0;
}
3. I/O输入和输出
3.1 头文件与输入输出函数快速入门
🐉使用cout标准输出（控制台）和cin标准输出（控制台）时，必须包含头文件以及std标准命名空间。cpp中输出输入流的头文件是<iostream>
🐉下面给出三个输入输出有关的三个函数
⚡️ostream 类型全局对象 cout
⚡️istream 类型全局对象 cin
⚡️ 全局的换行符号 endl
🐉cin的输入格式为cin >> 变量名，cout输出格式cout << 变量名
cin和cout对比printf和scanf的区别就是这两个函数可以自动识别数据的类型，现在不需要在输出的时候写上%+数据类型了，cin也可以不再像scanf那样该一个变量输入值需要取地址且按照相应的格式
使用示例
int a = 10;
char str[10];
std::cin >> a;
std::cin >> str;
std::cout << a << str << std::endl;
小结：
cout这种输出形式由于自动匹配，所以大多数情况写起来很方便，但是输出时候含格式就不是很方便，所以可以综合使用，哪个好用就用哪个
4. 缺省参数
4.1缺省参数的定义
⚡️缺省参数是声明或者定义函数时为函数的参数指定一个默认值
⚡️在调用函数的时，如果没有指定实参则采用该默认值，否则使用指定的实参。
// 缺省参数
void TestFunc(int a = 0)
{
cout << a << endl;
}
int main()
{
TestFunc(10);
TestFunc();
return 0;
}
比如说这里的TestFunc，当传入10的时候就是输出10，否则不传输出0
4.2 缺省参数的分类
4.2.1全缺省参数
我们把所有参数设置为缺省参数
// 全缺省
void TestFunc(int a = 10, int b = 20, int c = 30)
{
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl << endl;
}
int main()
{
TestFunc(1, 2, 3);
TestFunc();
TestFunc(1);
TestFunc(1,2);
return 0;
}
4.2.2 半缺省参数
半缺省
void TestFunc(int a, int b = 20, int c = 30)
{
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl << endl;
}
// 缺省参数的作用是什么，调用更灵活
int main()
{
TestFunc(1);
TestFunc(1, 2);
TestFunc(1, 2, 3);
return 0;
}
🍁将函数中的部分参数设置为缺省参数
4.3 实际应用
实际开发中，什么时候会用到缺省参数呢？
比如说写数据结构的时候
void StackInit(struct Stack* ps, int InitCapacity = 4) { ps->a = (int*)malloc(sizeof(int) * InitCapacity); ps->size = 0; ps->capacity = InitCapacity; } // 缺省参数-》调用时更灵活 int main() { struct Stack st1; // 假设我知道栈里面至少要存100个数据 StackInit(&st1, 100); struct Stack st2; // 假设我知道栈里面最多要存10个数据 StackInit(&st2, 10); struct Stack st3; // 假设我不知道栈里面可能存多少数据 StackInit(&st2); return 0; }
这是C语言所做不到的，C++提供的特殊的功能，如果我知道要存多少数据，直接改就可以了，但是如果不知道的话，那就按照默认值
4.4 缺省参数注意事项
🌿缺省值必须是常量或者全局变量
🌿半缺省参数其必须从右到左缺省，并且是连续的
🌿缺省参数不能在函数定义和声明中同时出现
//test.h void TestFunc(int a = 5); // test.cpp void TestFunc(int a = 10) { }
🌿 C语言不支持
5. 函数重载
5.1 重载快速入门
和Java中的重载是差不多的意思,C++也可以定义同名的函数
函数重载是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 顺序)必须不同，常用来处理实现功能类似数据类型不同的问题
🌰
int Add(int left, int right)
{
return left + right;
}
int Add(int left = 10, int right = 20)//缺省参数不是重载，如果写了这个会报错
{
return left + right;
}
char Add(char left, char right)
{
return left + right;
}
double Add(double left, double right)
{
return left + right;
}
int main()
{
cout << Add() << endl;//如果不把第一个Add注释掉，就会报错
cout << Add(1, 2) << endl; // 字面量 给的整形默认算常量
cout << Add('1', '2') << endl;
cout << Add(1.1, 2.2) << endl;
return 0;
}
🌰🌰
void f(int a, int b, int c = 1)
{}
void f(int a, int b)
{}
int main()
{
f(1, 2, 3);
// f(1, 2);//err产生了二义性
return 0;
}
所以重载和缺省不能乱用，注意不能踩坑
🌰🌰🌰
void swap(int* a, int* b)
{
// ...
}
void swap(double* a, double* b)
{
// ...
}
int main()
{
int x = 0, y = 1;
swap(&x, &y);
double m = 1.1, n = 2.2;
swap(&m, &n);
return 0;
}
看上去，调用起来更加舒服
⚠️ 注意：返回值不同不构成重载,比如下面的
short Add(short left, short right)
{
return left+right;
}
int Add(short left, short right)
{
return left+right;
}
5.1 名字修饰
此时我们对函数重载提出了疑问
5.1.1为什么C语言不支持重载，C++是怎么实现的
要解决这些个问题需要Linux来辅助演示
⚡️ Linux修饰规则
首先我们知道在C/C++中，一个程序要运行起来，需要经历以下几个阶段：预处理、编译、汇编、链接。
🍁 实际我们的项目通常是由多个头文件和多个源文件构成，而通过编译链接，我们可以知道，【当前a.cpp中调用了b.cpp中定义的Add函数时】，编译后链接前，a.o的目标文件中没有Add的函数地址，因为Add是在b.cpp中定义的，所以Add的地址在b.o中。那么怎么办呢？
🍁 所以链接阶段就是专门处理这种问题，链接器看到a.o调用Add，但是没有Add的地址，就会到b.o的符号表中找Add的地址，然后链接到一起。
🍁 那么链接时，面对Add函数，连接器会使用哪个名字去找呢？这里每个编译器都有自己的函数名修饰规
则。
🍁 由于Windows下vs的修饰规则过于复杂，而Linux下gcc的修饰规则简单易懂
🍁 通过下面我们可以看出gcc的函数修饰后名字不变。而g++的函数修饰后变成【_Z+函数长度+函数名+类型首字母】。
🌿 在linux下，采用gcc编译完成后，函数名字的修饰没有发生改变。
🌿 在linux下，采用g++编译完成后，函数名字的修饰发生改变，编译器将函数参数类型信息添加到修改后的名字中。
简单点说的话就是在函数链接的时候，重载的函数的地址和命名是不同的，所以区分了同名函数
⚡️Windows修饰规则
对比Linux的修饰规则，Windows的则会复杂很多，变换更多
还可以参考如下网站学习函数调用约定和名字修饰规则
🍁 通过这里就理解了C语言没办法支持重载，因为同名函数没办法区分。而C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。
🍁 另外我们也理解了，为什么函数重载要求参数不同，而跟返回值没关系。
5.1.2 extern "C"的作用是什么
有时候在C++工程中可能需要将某些函数按照C的风格来编译，在函数前加extern “C”，意思是告诉编译器，将该函数按照C语言规则来编译。
tcmalloc是google用C++实现的一个项目，他提供tcmalloc()和tcfree两个接口来使用。这些中间件程序，通常我们把它编译成静态库或者是动态库，C++可以找到并使用，这些但如果是C项目就没办法使用，因为修饰方式不同所以找不到，那么解决方法就是使用extern “C”来解决。这样的话C程序也可以调用的了这个库
解决的就是取名时候有extern “C”，也就表示最后链接的时候不要再加名字修饰规则了
而C++也可以通过extern “C”，可以导致都C/C++都可以调用了
不过，这个函数不能重载了
确实用了很多extern "C "
6. 引用
C++中，新引入的引用和指针互相是对标的
6.1 引入的概念
⚡️我们把a改变了值，b也会相应的改变
⚡️同时两个值的地址也是一样的
如何使用引用呢？
类型& 引用变量名(对象名) = 引用实体；
int main()
{
int a = 10;
// b是a的引用(别名)
int& b = a;
b = 20;
int& c = b;
c = 30;
return 0;
}
🍁别名是可以套娃取的
6.2 引用的功能
void swap(int* p1, int* p2)
{
int tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
void swap(int& r1, int& r2)
{
int tmp = r1;
r1 = r2;
r2 = tmp;
}
int main()
{
int a = 1, b = 2;
swap(&a, &b);
swap(a, b);
return 0;
}
引用简化了指针的效果，可以说很好用
struct Stack
{
int* a;
int size;
int capacity;
};
void StackInit(struct Stack* ps)
{}
void StackInit(struct Stack& s)
{}
int main()
{
struct Stack st;
StackInit(&st);
StackInit(st);
return 0;
}
有时候引用简化了使用二级指针
6.3 引用特点
🍁 引用在定义时必须初始化
🍁 一个变量可以有多个引用
🍁 引用一旦引用一个实体，再不能引用其他实体
🍁 引用类型必须和引用实体是同种类型的
double d = 12.34;
int& rd = d; // 该语句编译时会出错，类型不同
🍁 常引用不能放大权限，常变量的引用也得是常引用
const int a = 10;
//int& ra = a; // 该语句编译时会出错，a为常量
const int& ra = a;//应该如此
🍁 常引用权限可以缩小，但是不可以放大
int& b = 10; //
const int& b = 10;//缩小权限是可以接受的
const int& rd = d;
}
🍁 在c中有一个隐式类型转换，现在有一个奇特的语法,const之后可以“隐式转换”引用类型
int c = 10;
double d = 1.11;
d = c; // 隐式类型转换
int c = 10;
double& rc = c;//err
const double& rc = c;//pass
原因是这样的，语法层的理解是：在隐式类型转换的时候，int c会产生一个double类型的临时变量，且这个临时变量具有常性，所以加一个const就可以了
6.4 引用场景快速入门
6.4.1 做参数
比如Swap函数
void Swap(int& left, int& right)
{
int temp = left;
left = right;
right = temp;
}
6.4.2 返回值
传值返回，返回的对象的临时拷贝
传引用返回，返回的是对象的引用
🌸传值返回
int Add(int a, int b)
{
int c = a + b;
return c;
}
int main()
{
const int& ret = Add(1, 2);
return 0;
}
如果返回值用传值法返回int的话，由于是临时变量，是一个具体的空间，且具有常性，所以要加const
🌸传引用返回
不建议的返回形式
int& Add(int a, int b)
{
int c = a + b;
return c;
}
int main()
{
int ret = Add(1, 2);
}
感觉好像没有问题其实有问题,因为Add函数相当出了函数栈帧,栈帧就销毁,那么这块空间相当于已经不属于这个赋引用值的ret了,也就是说,如果此时再要访问,虽然空间暂时没有被销毁,但是已经是越界访问了,结果是不确定的，就好像酒驾，不报错不代表没有问题
有时会输出随机值,比如
int& Add(int a, int b)
{
int c = a + b;
return c;
}
int main()
{
int& ret = Add(1, 2);
Add(5, 7);
cout << ret << endl;
printf("hello world\n");
cout << ret << endl;
return 0;
}
因此一般的代码是不能够用引用返回的
那么什么时候可以利用呢?把属性变成静态的就可以了,这样的话不会被销毁
int& Add(int a, int b)
{
static int c = a + b;
return c;
}
int main()
{
int& ret = Add(1, 2);
Add(5, 7);
printf("hello world\n");
cout << ret << endl;
return 0;
}
小结:
如果函数返回时，出了函数作用域，如果返回对象还未还给系统，则可以使用引用返回，如果已
经还给系统了，则必须使用传值返回。所以说想要用就把该对象置为static属性就可以了
6.5 传值、传引用效率比较
不是说传引用返回一无是处,还是有优点的
先看看传引用作为参数的情况
#include <time.h>
#include<iostream>
using namespace std;
struct A{ int a[10000]; };
void TestFunc1(A a){}
void TestFunc2(A& a){}
void TestRefAndValue()
{
A aa;
// 以值作为函数参数
size_t begin1 = clock();
for (size_t i = 0; i < 10000; ++i){
TestFunc1(aa);
}
size_t end1 = clock();
// 以引用作为函数参数
size_t begin2 = clock();
for (size_t i = 0; i < 10000; ++i){
TestFunc2(aa);
}
size_t end2 = clock();
// 分别计算两个函数运行结束后的时间
cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}
int main()
{
TestRefAndValue();
}
再看看返回值的情况
#include <time.h>
struct A { int a[10000]; };
A a;
// 值返回
A TestFunc1() { return a; }
// 引用返回
A& TestFunc2() { return a; }
void TestReturnByRefOrValue()
{
// 以值作为函数的返回值类型
size_t begin1 = clock();
for (size_t i = 0; i < 100000; ++i)
TestFunc1();
size_t end1 = clock();
// 以引用作为函数的返回值类型
size_t begin2 = clock();
for (size_t i = 0; i < 100000; ++i)
TestFunc2();
size_t end2 = clock();
// 计算两个函数运算完成之后的时间
cout << "TestFunc1 time:" << end1 - begin1 << endl;
cout << "TestFunc2 time:" << end2 - begin2 << endl;
}
int main()
{
TestReturnByRefOrValue();
}
所以说,当参数和返回值都是比较大的变量时,传引用传参和传引用作为返回值还可以提高效率,只要符合条件,尽量用引用传参,传返回值,避免一些深拷贝
6.6 指针VS引用
在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。
// 在语法上，这里给a这块空间取了一个别名，没有新开空间
int& ra = a;
ra = 20;
// 在语法上，这里定义个pa指针变量，开了4个字节，存储a的地址
int* pa = &a;
*pa = 20;
在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。
引用和指针的汇编代码对比,其实底层很像，区别只在换了个别名
6.6.1 引用和指针的不同点:
🍁 引用概念上定义一个变量的别名，种子很存储一个变量的地址
🍁 引用在定义时必须初始化，指针没有要求
🍁 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
🍁 不能直接NULL引用，但有NULL指针
int* p = NULL;
int*& rp = p;
cout << rp << endl;
🍁 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
🍁 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
🍁 有多级指针，但是没有多级引用
🍁 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
🍁 引用比指针使用起来相对更安全
下面我们混合一下指针和引用，来看看下面一段代码的意思
int* pa = &a;
*pa = 20;
int b = 10;
int*& rpa = pa;
rpa = &b;
先是pa指针放着a的地址，再让rpa对pa取别名，然后让rpa引用b的地址，同时pa的地址也改变了
7. 内联函数
7.0 Intro of inline
以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，而不是开一个函数栈帧，函数栈帧是大开销，而如果没有函数压栈的开销，内联函数就可以提升程序运行的效率。
还记得C语言为了小函数避免建立栈帧，提供了宏函数支持，预处理阶段展开，既然C语言已经解决了，为什么C++还要提供inline函数呢？（宏函数的缺点）
C++推荐频繁调用的小函数，定义成inline，会在调用的地方展开，没有栈帧开销
7.1 宏函数的优缺点即内联函数的优点
😄 优点
🛡 增强代码的复用性。
🛡 提高性能。
😢 缺点
🗡预处理阶段展开,无法调试
🗡宏的语法复杂，容易出错
🗡没有类型安全的检查
###🌰写一个Add的宏函数
注意还是比较容易写错的
// #define ADD(int x, int y) return x + y 典型的错误写法
// #define ADD(x, y) x+y;// 不能带分号 err
// #define ADD(x, y) (x)+(y) //err
#define ADD(x, y) ((x)+(y))
那么C语言宏函数的缺点就是C++内联函数的优点
C++有哪些技术替代宏？
- 常量定义 换用const
- 函数定义 换用内联函数
7.2 内联函数快速入门
凡是在汇编中看到有call的一般就是要开辟函数栈帧，不内联的函数就是含call的
怎么样才能看到内联函数具体的汇编呢，想要把debug改成release版，因为debug版本为了方便调试，没有展开内联函数，可以看到内联函数确实没有call，即开一个函数栈帧
但是下面的情况还是会产生影响，来看一下
指令多代表效率低吗，不是这样的，指令多，但是不用开栈帧，所以还是快，问题在于内联是在用空间换时间，当然编译器也是有底线的，函数太大不会让你内联的
7.3 内联函数特点
🍁 inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的函数不适宜
使用作为内联函数。
🍁 inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等
等，编译器优化时会忽略掉内联。
🍁 inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会
找不到。
8. auto关键字
8.0 Intro of auto
在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，但遗憾的是一直没有
人去使用它
C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。
使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类
型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为
变量实际的类型。
8.1 auto快速入门
🍁 auto与指针和引用结合起来使用
用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&
int main()
{
int x = 10;
auto a = &x; // int*
auto* b = &x; // int*
int& y = x; // y的类型是什么？int
auto c = y; // int
auto& d = x; // d的类型是int， 但是这里指定了d是x的引用
// 打印变量的类型
cout << typeid(x).name() << endl;
cout << typeid(y).name() << endl;
cout << typeid(a).name() << endl;
cout << typeid(b).name() << endl;
cout << typeid(c).name() << endl;
cout << typeid(d).name() << endl;
return 0;
}
上面的auto可以自动推导出声明的类型是什么，auto干的就是这个工作
typeid(x).name()用来打印变量的类型
🍁 在同一行定义多个变量
当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对
第一个类型进行推导，然后用推导出来的类型定义其他变量。
void TestAuto()
{
auto a = 1, b = 2;
auto c = 3, d = 4.0; // 该行代码会编译失败，因为c和d的初始化表达式类型不同
}
8.2 auto不能推导的类型
🍁 auto不能作为函数的参数
// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
void TestAuto(auto a)
{}
🍁 auto不能直接用来声明数组
void TestAuto()
{
int a[] = {1,2,3};
auto b[] = {4，5，6};
}
🍁 为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法
🍁 auto在实际中最常见的优势用法就是跟C++11提供的新式for循环，还有lambda表达式等进行配合使用。
9 新型for循环
9.1 范围for的语法
对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。
新for循环，和Java的foreach增强for循环很像
int main()
{
for (auto& e : array)
{
e *= 2;
}
for (auto ee : array)
{
cout << ee << " ";
}
cout << endl;
return 0;
}
9.2 范围for的使用条件
🍁 for循环迭代的范围必须是确定的
对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围。
void TestFor(int array[])//没给范围不可以，err
{//传进来的已经变成指针了
for(auto& e : array)
cout<< e <<endl;
}
🍁 迭代的对象要实现++和==的操作。
int main()
{
int array[] = { 1, 2, 3, 4, 5 };
// 范围for C++11新语法遍历，更简单，数组都可以
// 自动遍历，依次取出array中的元素，赋值给e，直到结束
for (auto e : array)
{
e *= 2;
}
for (auto ee : array)
{
cout << ee << " ";
}
cout << endl;
return 0;
}
打印出来是12345 而不是 246810，说明
e *= 2;，没起作用，这是因为该for循环本质是通过船舰一个临时拷贝，所以出了循环改变就消失了
有如下解决方法，把做运算的for循环写成引用类型即可
for (auto& e : array) { e *= 2; }
如图片使用涉及侵权请私信联系我删除，谢谢
10. 指针空值nullptr(C++11)
10.1 nullptr快速入门
在良好的C/C++编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现不可预料的
错误，比如未初始化的指针。如果一个指针没有合法的指向，我们基本都是按照如下方式对其进行初始化：
NULL实际是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif
可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。不论采取何种定义，在
使用空值的指针时，都不可避免的会遇到一些麻烦
NULL会被认为是一个int，而只有nullptr才是会被看做一个指针
void f(int i)
{
cout << "f(int)" << endl;
}
void f(int* p)
{
cout << "f(int*)" << endl;
}
int main()
{
int* p1 = NULL; // int* p1 = 0;
int* p2 = nullptr;
f(0);
f(NULL);
f(nullptr);
return 0;
}
程序本意是想通过f(NULL)调用指针版本的
f(int*)函数，但是由于NULL被定义成0，因此与程序的初衷相悖。
在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void*)常量，但是编译器默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void *)0。
10.2 nullptr注意事项
🍁 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。
🍁 在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。
🍁 为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。
兄弟们 干净又卫生
892
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
