study_c++_day1_关键字解释

最新推荐文章于 2024-09-15 11:40:06 发布

大田菜

最新推荐文章于 2024-09-15 11:40:06 发布

阅读量344

点赞数

分类专栏： study-c++ 文章标签： c++

原文链接：https://blog.csdn.net/wuxinliulei/article/details/9787901

版权

study-c++ 专栏收录该内容

28 篇文章 4 订阅

订阅专栏

asm (指令字符串)：允许在 C++ 程序中嵌入汇编代码。

auto

auto（自动，automatic）是存储类型标识符，表明变量"自动"具有本地范围，块范围的变量声明（如for循环体内的变量声明）默认为auto存储类型。

在C++ 98 中，auto 的作用是让变量成为自动变量（拥有自动的生命
周期），但是该作用是多余的，变量默认拥有自动的生命周期，在
C++ 11 中，已经删除了该用法，取而代之的作用是：自动推断变量的
类型。
举一个例子：
int a=0;
auto b=a;
std::cout<<typeid(b).name<<std::end;
输出的结果就是int，typeid函数可以输出变量的类型。

但是在实际使用过程中上面的用法并不常用，它的实际用法如下（主要用
于代替***冗长复杂，变量使用范围专一***的变量声明）
std::vector<std::string> vec;
for (auto iter = vec.begin(); iter != vec.end(); ++iter)
 {}
在定义函数模板时，用于声明依赖模板参数的变量类型
模板函数依赖于模板参数的返回值，比如：
template<typename Tx, typename Ty>
auto multiply(Tx x, Ty y)
{
return x * y;
}

bool

bool（布尔）类型，C++ 中的基本数据结构，其值可选为 true（真）或者 false（假）。C++ 中的 bool 类型可以和 int 混用，具体来说就是 0 代表 false，非 0 代表 true。bool 类型常用于条件判断和函数返回值。(c++书中的有罪裁决及无罪裁决值得就是bool)

break

break（中断、跳出），用在switch语句或者循环语句中。程序遇到 break 后，即跳过该程序段，继续后面的语句执行。

例子如下：
    switch (choice)
    {
        case 'A' :
            cout<< "You entered A. \n";
            break;
        case 'B' :
            cout << "You entered B. \n";
            break;
        case 'C' :
            cout << "You entered C.\n";
            break;
        default:
            cout << "You did not enter A, B, or C!\n";
            break;//(此处的break可以要也可以不要)
    }
    return 0;
}

case

用于 switch 语句中，用于判断不同的条件类型。

catch

catch 和 try 语句一起用于异常处理。

try 
{
    语句组
}
catch(异常类型)
 {
    异常处理代码
}
...
catch(异常类型) 
{
    异常处理代码
}
//其中catch可以有很多个，但是至少有一个。

char

char（字符，character）类型，C++ 中的基本数据结构，其值一般为 0~255 的 int。这 256 个字符对应着 256 个 ASCII 码。char 类型的数据需要用单引号 ’ ’ 括起来。
在这里插入图片描述

8.class

class（类）是 C++ 面向对象设计的基础。使用 class 关键字声明一个类。
9. const

const（常量的，constant）所修饰的对象或变量不能被改变，修饰函数时，该函数不能改变在该函数外面声明的变量也不能调用任何非const函数。在函数的声明与定义时都要加上const，放在函数参数列表的最后一个括号后。在 C++ 中，用 const 声明一个变量，意味着该变量就是一个带类型的常量，可以代替 #define，且比 #define 多一个类型信息，且它执行内链接，可放在头文件中声明；但在 C 中，其声明则必须放在源文件（即 .C 文件）中，在 C 中 const 声明一个变量，除了不能改变其值外，它仍是一具变量。如:

const double pi(3.14159);
或 
const double pi = 3.14159;

const_cast用法：
const_cast<type_id> (expression)

该运算符用来修改类型的 const 或 volatile 属性。除了 const 或 volatile 修饰之外， type_id 和 expression 的类型是一样的。常量指针被转化成非常量指针，并且仍然指向原来的对象；常量引用被转换成非常量引用，并且仍然指向原来的对象；常量对象被转换成非常量对象。

