const用法
1,定义全局变量的内存分配问题
#define Pi_1 3.14 //使用#define宏
const double Pi_2 = 3.14 //使用const,这时候Pi并没有放入内存中
double a = Pi_2; //这时候才为Pi分配内存,不过后面再有这样的定义也不会再分配内存
double b = Pi_1; //编译时分配内存
double c = Pi_2; //不会再分配内存,
double d = Pi_1; //编译时再分配内存
const定义的变量,系统只为它分配一次内存,而使用#define定义的常量宏,能分配好多次,这样const就很节约空间
2,const修饰变量
1、限定符声明变量只能被读
const int i=5;
int j=0;
……
i=j; //非法,导致编译错误
j=i; //合法
2、 必须初始化
const int i=5; //合法
const int j; //非法,导致编译错误
3、在另一连接文件中引用const常量
extern const int i; //合法
extern const int j=10; //非法,常量不可以被再次赋值
3,指向常量的指针变量
int a = 10;
int b = 20;
const int* p = &a; // assignment of read-only location ‘* p’, 即*p为只读的,不能对*p进行写操作。
int const* p1 = &a; //同上
*p = 11; // error
p = &b; // ok, 此时 *p = 20;
4,常量指针
int * const p2 = &a; //assignment of read-only variable ‘p2’, 即p2始终指向&a,不可被改变,但是可对*p2 做读写操作。
p2 = &b; // error
*p2 = b; // ok , 此时 *p2 = 20,由于p2始终指向&a,所以此时 a = 20;
5,指向常量的常量指针
const int * const p3 = &a; //此时p3始终指向 &a,并且不能对*p3做“写”操作。但是可以通过 a = 12 去改变*p3的值。
6,const限定类的成员函数
这种用法只在C++中有用(C语言中没有成员函数).如:
class classname
{
public:
int func() const
{... ...;}
}
采用这种const后置的形式一种规定,为了不引起混淆,在此函数的声明中和定义中均要使用const,因为const已经成为类型信息的一部分.但要注意,这种情况下,该函数不能修改类的非静态(static)数据成员,也不能在函数中调用其它非const的函数.比如:
class base
{
int x;
static int y;
public:
void foo() { cout << “foo” << endl;}
void foo() const { cout << “foo const” << endl;}
void foo1() { cout << “foo1” << endl;}
void foo2() const { cout << “foo2 const” << endl;}
static void foo3() { cout << “foo3” << endl;}
void test() const
{
int c;
x = 5; //错误
y = 10; //正确
foo() //正确
foo1(); //错误
foo2(); //正确
foo3() //正确
c = 10; //正确
}
}
这种情况下,在函数内部无法改变成员数据x的值,因此编译器会报错:"l-value secifies const object".
尽管函数名和参数列表都相同,void foo( ) const成员函数是可以与void foo( )并存的,可以形成重载! 我们假设调用语句为obj.foo(),如果obj为non-const对象,则调用foo()。如果obj为const对象,则调用foo()const。另外要注意,假如没有提供foo()const,则const obj调用foo()将会报错。但假如是没有提供foo(),则non-const obj调用foo()const是完全没有问题的。也就是说,non-const对象可以调用const函数(当然也可以调用non-const函数),但const对象不能调用non-const函数。
const关键字所起作用的本质,就是把隐藏着的默认的this指针参数,改成const类型。也就是说:假如void foo( )函数被编译器改写为 void foo(T* pThis),则void foo( ) const将会被改写为void foo(const T* pThis) 。i.e. 在函数末尾添加一个const,就相当于在隐藏的this参数类型前加一个const.
这样做有两个效果,第一:编译器将不允许foo()const修改pThis指向的对象的成员。第二、const对象只能调用const成员函数,否则就会报错说把const T* 转化为T* 会丢失qualifier