常量指针、指针常量、C++类型转换

一、const应用

1.const关键字，他后面内容的不可修改，一般来说，其修饰的变量不可再进行赋值操作；

2.常量指针

int a = 3；

int b = 4；

const int* pt = &a；

a = 5；

*pt的值为5，pt只是一个指针，所以他指向的是a的内容，const限制的是*pt，所以，只是不能通过*pt修改其指向的内存内容.

3.指针常量：int* const a = pt;由于不可再进行赋值操作，所以指针常量在声明时必须赋值；

相关文章：

一、常指针与指针常量的区别？

1 常量指针！如 int b, c; int * const a = &b;

表示a是一个常量指针它指向变量b的内存。但是 因为是常量指针所以不能再用a指向其他变量，如 a = &c; 错误！可以修改指向内存的值，如:*a = 20; BTW 常量指针声明的时候必须向我那样赋初值。

2 指向常量的指针！如 int b, c; int const *a; a = &b; a = &c;

都可以，唯独它指向的内存不能被修改。如：*a=20;这是违法的！错误！

这就是主 要区别！

BTW 还有一个记住他们不同形式的技巧！看const关键字，他后面的不可修改，如int * const a = &b; 后面是a,则说明a不能修改！

int const * a = &b;后面是*a则说明*a不可被修改！

在 好多书上或MSDN是经常用 const int a=5;

int b=6;

const int *p=&b;

其实 const int* 和int const* 一样，就是常指针 也就是它所指向的数据（在这是int）是常量，它自己的数据类型是const int*

还有const int *p=&b;是可以的 虽然b不是常量。

但是 const int a=6;

int *p=&a;

会报错，因为它消除了a的const属性

**********************************************

******* 我们可以总结一下********

1. 对于常量（符号常量）和常指针、常引用常对象声明都是一样的

定义格式： const 数据类型 常量名=常量值；

或 数据类型 const 常量名=常量值；

例如：const int a=7; 或 int const a=7;（符号常量）

int b=5;

