static_cast、dynamic_cast、reinterpret_cast和const_cast之间的区别，char int *p,int const*p



深入理解const char*p,char const*p,char *const p,const char **p,char const**p,char *const*p,char**const p

一、可能的组合：

(1)const char*p

(2)char const*p

(3)char *const p

(4)const char **p

(5)char const**p

(6)char *const *p

(7)char **const p

当然还有在(5)、(6)、(7)中再插入一个const的若干情况，不过分析了以上7中，其他的就可类推了！

二、理解助记法宝：

1、关键看const 修饰谁。

2、由于没有 const *的运算，若出现 const * 的形式，则const实际上是修饰前面的。

    char const*p   ===  const char*p

    const char **p ==  char const**p

三、深入理解7种组合

而所有对指针的各种const限定说白了     只是对该指针 的 读写权限 （包括读写位置）进行了限定 。

(1)  char *p：p是一个指针，用来对任意位置（非系统敏感区域）进行读写操作 ，一次读写一个字节（char占一个字节）。

(2)  const char*p或者char const *p  ：可以对任意位置（非系统敏感区域）进行“只读” 操作。（“只读”是相对于char *p来说所限定的内容）

(3)char *const p（const 修饰的是p）：只能对“某个固定的位置” 进 行读写操作，并且在定义p时就必须初始化（因为在后面不能执行“p=..”的操作，因此就不能在后面初始化，因此只能在定义时初始化）。（“某个固定的位 置”是相对于char *p来说所限定的内容）
可以总结以上3点为：char *p中的指针p通常是”万能”的工作指针 ，而（2）和（3）只是在（1）的基础上加了些特定的限制 ，这些限制在程序中并不是必须的，只是为了防止程序员的粗心大意而产生事与愿违的错 误。

(4)上面的(2)和(3)只是对p进行限定，没有也不能对p所指向的空间进行限定，

对于"char s[]="hello";const char*p=s;" 虽然不能通过*(p+i)='x'或者p[i]='x'来修改数组元素s[0]～s[4]的值，

但可以通过*(s+i)='x'或者s[i]='x'来修改原数组元素的值

如const char c＝‘A’, c是RAM里一个内存单元（8字节）的名字，该内存单元的内容只可读，不可写。

(5)const char **p或者char const**p ：涉及两个指针p和 *p。由于const修饰char ，对指针p没有任何限定，对指针*p进行了上面情况(2)的限定。

(6)char *const *p：涉及两个指针p和 *p。由于const修饰前面的char*,也就是对p所指向的内容*p进行了限定(也属于前面的情况(2))。而对*p来说，由于不能通过"*p＝..."来进行另外赋值，因此属于前面的情况(3)的限定。

(7)char **const p ： 涉及两个指针p和 *p，const修饰p，对p进行上面情况(3)的限定，而对*p,没有任何限定。

四、关于char **p 、const char **p的类型相容性问题

1。问题

char *p1;const *p2=p1;//合法

char **p1;const char**p2=p1;//不合法，会有警告warning: initialization from incompatible pointer type

char **p1;char const**p2=p1;//不合法，会有警告warning: initialization from incompatible pointer type

char**p1;char*const*p2=p1;//合法

2。判断规则

明确const修饰的对象！对于指针p1，和p2，若要使得p2=p1成立，则可读做 ：

“p1是指向X类型的指针，p2是指向“带有const限定”的X类型的指针 “。只要二者的X类型一样，就是合法的。

1) char *p1; char const *p2=p1;//合法:p1是指向（char）类型的指针，p2是指向“带有const限定"的(char)类型的指针。

	const char *p1;
	char *p="liu";
	p1=p;
	printf("p is %s\n",p1);//p is liu

char **p1;const char**p2=p1;//不合法:p1是指向（char*）类型的指针,p2是指向 ((const char)*)类型的指针。

char **p1;char const**p2=p1;//不合法;与上等价。

char**p1;char*const*p2=p1;//合法: p1是指向（char *）类型的指针，p2是指向“带有const限定"的(char*)类型的指针。

2)

const int a = 0;

a = 10;    //“a”: 不能给常量赋值

五、其他

1。 含有const的单层或双层指针的统一读法：

“p是一个指针，是一个［“带有const限定”的］指向［”带有const限定”的］X类型的指针”。

l例如：const char* const *p就是说：p是一个带有const限定的指向带有const限定的（char*）类型的指针。

2。定义时const修饰的对象是确定的，但不能在定义时加括号，不然就和定义时用“（）”表示的函数类型相混淆了！因此定义时不能写(char *)const *p或者(const char) **p。

