Chinaunix首页 | 论坛 | 博客
  • 博客访问: 345063
  • 博文数量: 201
  • 博客积分: 305
  • 博客等级: 二等列兵
  • 技术积分: 500
  • 用 户 组: 普通用户
  • 注册时间: 2012-11-30 16:58
文章分类

全部博文(201)

文章存档

2015年(5)

2014年(12)

2013年(173)

2012年(11)

我的朋友

分类:

2012-11-30 17:11:53

一、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是两个不同的对象。

阅读(647) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~