const_cast是一种C++运算符，主要是用来去除复合类型中const和volatile属性（没有真正去除）。
变量本身的const属性是不能去除的，要想修改变量的值，一般是去除指针（或引用）的const属性，再进行间接修改。
用法:const_cast<type>(expression)
通过const_cast运算符，也只能将const type*转换为type*，将const type&转换为type&。
也就是说源类型和目标类型除了const属性不同，其他地方完全相同。

#include<iostream>
using namespace std;
void ConstTest1(){
    const int a = 5;
    int *p;
    p = const_cast<int*>(&a);
    (*p)++;
    cout<<a<<endl;
    cout<<*p<<endl;
    
}
void ConstTest2(){
    int i;
    cout<<"please input a integer:";
    cin>>i;
    const int a = i;
    int &r = const_cast<int &>(a);
    r++;
    cout<<a<<endl;
}
int main(){
    ConstTest1();
    ConstTest2();
    return 0;
}
输出：
5
6
若输入7
则输出8

continue

continue（继续）关键字用于循环结构。它使程序跳过代码段后部的部分，与 break 不同的是，continue 不是进入代码段后的部分执行，而是重新开始新的循环。因而它是"继续循环"之意，不是 break（跳出）。
三中循环语句的continue作用
在这里插入图片描述
12. default

default（默认、缺省）用于 switch 语句。当 switch 所有的 case 都不满足时，将进入 default 执行。default 只能放在 switch 语句所有的 case 之后，并且是可选的。

delete

delete（删除）释放程序动态申请的内存空间。delete 后面通常是一个指针或者数组 []，并且只能 delete 通过 new 关键字申请的指针，否则会发生段错误。

delete操作后：
我们在删除一个指针之后，编译器只会释放该指针所指向的内存空间，而不会删除这个指针本身。

1.假如你不去释放，那么该区域的内存始终不能被其他数据所使用。
2.指向该内存的指针是个局部变量，当定义给指针的函数结束并返回时，指针也就消失了，那么就再也找不到该块的内存区域。
假如指向该内存区域的指针自动消失了，计算机就再也找不到该区域的内存了，就好像丢了这块内存一样，这种情况称为“内存泄漏”。
这种情况直到程序结束该区域的内存才能恢复使用。

内存泄漏:（Memory Leak）是指程序中己动态分配的堆内存由于某种原因程序未释放或无法释放，造成系统内存的浪费，导致程序运行速度减慢甚至系统崩溃等严重后果。

野指针：指向被释放的或者访问受限内存的指针。(感觉就是不正常的指针)

造成野指针的原因：

指针变量没有被初始化,因为会分配一个随机的值.若它指向非法地址，这时的操作会报异常；若它指向一个合法地址，更危险，因为这样可能更改一个正在使用的数值（声明后需要指向一个变量或者指向堆里的内存）
指针被free或者delete后，没有置为NULL, free和delete只是把指针所指向的内存给释放掉，并没有把指针本身干掉，此时指针指向的是“垃圾”内存。释放后的指针应该被置为NULL.
指针操作超越了变量的作用范围，比如返回指向栈内存的指针就是野指针。
与空指针不同，野指针无法通过简单地判断是否为 NULL避免，而只能通过养成良好的编程习惯来尽力减少。对野指针进行操作很容易造成程序错误。需对指针进行初始化。

例子：

刚开始我们用new来创建一个指针，等用完之后，用delete将指针删除掉，但是没有只是删除这个值真真简单；比如：

#include <iostream>
using namespace std;
int main()
{
int *p=new int;
*p=6;
cout<<"将3赋给p的地址后，指针p读的值："<<*p<<endl;
delete p;
cout<<"删除空间后，指针p读的值："<<*p<<endl;
long *p1=new long;
*p1=2;
cout<<"创建新空间后，指针p保存的地址："<<p<<endl;
cout<<"p1的地址"<<p1<<endl;
*p=12;
cout<<"重新赋值后，p的值"<<*p<<endl;
cout<<"重新赋值后，p1的值"<<*p1<<endl;
delete p1;
return 0;
}
运行结果如下：

将3赋给p的地址后，指针p读的值：6
删除空间后，指针p读的值：0
创建新空间后，指针p保存的地址：0x2538010
p1的地址0x2538010
重新赋值后，p的值12
重新赋值后，p1的值12

避免以上结果出现就要在删除指针后再接一个赋值被删除的指针为null
（即在delete *p之后一定要加上： p=NULL）；