const int *p=&b; 或 int const *p=&b;(常指针）

const int &m=b;（常引用）

const Point pt; 或 Point const pt; //常对象不能更新

常指针和常引用在功能上有所限制，就是不能通过他们更改其指向的变量的数据（值）

2. 指针常量

定义格式： 数据类型 *const 指针常量=常量值；

如char ch,*const pch=&ch;(我是一步完成的，你也可以分开）

也就是说这个指针本身是个常量，不可改变，即它所指向的地址是固定的。但，ch是可以 改变的。

二、c++中有常指针和指针常量的概念，c中有吗？

char *p="abc"

"abc"叫字符字面常 量，指针是可以变的，但是指针指向的这段字符串不可修改

char a[]="def"

这个a是数组，a本身不可变，但a的内 容"def"可以变

const char *p

p指向的字符串是常量，不可变；但p指针本身可以变化，也就是说可以指向另外一个 地址

char* const p

p是指针常量，只能指向最初的那个地址，需要在定义时赋值，因为一旦定义，指针p就不能改变；但 p指向的内容是可以变化的。

二、类型转换

reinterpret_cast,const_cast,static_cast,dynamic_cast 总结

#include

int main(void)

{

//reinterpret_cast

//将一个类型指针转换为另一个类型指针，这种在转换不修改指针变量值 数据存放格式

//只需在编译时重新解释指针的类型，他可以将指针转化为一个整型数但不能用于非指针的转换

double d=9.3;

double* pd = &d;

int* pi = reinterpret_cast (pd);

class A{};

class B{};

A* pa = new A;

B* pb=reinterpret_cast(pa); //将pa 转为B

long j=reinterpret_cast (pa);//指针转换为整数

// int i=9;

// double x=reinterpret_cast(i); //reinterpret_cast不能用于非指针的转换

//const_cast

该运算符用来修改类型的const或 volatile属性。除了const 或volatile修饰之外， type_id和expression的类型是一样的。

一、常量指针被转化成非常量指针，并且仍然指向原来 的对象；

二、常量引用被转换成非常量引用，并且仍然指向原来 的对象；

三、常量对象被转换成非常量对象。

//1. 用于去除指针变量的常属性，将它转换为一个对应指针类型的普通变量，

//2.反过来也可以将一个非常量指针转换为一个常量指针变量

//3. 他无法将一个非指针的常量转换为普通变量

//example: const i=10;

// int j=const_cast(i); //无法转换

const int ppp=998;

const int* pca=&ppp;

int* p=const_cast(pca);//将它转换为一个对应指针类型的普通变量，去除了const;

const A* paa=new A;

A * ppppa=const_cast (paa);//它转换为一个对应指针类型的普通变量，去除了const;

int * pii=0;//反过来也可以将一个非常量指针转换为一个常量指针变量

const int* piiic=const_cast(pii);

//////////////////////////////////////////////////////////////////////////////////

//static_cast

//用于转换基本类型和具有 继承关系的类新之间转换

//static_cast不太用于指针类型的之间的转换，他的效率没有reinterpret_cast的效率高

int in=99;

double dn=static_cast (in);// 用于转换基本类型和具有继承关系的类新之间转换

class Base{};

class derv:public Base{};

derv dd;

Base bbbb=static_cast(dd);// 具有继承关系的类新之间转换

//static_cast 不太用于指针类型的之间的转换，他的效率没有reinterpret_cast的效率高

Base *pb1=new Base;

derv *pder=static_cast(pb1);//基类转继承类

derv* pder1=new derv;

Base* pbase1=static_cast(pder1);// 继承类指针转父类指针

//////////////////////////////////////////////////////////////////////////

//dynamic_cast

//1.只能在继承类对象的指 针之间或引用之间进行类型转换

//2.这种转换并非在编译时，而是在运行时，动态的

//3.没有继承关系，但被转换的类具有虚函数对象的 指针进行转换

derv* dp=new derv;

Base* bv=dynamic_cast(dp);//继承类对象的指针之间进行类型转换

derv dpp;//继承类对象引用之间进行类型转换

Base &b=dynamic_cast(dpp);

class AA{virtual fun(){}

virtual ~AA(){}};

class BB{};

//没有继承关系，但被转换的类具有虚函数对象的指针进行转换，编译可通过

AA* pAA=new AA;

BB* pBB=dynamic_cast(pAA);

//没有继承关系，被转换的类也没有有虚函数对象的指针进行转换，编译不能通过

BB* pBBB=new BB;

AA* pAAA=dynamic_cast(pBBB);

return 1;

}





//总结：

//reinterpret_cast 将一个类型指针转换为另一个类型指针

//const_cast 用于去除指针变量的常属性，将它转换为一个对应指针类型的普通变量，反过来也可以将一个非常量指针转换为一个常量指针变量

//static_cast 用于转换基本类型和具有继承关系的类新之间转换,不太用于指针类型的之间的转换

//dynamic_cast 只能在继承类对象的指针之间或引用之间进行类型转换

//以上只有dynamic_cast这种转换并非在编译时，而是在运行时，动态的。其它均在 编译时

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

标准C++的类型转换符：static_cast、dynamic_cast、 reinterpret_cast、和const_cast。

static_cast

用法：static_cast < type-id > ( exdivssion )

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

①用于类层次结构中基类和子类之间指针或引用的转换。

　　进行上行转换（把子类的指针或引用转换成基类表示）是安全的；

　 　进行下行转换（把基类指针或引用转换成子类表示）时，由于没有动态类型检查，所以是不安全的。

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

③把空指针转换成目标类型的空指针。

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

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

dynamic_cast

用法：dynamic_cast < type-id > ( exdivssion )

该运算符把exdivssion转换成type-id类型的对象。Type-id必须是 类的指针、类的引用或者void *；

如果type-id是类指针类型，那么exdivssion也必须是一个指针，如果type-id是一个引 用，那么exdivssion也必须是一个引用。

dynamic_cast主要用于类层次间的上行转换和下行转换，还可以用于类之间的交叉转换。

在 类层次间进行上行转换时，

dynamic_cast和static_cast的效果是一样的；

在进行下行转换 时，dynamic_cast具有类型检查的功能，比static_cast更安全。

class B{

public:

int m_iNum;

virtual void foo();

};

class D:public B{

public:

char *m_szName[100];

};

void func(B *pb){

D *pd1 = static_cast(pb);

D *pd2 = dynamic_cast((pb);

}

在上面的代码段中，如果pb指向一个D类型的对象，pd1和pd2是一样的，并且对这两个指针执行D 类型的任何操作都是安全的；

但是，如果pb指向的是一个B类型的对象，那么pd1将是一个指向该对象的指针，对它进行D类型的操作将是不安全的 （如访问m_szName），

而pd2将是一个空指针。

另外要注意：B要有虚函数，否则会编译出错；static_cast则没有这个限制。

这是由 于运行时类型检查需要运行时类型信息，而这个信息存储在类的虚函数表（

关于虚函数表的概念，详细可见）中，只有定义了虚函数的类才有虚函数表，

没 有定义虚函数的类是没有虚函数表的。

另外，dynamic_cast还支持交叉转换（cross cast）。如下代码所示。

class A{

public:

int m_iNum;

virtual void f(){}

};

class B:public A{

};

class D:public A{

};

void foo(){

B *pb = new B;

pb->m_iNum = 100;

D *pd1 = static_cast((pb); //compile error

D *pd2 = dynamic_cast((pb); //pd2 is NULL

delete pb;

}

在函数foo中，使用static_cast进行转换是不被允许的，

将在编译时出错；而使用 dynamic_cast的转换则是允许的，结果是空指针。

reinterpret_cast

用法：reinterpret_cast< type-id >(exdivssion)

type-id必须是一个指针、引用、算术类型、函数指针或者成员指针。

它可以把一个 指针转换成一个整数，也可以把一个整数转换成一个指针（先把一个指针转换成一个整数，

在把该整数转换成原类型的指针，还可以得到原先的指针值）。

该运算符的用法比较多。

const_cast

用法：const_cast< type-id > (exdivssion)

该运算符用来修改类型的const或volatile属性。除了const 或volatile修饰之外， type_id和exdivssion的类型是一样的。

常量指针被转化成非常量指针，并且仍然指向原来的对象；

常量引用被转换成非常量引 用，并且仍然指向原来的对象；常量对象被转换成非常量对象。

Voiatile和const类试。举如下一例：

class B{

public:

int m_iNum;

}

void foo(){

const B b1;

b1.m_iNum = 100; //comile error

B b2 = const_cast((b1);

b2. m_iNum = 200; //fine

}

上 面的代码编译时会报错，因为b1是一个常量对象，不能对它进行改变；

使用const_cast把它转换成一个常量对象，就可以对它的数据成员任意 改变。注意：b1和b2是两个不同的对象。

转自:http://blog.chinaunix.net/uid-22889411-id-59671.html