六、问题探讨 

例一：

	const char aa[]="liu";
	char *p;
	p=aa;

 所以char *p中的P不能指向常变量。  p=aa 无法从“const char [5]”转换为“char *”

例二、

#include "stdafx.h"
#include <stdio.h>

int _tmain(int argc, _TCHAR* argv[])
{
	const char *s1="test";// 在只读数据区开辟5字节存储"test",并用s1指向首字符‘t’
	//char *s2 =s1;//无法从“const char *”转换为“char *”
	char *s2 =(char *)s1; //合法  s2也指向只读数据区中“test”的首字符't'。
	s2="doudou";  在只读数据区开辟7字节存储"doudou"，并将s2由指向't'转而指向"It's modified!"的首字符'I'。 
	printf("p is %s\n",s2);// p is doudou  
	printf("p is %s\n",s1);// p is test

	return 0;
}

注意：

误以为s2 = "doudou"是对“test”所在区域的重新赋值，其实这里只是将“万能”工作指针s2指向另外一个新开辟的区域而已。

比如若在char *s2 = s1后再执行s2[2]='a'则是对“test”的区域进行了写操作，执行时会出现段错误。

一 C语言中存在着两种类型转换：

隐式转换和显式转换

隐式转换：不同数据类型之间赋值和运算，函数调用传递参数……编译器完成

char ch;
int i = ch;

显示转换：在类型前增加 ：（Type）变量 对变量进行的转换。用户显式增加

char *pc =(char*)pb;
void *ps = (void*)pa;

int i;

double d;

i=(int)d;;

上面的代码就是本来为double类型的d，通过(int)d将其转换成整形值，并将该值赋给整形变量i (注意d本身的值并没有发生改变)。这就是典型的c-style类型转换。

下面是一个简单的程序：

#include <iostream>
using namespace std;
int main(void)
{
int i;
double d = 11.29;
i = (int)d;
cout << i << endl;
cout << d << endl;


return 0;
}

输出结果：

11

11.29

二 C++中的类型转换

C++继承了C中的隐式和显式转换的方式。C++增加了四个显示转换的关键字

（static_cast，dynamic_cast，const_static，reinterpret_cast）

1 static_cast

（1）用于基本的数据类型转换（char，int），及指针之间的转换

	test_enum type = test_enum_1;
	char a ;
	int b = static_cast<int>(a);
	char c = static_cast<char>(b);
	type = static_cast<test_enum>(b);

	char* pa = NULL;
	int *pb = (int*)pa;
	//int *pb = static_cast<int*>(pa);        //error
	//pa = static_cast<char*>(pb)           //error
	char *pc = (char*)pb;
	//char *pc = static_cast<char*>(pb);    //error

	void *p = static_cast<void*>(pa);
	pb = static_cast<int*>(p);
	pc = static_cast<char*>(p);<span style="font-family: Arial; font-size: 9pt; line-height: 21px; background-color: rgb(255, 255, 255);"> </span>

在简单的情况下，上面这种类型转换可以很好地工作，但在C++中往往还是不够的，为此ANSI-C++新标准定义的四个转换符，即static_cast、dynamic_cast、reinterpret_cast和const_cast。同时在C++环境中，原先的C-Style的类型转换仍旧可以使用。

 

1)  static_cast

    用法：static_cast <typeid> (expression)

    说明：该运算符把expression转换为typeid类型，但没有运行时类型检查来确保转换的安全性。

    用途：

    a) 用于类层次结构中基类和派生类之间指针或者引用的转换。up-casting (把派生类的指针或引用转换成基类的指针或者引用表示)是

    安全的；down-casting(把基类指针或引用转换成子类的指针或者引用)是不安全的。

    b) 用于基本数据类型之间的转换，如把int转换成char，这种转换的安全性也要由开发人员来保证。

    c) 可以把空指针转换成目标类型的空指针(null pointer)。

    d) 把任何类型的表达式转换成void类型。

    注意： static_cast不能转换掉expression的const、volitale或者__unaligned属性。

 