do-while是一类循环结构。与while循环不同，do-while循环保证至少要进入循环体一次。

double

double（双精度）类型，C++ 中的基本数据结构，以双精度形式存储一个浮点数。

dynamic_cast

dynamic_cast（动态转换），允许在运行时刻进行类型转换，从而使程序能够在一个类层次结构安全地转换类型。dynamic_cast 提供了两种转换方式，把基类指针转换成派生类指针，或者把指向基类的左值转换成派生类的引用。

dynamic_cast可以获取目标对象的引用或指针：

T1 obj;

T2* pObj = dynamic_cast<T2*>(&obj);//转换为T2指针，失败返回NULL

T2& refObj = dynamic_cast<T2&>(obj);//转换为T2引用，失败抛出bad_cast异常
多态类型

在使用时需要注意：被转换对象obj的类型T1必须是多态类型，即T1必须
公有继承自其它类，或者T1拥有虚函数（继承或自定义）。若T1为非多态
类型，使用dynamic_cast会报编译错误。

else

else 紧跟在 if 后面，用于对 if 不成立的情况的选择。

enum

enum（枚举）类型，给出一系列固定的值，只能在这里面进行选择一个。

步骤(一)——枚举量的声明和定义

(1)首先，请看下面的语句：


enum enumType {Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday};

这句话有两个作用：

第一：声明enumType为新的数据类型，称为枚举(enumeration);

第二：声明Monday、Tuesday等为符号常量，通常称之为枚举量，其值默
认分别为0-6。（后面会介绍怎样显式的初始化枚举量的值）

(2)接着利用新的枚举类型enumType声明这种类型的变量：enumType Weekday'就像使用基本变量类型int声明变量一样，如 int a;也可以在定
义枚举类型时定义枚举变量enum enumType {Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday}Weekday;

然而与基本变量类型不同的地方是，在不进行强制转换的前提下，只能将
定义的枚举量赋值给该种枚举的变量，如：Weekday = Monday;或者
Weekday = Sunday;不能将其他值赋给枚举变量，如：Weekday = 10;这是
不允许的，因为10不是枚举量。也就是说Weekday只能是定义的Monday-
Sunday这些定义过的枚举量。然而这不是绝对的，第六条会讲到利用强制
类型转换将其他类型值赋给枚举变量。


(3)上面讲不能将非枚举量赋给枚举变量，那么能不能将枚举量赋给非枚
举变量呢？如：int a=Monday;这是允许的，因为枚举量是符号常量，这
里的赋值编译器会自动把枚举量转换为int类型。


(4)前面讲可以对枚举进行赋值运算，那枚举变量能不能进行算术运算
呢？

Weekday++;Weekday = Monday + Tuesday;这是非法的，因为这些操作可
能导致违反类型限制，比如：Weekday = Sunday;


Weekday++;Weekday首先被赋予枚举量中的最后一个值Sunday(值为6)，再
进行递增的话，Weekday增加到7，而对于enumType类型来说，7是无效
的。

总结：对于枚举，只定义了赋值运算符，没有为枚举定义算术运算。


(5)不能对枚举量进行算术运算，那么枚举量能不能参与其他类型变量的
运算呢？int a;a = 1 + Monday;这是允许的，因为编译器会自动把枚举
量转换为int类型。

(6)第二条讲：在不进行强制转换的前提下，只能将定义的枚举量赋值给
该种枚举的变量，言下之意就是可以通过强制转换将其他类型值赋给枚举
变量：

Weekday = enumType(2);等同于：Weekday = Wednesday;但是，如果试图
将一个超出枚举取值范围的值通过强制转换赋给枚举变量，会出现什么结
果？

Weekday = enumType(20);结果将是不确定的，这么做不会出错，但得不
到想要的结果。

步骤(二)——自定义枚举量的值


(1)前面讲通过定义enum enumType {Monday, Tuesday, Wednesday, 
Thursday, Friday, Saturday, Sunday};

枚举量Monday、Tuesday等的值默认分别为0-6，我们可以显式的设置枚举
量的值：

enum enumType {Monday=1, Tuesday=2, Wednesday=3, Thursday=4, 
Friday=5, Saturday=6, Sunday=7};

指定的值必须是整数！

(2)也可以只显式的定义一部分枚举量的值：

