5 新的关键字

动态内存分配

回想C语言中，动态内存是怎么分配的？通过C库里面的malloc free去进行动态内存分配。
C++通过new关键字进行动态内存申请，动态内存申请是基于类型进行的。
delete 关键字用于内存释放。

//变量申请
type* pointer = new type;
delete pointer;//数组申请
type* pointer = new tyep[10];
delete[] pointer;
//数组释放一定要加 []
int *p = new int[10];
//.......
delete p;//会造成内存泄漏。这句话的意思是告诉编译器只释放p指向的一个int型空间，而不是所有的数组空间。
delete [] p;//正确的写法

new关键字与malloc函数的区别

new关键字是c++的一部分，malloc是由c库提供的函数。
new以具体类型为单位进行内存分配，而malloc只能以字节为单位进行内存分配。
new在申请单个类型变量时可进行初始化，malloc不具备内存初始化的特性。

#include <stdio.h>int main()
{int* a = new int(6);float* b = new float(7.0);char* c = new char('c');printf("*a = %d, *b = %f, *c = %c\n", *a, *b, *c);delete a;delete b;delete c;return 0;
}

C++中命名空间

在C语言中，只有一个全局作用域。C语言中所有的全局标识符共享同一个作用域，那么项目很大时，标识符之间就有可能发生冲突。
C++中提出了命名空间的概念。目的是将全局作用域划分为不同的块。
命名空间定义：
namespace name { /…/}

#include <stdio.h>
namespace First
{int i = 0;
}
namespace Second
{int i = 1;namespace Internal{struct P{int x;int y;};}
}int main()
{return 0;
}

命名空间的使用

使用整个命名空间： using namespace name;
使用命名空间中的变量：using name::variable
使用默认命名空间中的变量：::variable
默认情况下，可以直接使用默认命名空间中所有的标识符。

#include <stdio.h>
namespace First
{int i = 0;
}
namespace Second
{int i = 1;namespace Internal{struct P{int x;int y;};}
}int main()
{using namespace First;//告诉编译器，解开First域using Second::Internal::P;//告诉编译器要用Second空间中Internal空间中的P成员变量。printf("i = %d\n", i);//打印0，使用的是First 空间中的i。因为我们没有解开Second 空间printf("i = %d\n", Second::i);//打印1，告诉编译器访问的是Second 空间中的i。P p = {2, 3};printf("p.x=%d, p.y=%d\n", p.x, p.y);return 0;
}

在这里插入图片描述

强制类型转换

C方式的强制类型转换(type)(expression) or type(expression)

#include <stdio.h>
//定义一个函数指针
typedef void(PF)(int);struct Point
{int x;int y;
};int main()
{int v = 0x12345;//将变量v强制类型转换为函数指针PF* pf = (PF*)v;//将变量v强制类型转换为char型char c = char(v);//调用v变量强制转换为函数的地址函数，此处不一定是函数。pf(v);//将v变量强制转换为结构体指针。Point* p = (Point*) v;printf("p->x = %d\n", p->x);printf("p->y = %d\n", p->y);
}

在这里插入图片描述

C强制类型转换过于粗暴，任意类型之间都可以进行转换，编译器很难判断其正确性；且在源码中无法快速定位所有使用强制类型转换的语句，出现问题时难以定位。
在现代软件工程中，最难定位问题的三种问题：
1.强制类型转换。
2.多线程的交互。
3.位运算优先级，数学运算、逻辑运算混在一起。
在程序设计理论中，强制类型转换也是不被推荐的，与goto语句一样，尽量避免。
C++提供了更安全的强制类型转换。将强制类型转换分为4中不同的类型。static_cast const_cast dynamic_cast reinterpret_cast 。用法xxx_cast<type>(expression)

static_cast

用于基本类型间的转换，但不能用于基本类型指针间的转换
用于有继承关系类对象之间的转换和类指针之间的转换。

#include <stdio.h>int main()
{int i = 8;char c = 'B';int* pi = &i;char * pc = &c;c = static_cast<char>(i);pc = static_cast<char*>(pi);	return 0;
}

在这里插入图片描述
static_cast是编译期进行转换的，无法在运行时检测类型。所以类类型之间的转换可能存在风险。

const_cast

用于去除变量的const属性

#include <stdio.h>int main()
{//const 引用j,初始化的时候j就是一个只读变量。//注意第二节讲到 const引用只有定义的别名拥有只读属性，不会影响到正名const int& j = 1;//将只读变量j的const属性去掉，j就降级为普通变量。int& k = const_cast<int&>(j);//声明一个真正的常量x。const int x = 2;//由于对x常量取引用，前面学习了，引用本身就是地址别名，是指针。//所以此处编译器会为这个常量分配一个空间。//y就指向了常量x的地址，y就变成了普通变量。int& y = const_cast<int&>(x);//将j的值改为6k = 6;//j 和 k的值一致。printf("j = %d,k = %d\n", j, k);//将x的变量改成8y = 8;//所以x 和 y的地址一样的。//const引用只有定义的别名拥有只读属性，不会影响到正名，所以x的值还是2，因为是常量，编译器直接替换。printf("x = %d, y = %d\n", x, y);printf("&x = %p, &y = %p\n", &x, &y);return 0;
}

在这里插入图片描述
上面程序中运用到了第二节的知识点：const 常量只有定义的别名拥有只读属性，不会影响到正名。
int& y = const_cast<int&>(x);在解除const属性时，会为x分配内存空间，此时引用y指向这段编译器为x分配的空间，引用y就是普通变量。但是x还是常量，编译器依然认为其不能被赋值。假如下面有一段语句x=8；则编译器还是会报错。

reinterpret_cast

用于指针类型间的强制类型转换
用于整数和指针类型间的强制转换
reinterpret_cast直接从二进制位进行复制，是一种及其不安全的转换。

#include <stdio.h>typedef void (PF)(int);int main()
{int i = 0;char c = 'C';//将字符变量c的地址强制转换为int型指针，并且赋值给pi指针。int* pi = reinterpret_cast<int*>(&c);//将int变量i的地址强制转换为char型指针，并赋值给pc指针。char* pc = reinterpret_cast<char*>(&i);//将0x888888地址，强制转换为PF型函数指针，并赋值给pf指针。PF* pf = reinterpret_cast<PF*>(0x888888);//将int类型变量转换为char，不是用reinterpret_cast，而是static_castc = reinterpret_cast<char>(i);return 0;
}