2)  dynamic_cast

    用法：dynamic_cast <typeid> (expression)

    说明：该运算符把expression转换成typeid类型的对象。typeid必须是类的指针、类的引用或者void*。如果typeid是类的指针类型，

        那么expression也必须是指针，如果typeid是一个引用，那么expression也必须是一个引用。一般情况下，dynamic_cast用

        于具有多态性的类(即有虚函数的类)的类型转换。

 

               dynamic_cast依赖于RTTI信息，其次，在转换时，dynamic_cast会检查转换的source对象是否真的可以转换成target类型，

       这种检查不是语法上的，而是真实情况的检查。先看RTTI相关部分，通常，许多编译器都是通过vtable找到对象的RTTI信息

       的，这也就意味着，如果基类没有虚方法，也就无法判断一个基类指针变量所指对象的真实类型，这时候，dynamic_cast只能

       用来做安全的转换,例如从派生类指针转换成基类指针。而这种转换其实并不需要dynamic_cast参与。也就是说,dynamic_cast

       是根据RTTI记载的信息来判断类型转换是否合法的。

 

    用途：主要用于类层次之间的up-casting和down-casting，还可以用于类之间的交叉转换。在进行down-casting时，dynamic_cast

        具有类型检查的功能，比static_cast更安全。检测在运行时进行。如果被转换的指针不是一个被请求的有效完整的对象指针，

        返回值为NULL。当用于多态类型时，它允许任意的隐式类型转换以及相反过程。不过，与static_cast不同，在后一种情况里

        （注：即隐式转 换的相反过程），dynamic_cast会检查操作是否有效。也就是说，它会检查转换是否会返回一个被请求的有

        效的完整对象。

    注意：dynamic_cast不能转换掉expression的const、volitale或者__unaligned属性。

 

3)   reinterpret_cast

     用法：reinterpret_cast <typeid>(expression)

     说明：转换一个指针为其他类型的指针，也允许将一个指针转换为整数类型，反之亦然。这个操作符能够在非相关的类型之间进行

        转换。操作结果只是简单的从一个指针到别的指针的值的二进制拷贝，在类型之间指向的内容不做任何类型的检查和转换。这

        是一个强制转换。使用时有很大的风险，慎用之。

     注意：reinterpret _cast不能转换掉expression的const、volitale或者__unaligned属性。

 

4)   const_cast

     用法：const_cast<typeid>(expression)

     说明：这个类型操纵传递对象的const属性，或者是设置或者是移除。如：

           Class C{…}

           const C* a = new C;

           C* b = const_cast<C*>(a);

           如果将上面的const_cast转换成其他任何其他的转换，编译都不能通过，出错的信心大致如下：

           “…cannot convert from 'const class C *' to 'class C *'”。

  

     下面的代码是4中casting方法的典型用法示例：

     #include <iostream>

     using namespace std;

 

     class Base

     {

     public:

         int _base;

         virtual void printinfo()

         {

              cout << _base << endl;

         }

     };

 

     class Derived : public Base

     {

     public:

         int _derived;

         virtual void printinfo()

         {

              cout << _derived << endl;

         }

     };

 

     int main(void)

     {

         Base b1;

         Derived d1;

         int aInt = 10;

         long aLong = 11;

         float aFloat = 11.11f;

         double aDouble = 12.12;

 

         Derived* pd = static_cast<Derived*>(&b1);                           // down-casting          不安全

         Base* pb = static_cast<Base*>(&d1);                                   // up-casting                安全

         Derived& d = static_cast<Derived&>(b1);                             // down-casting          不安全

         Base& b = static_cast<Base&>(d1);                                      // up-casting                安全

 

         aInt = static_cast<int>(aFloat);                                                // 基本数据类型转换

         void* sth = static_cast<void*>(&aDouble);                            // 将double指针类型转换成void指针类型

         double* bDouble = static_cast<double*>(sth);                    // 将void指针类型转换成double指针类型

         cout << *bDouble << endl;

 

         Base* pb1 = dynamic_cast<Base*>(&d1);

         //Derived* pd1 = dynamic_cast<Derived*>(&b1);                 // 编译时有warning，运行时出错

 

         int bInt = reinterpret_cast<int>(pb1);                                       // 将地址或指针转换成整数

         cout << bInt << endl;

         pb1 = reinterpret_cast<Base*>(bInt);                                     // 将整数转换成地址或指针

 

         int* cInt = reinterpret_cast<int*>(&aFloat);                             // 这个转换的结果会出乎意料

         cout << (int)*cInt << endl;

 

         const Base* bBase = new Base();

         Base* cBase = const_cast<Base*>(bBase);

         //Base* dBase = dynamic_cast<Base*>(bBase);                // 不能通过编译

         //Base* eBase = static_cast<Base*>(bBase);                     // 不能通过编译

         //Base* fBase = reinterpret_cast<Base*>(bBase);             // 不能通过编译

 

         return 0;

}