enum enumType {Monday=1, Tuesday, Wednesday=1, Thursday, Friday, 
Saturday, Sunday};这样Monday、Wednesday均被定义为1，则
Tuesday=2，Thursday、Friday、Saturday、Sunday的值默认分别为2、
3、4、5.总结：未被初始化的枚举值的值默认将比其前面的枚举值大1。


(3)第二条还说明另外一个现象，就是枚举量的值可以相同。

步骤(三)——枚举的取值范围
前面讲到可以通过强制转换将其他类型值赋给枚举变量：Weekday = 
enumType(2);这是合法的；但是Weekday = enumType(20);是非法的。这
里涉及枚举取值范围的概念：枚举的上限是 大于最大枚举量的 最小的2
的幂，减去1；

枚举的下限有两种情况：一、枚举量的最小值不小于0，则枚举下限取0；
二、枚举量的最小值小于0，则枚举下限是 小于最小枚举量的 最大的2的
幂，加上1。

举例来讲：

假如定义 enum enumType1 { First=-5，Second=14，Third=10 };则枚举
的上限是16-1=15（16大于最大枚举量14，且为2的幂）；  枚举的下限
是-8+1=-7（-8小于最小枚举量-5，且为2的幂）；


步骤(四)——枚举应用
个人觉得枚举和switch是最好的搭档：enum enumType{Step0, Step1, 
Step2}Step=Step0;//注意这里在声明枚举的时候直接定义了枚举变量
Step,并初始化为Step0

switch (Step)

{

  case Step0:{...;break;}

  case Step1:{...;break;}

  case Step2:{...;break;}

  default:break;

}

另外枚举还有一种少见的用法是 enum { one ,two ,three};  就是不指
定一个名字,这样我们自然也没法去定义一些枚举类型了。此时就相当于
static const int one = 0;这样定义三个常量一样。然后用的话就是int 
no = one。

————————————————————————————————————————————————————————

一、简述
  强类型枚举（Strongly-typed enums），号称枚举类型，是C++11中的
  新语法，用以解决传统C++枚举类型存在的缺陷。传统C++中枚举常量被
  暴漏在外层作用域中，这样若是同一作用域下有两个不同的枚举类型，
  但含有相同的枚举常量也是不可的，比如：
  

enum Side{Right,Left};
enum Thing{Wrong,Right};
这是不能一起用的。 
  另外一个缺陷是传统枚举值总是被隐式转换为整形，用户无法自定义类
  型。C++11中的强类型枚举解决了这些问题。
————————————————————————— 

二、强类型枚举
  强类型枚举使用enum class语法来声明，如下：
  

enum class Enumeration{
 VAL1,
 VAL2,
 VAL3=100,
 VAL4
};
这样，枚举类型时安全的，枚举值也不会被隐式转换为整数，无法和整数
数值比较，比如（Enumeration：：VAL4==10会触发编译错误）。

 另外枚举类型所使用的类型默认为int类型，也可指定其他类型，比如：
 

enum calss Enum:unsigned int{VAL1,VAL2};
正如前面所说，强类型枚举能解决传统枚举不同枚举类下同枚举值名的问
题，使用枚举类型的枚举名时，必须指明所属范围，比如：Enum::VAL1，
而单独的VAL1则不再具有意义。
还有一点值得说明的是C++11中枚举类型的前置声明也是可行的，比如：


enum calss Enum;
enum class Enum1:unsigned int;
————————————————————————— 
三、项目中的强类型枚举代码片段
1、图像处理
enum class Color{RED,BLUE,YELLOR,BLACK,WHITE};
2.交通灯
enum class TrafficLight{RED,YELLOR,GREEN};
强类型枚举值具有传统枚举的功能——命名枚举值，同时又具有类的特点——
具有类域的成员和无法进行默认的类型转换。所以也称之为枚举类——enmu 
class
枚举类的底层数据必须是有符号或无符号整型，比如char unsigned int 
unsigned long，默认为int。

3.前置声明应用
enmu class Clolor:char;  //前置声明枚举类
void Foo(Color*p);        //前置声明的使用
//....................
enum class Color:char{RED,GREEN,BLACK,WHITE};                       //前置声明的定义

explicit

explicit（显式的）的作用是"禁止单参数构造函数"被用于自动型别转换，其中比较典型的例子就是容器类型。在这种类型的构造函数中你可以将初始长度作为参数传递给构造函数。

