四、新的关键字

一、动态类型分配（c中用库函数实现，c++中用关键字）

（1）.动态内存分配用new关键字
（2）.删除用delete关键字

#include<stdio.h>
int main()
{
    int *p1 = new int;
    char *p = new char[10];
    *p1 = 5;
    p[0] = 'a';
    printf("%d\n",*p1);
    printf("%c\n",p[0]);
    delete p1;//一定要记得释放
    delete[] p;//注意释放的方法不一样
    getchar();
    return 0;
}

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

#include<stdio.h>
int main()
{
    char *p = new char('c');
    int *p1 = new int(3);
    printf("%c\n",*p);//打印字符c
    printf("%d",*p1);//打印3
    delete p;//最后要记得释放
    delete p1;
    getchar();
    return 0;
}

二、c++中的命名空间

（1）.在C语言中只有一个全局作用域，所以的全局标识符共享一个作用域，标识符之间可能发生冲突
（2）.c++中提出命名空间的概念：
命名空间将全局作用域分成不同的部分，不同命名空间中的标识符可以同名而不会发生冲突
命名空间可以互相嵌套
全局作用域也叫默认空间命名（c原来的全局作用域）
（3）.c++命名空间的定义：
namespace name{}

（4）.如何使用命名空间里面的东西？
使用整个命名空间： using namespace name;
使用命名空间中的变量：using name::variable;
使用默认命名空间的变量（即没有名字的命名空间）： ::variable;

#include<iostream>
using namespace std;
namespace first
{
    namespace four
    {
        int i = 5;
        int b = 9;
    }

}
namespace second
{
    namespace third
    {
        int x=6;
        int y=7;
    }
}
int a = 2;
int main()
{

    using namespace first::four;
    using second::third::x;//注意使用某个变量时不需要namespace
    printf("%d\n", ::a);//使用默认命名空间
    printf("%d\n",i);//four 命名空间已经被打开，里面的东西都可以用
    printf("%d\n", b);//four 命名空间已经被打开，里面的东西都可以用
    printf("%d\n",x);
    //printf("%d\n", y);//会报错，因为y没有打开被使用
    getchar();
    return 0;
}

三、强制类型转换

1.c方式的强制类型转换：（Type）（expression）或Type（expression）两者无本质区别
c转换的问题：
（1）.过于粗暴：任意类型的都可以转换，编译器难以判断
（2）.难以定位：在源码中无法快速定位所有使用的强制类型转换的语句

2.c++将强制类型转换分成四种不同类型（static_cast、const_cast、dynamic_cast、reinterpret_cast。c++将这四个变成自己的关键字）
（1）.static_cast：
a. 用于基本类型间的转换，但不能用于基本类型指针的转换（int to char）
b. 用于有继承关系类对象之间的转换和类指针之间的转换
c. static_cast是编译期进行转换的，无法在运行时检查类型，所以类型
之间的转换可能存在风险

#include<stdio.h>
int main()
{
    int i = 97;
    char c;
    int *p1 = &i;
    char *p2;
    c = static_cast<char>(i);
    //p2 = static_cast<char *>(p1);//报错，基本类型的指针无法转换
    printf("%c\n",c);
    getchar();
    return 0;
}

（2）.const_cast：用于去除变量的const属性，用于指针或者引用

#include<stdio.h>
int main()
{
    const int& j = 2;//之前在const引用那里讲过，这里为为常量分配了空间，只读变量
    int& k = const_cast<int&>(j);//去掉只读变量的特性
    k = 3;
    printf("%d\n",j);//打印的值都是3
    printf("%d\n",k);
    getchar();
    return 0;
}

#include<stdio.h>
int main()
{
    const int j = 2;
    int& k = const_cast<int&>(j);//去掉常量的特性
    k = 3;
    printf("%d\n",j);//打印的值都是2
    printf("%d\n",k);//打印的值是3
    //原因：j是常量，在符号表里，即使为它分配了地址，也不用里面的值
    getchar();
    return 0;
}

（3）.reinterpret_cast：
用于指针间的强制类型转换
用于整数和指针类型的强制类型转换

#include<stdio.h>
int main()
{
    int j = 97;
    int *p1 = &j;
    char *p2;
    p2 = reinterpret_cast<char*>(p1);//用于指针类型的转换
    printf("%c\n",*p2);
    getchar();
    return 0;
}

（4）.dynamic_cast：
主要用于类层次间的转换，还可以用于类之间的交叉转换
具有类型检查功能，比static_cast安全