explicit用来防止由构造函数定义的隐式转换。

 

要明白它的作用，首先要了解隐式转换：可以用单个实参来调用的构造函
数定义了从形参类型到该类类型的一个隐式转换。
class things
{
    public:
        things(const std::string&name =""):
              m_name(name),height(0),weight(10){}
        int CompareTo(const things & other);
        std::string m_name;
        int height;
        int weight;
};
这里things的构造函数可以只用一个实参完成初始化。所以可以进行一个
隐式转换，像下面这样：
things a;
................//在这里被初始化并使用。
std::string nm ="book_1";
//由于可以隐式转换，所以可以下面这样使用
int result = a.CompareTo(nm);
这段程序使用一个string类型对象作为实参传给things的CompareTo函
数。这个函数本来是需要一个tings对象作为实参。现在编译器使用
string nm来构造并初始化一个

 things对象，新生成的临时的things对象被传递给CompareTo函数，并在
 离开这段函数后被析构。
 
　　这种行为的正确与否取决于业务需要。假如你只是想测试一下a的重量
　　与10的大小之比，这么做也许是方便的。但是假如在CompareTo函数中
　　还涉及到了要除以初始化为0的height属性，那么这么做可能就是错误
　　的。你可能需要在构造tings之后更改height属性不为0。所以要限制
　　这种隐式类型转换。

　　那么这时候就可以通过将构造函数声明为explicit，来防止隐式类型
　　转换。

　　explicit关键字只能用于类内部的构造函数声明上，而不能用在类外
　　部的函数定义上。现在things类像这样：
class things
{
    public:
        explicit things(const std::string&name =""):
              m_name(name),height(0),weight(0){}
        int CompareTo(const things & other);
        std::string m_name;
        int height;
        int weight;
};
这时再进行编译，在vs2008上会提示：没有可用于执行该转换的用户定义
的转换运算符，或者无法调用该运算符。

　　这时你仍然可以通过显式使用构造函数完成上面的类型转换：
things a;
................//在这里被初始化并使用。
std::string nm ="book_1";
//显示使用构造函数
int result = a.CompareTo(things(nm));
google的c++规范中提到explicit的优点是可以避免不合时宜的类型变
换，缺点无。所以google约定所有单参数的构造函数都必须是显式构造
的，只有极少数情况下拷贝构造函数可以不声明成explicit。例如作为其
他类的透明包装器的类。

 

　　effective c++中说：被声明为explicit的构造函数通常比其non-
　　explicit兄弟更受欢迎。因为它们禁止编译器执行非预期（往往也不
　　被期望）的类型转换。除非我有一个好理由允许构造函数被用于隐式
　　类型转换，否则我会把它声明为explicit。我鼓励你遵循相同的政
　　策。
　　转载自https://www.cnblogs.com/winnersun/archive/2011/07/16/2108440.html

export

为了访问其他编译单元（如另一代码文件）中的变量或对象，对普通类型（包括基本数据类、结构和类），可以利用关键字 extern，来使用这些变量或对象时；但是对模板类型，则必须在定义这些模板类对象和模板函数时，使用标准 C++ 新增加的关键字 export（导出）。

extern

extern（外部的）声明变量或函数为外部链接，即该变量或函数名在其它文件中可见。被其修饰的变量（外部变量）是静态分配空间的，即程序开始时分配，结束时释放。用其声明的变量或函数应该在别的文件或同一文件的其它地方定义（实现）。在文件内声明一个变量或函数默认为可被外部使用。在 C++ 中，还可用来指定使用另一语言进行链接，这时需要与特定的转换符一起使用。目前仅支持 C 转换标记，来支持 C 编译器链接。使用这种情况有两种形式：

extern “C” 声明语句

extern “C” { 声明语句块 }
22. false

false（假的），C++ 的基本数据结构 bool 类型的值之一。等同于 int 的 0 值。

float

float（浮点数），C++ 中的基本数据结构，精度小于 double。

for 是 C++ 中的循环结构之一。

friend

friend（友元）声明友元关系。友元可以访问与其有 friend 关系的类中的 private/protected 成员，通过友元直接访问类中的 private/protected 成员的主要目的是提高效率。友元包括友元函数和友元类。

goto

goto（转到），用于无条件跳转到某一标号处开始执行。

if（如果），C++ 中的条件语句之一，可以根据后面的 bool 类型的值选择进入一个分支执行。

inline

inline（内联）函数的定义将在编译时在调用处展开。inline 函数一般由短小的语句组成，可以提高程序效率。

int（整型，integer），C++ 中的基本数据结构，用于表示整数，精度小于 long。

long

long（长整型，long integer），C++ 中的基本数据结构，用于表示长整数。

mutable

mutable（易变的）是 C++ 中一个不常用的关键字。只能用于类的非静态和非常量数据成员。由于一个对象的状态由该对象的非静态数据成员决定，所以随着数据成员的改变，对像的状态也会随之发生变化。如果一个类的成员函数被声明为 const 类型，表示该函数不会改变对象的状态，也就是该函数不会修改类的非静态数据成员。但是有些时候需要在该类函数中对类的数据成员进行赋值，这个时候就需要用到 mutable 关键字。

namespace

namespace（命名空间）用于在逻辑上组织类，是一种比类大的结构。

new（新建）用于新建一个对象。new 运算符总是返回一个指针。由 new 创建

operator

operator（操作符）用于操作符重载。这是 C++ 中的一种特殊的函数。

private

private（私有的），C++ 中的访问控制符。被标明为 private 的字段只能在本类以及友元中访问。

protected

protected（受保护的），C++ 中的访问控制符。被标明为 protected 的字段只能在本类以及其继承类和友元中访问。

public

public（公有的），C++ 中的访问控制符。被标明为 public 的字段可以在任何类

38.register

register（寄存器）声明的变量称着寄存器变量，在可能的情况下会直接存放在机器的寄存器中；但对 32 位编译器不起作用，当 global optimizations（全局优化）开的时候，它会做出选择是否放在自己的寄存器中；不过其它与 register 关键字有关的其它符号都对32位编译器有效。

reinterpret_cast

用法：

reinpreter_cast (expression)
type-id 必须是一个指针、引用、算术类型、函数指针或者成员指针。它可以把一个指针转换成一个整数，也可以把一个整数转换成一个指针（先把一个指针转换成一个整数，在把该整数转换成原类型的指针，还可以得到原先的指针值）。

return

return（返回）用于在函数中返回值。程序在执行到 return 语句后立即返回，return 后面的语句无法执行到。

short

short（短整型，short integer），C++ 中的基本数据结构，用于表示整数，精度小于 int。

signed

signed（有符号），表明该类型是有符号数，和 unsigned 相反。数字类型（整型和浮点型）都可以用 signed 修饰。但默认就是 signed，所以一般不会显式使用。

sizeof

由于 C++ 每种类型的大小都是由编译器自行决定的，为了增加可移植性，可以用 sizeof 运算符获得该数据类型占用的字节数。

static

static（静态的）静态变量作用范围在一个文件内，程序开始时分配空间，结束时释放空间，默认初始化为 0，使用时可改变其值。静态变量或静态函数，只有本文件内的代码才可访问它，它的名字（变量名或函数名）在其它文件中不可见。因此也称为"文件作用域"。在 C++ 类的成员变量被声明为 static（称为静态成员变量），意味着它被该类的所有实例所共享，也就是说当某个类的实例修改了该静态成员变量，其修改值为该类的其它所有实例所见；而类的静态成员函数也只能访问静态成员（变量或函数）。类的静态成员变量必须在声明它的文件范围内进行初始化才能使用，private 类型的也不例外。

static_cast

用法：

static_cast < type-id > ( expression )
该运算符把 expression 转换为 type-id 类型，但没有运行时类型检查来保证转换的安全性。它主要有如下几种用法：

① 用于类层次结构中基类和子类之间指针或引用的转换。进行上行转换（把子类的指针或引用转换成基类表示）是安全的；进行下行转换（把基类指针或引用转换成子类表示）时，由于没有动态类型检查，所以是不安全的。
② 用于基本数据类型之间的转换，如把 int 转换成 char，把 int 转换成 enum。这种转换的安全性也要开发人员来保证。
③ 把空指针转换成目标类型的空指针。
④ 把任何类型的表达式转换成void类?
注意 static_cast 不能转换掉 expression 的 const、volitale、或者 __unaligned 属性。