const的用法

const的用法
1、用作变量修饰符
const可以在定义变量时作为修饰符，用来表示该变量不可修改。

需要注意的是：const修饰某个变量时，总是限定const所处位置的右侧。

例如代码 const int nc = 0; 用来声明一个整型常量 nc，这个常量不可更改。

假如执行下面的语句
int main(int argc, char* argv[])
{
const int nc = 0;
nc = 1; //修改了常量 nc，不能编译过去
return 0;
}
编译时会报错“l-value specifies const object”
需要说明的是，声明变量时，const int nc = 0 与 i nt const nc = 0 意义是一样的，个人推荐使用后面一种 i nt const nc = 0 ，这样别人在看代码的时候，可以先很快的知道 nc 是常量。

大家看完我上面所说的，可能更好的理解下面我所说的int const *p 与 int *const p 的区别。

前面我也说了，const 是修饰它位置右侧的，所以 int const *p 主要是修饰*p 为常量，也就是说*p 的值不能改变；而 int *const p 则是修饰 p 为常量，也就是说指针 p 为一个常量指针。

可以根据下面的代码来加深印象
int main(int argc, char* argv[])
{
int n = 0;
int m = 1;
int const *p1 = &n;
int * const p2 = &n;
p1 = &m;
(*p1) = m; //这里编译出错，错误为“error C2166: l-value specifies const object”
p2 = &m; //这里编译出错，错误为“error C2166: l-value specifies const object”
(*p2) = m;
return 0;
}
执现在大家该明白了 int const *p 与 int *const p 两者之间的区别了吧。

好了，我们又回到上面的代码。

去除了两行编译错误的行后，可以正确的编译并运行。

调试信息如下所示：
int main(int argc, char* argv[])
{
//说明: 下面的注释（以 //D 开头）都是对上面语句执行后的注释int n = 0;
int m = 1;
//D &m = 0x0012ff78
//D &n = 0x0012ff7c
int const *p1 = &n;
//D p1 = 0x0012ff7c, (*p1) = 0
int * const p2 = &n;
//D p2 = 0x0012ff7c, (*p2) = 0
p1 = &m;
//D p1 = 0x0012ff78[改变], (*p1) = 1[改变]
(*p2) = m;
//D p2 = 0x0012ff7c[未改变], (*p2) = 1[改变]
//D 注意，这时候， n 的值改变了， n = 1[改变]
//D p1 与 *p1 都未改变
return 0;
}
2、用来修饰函数
const 用来修饰函数，有两种情况
int const foo1()
{
return 0;
}
与
int CXXX::foo2() const
{
return 1;
}
不过，上面的那种情况，一般是使用在函数的返回值为一个指针的情况下，告诉编译器（或者说是编码人员），请不要修改我这个函数的返回值，否则有可能出错；下面的那种情况，只能是用在一个类成员函数中，不能用在普通的函数中，作用是告诉编译器，我这个函数体中，不会修改任何同类（都是类CXXXX）的任何变量。

下面我来列出代码说说情况。

我写了下面的代码：
class CXXX{
public:
//构造函数与析构函数
CXXX();
~CXXX();
//外部调用的函数
public:
int foo();
int const foo1();
int fooc() const;
int const *foop();
protected:
private:
//成员变量
public:
int m_public;
protected:
int m_protected;
private:
int m_private;
};
CXXX::CXXX()
{
m_public = 0;
m_protected = 1;
m_private = 2;
}
CXXX::~CXXX()
{
}
int CXXX::foo()
{
m_public += 100; // 编译不会产生任何的错误m_protected += 100; // 编译不会产生任何的错误m_protected += 100; // 编译不会产生任何的错误return 0;
}
int const CXXX::foo1()
{
m_public += 100; // 编译不会产生任何的错误
m_protected += 100; // 编译不会产生任何的错误
m_protected += 100; // 编译不会产生任何的错误
return 1;
}
int CXXX::fooc() const
{
m_public += 100; // error C2166: l-value specifies const object
m_protected += 100; // error C2166: l-value specifies const object
m_protected += 100; // error C2166: l-value specifies const object
return 2;
}
int const *CXXX::foop()
{
return &m_protected;
}
int main(int argc, char* argv[])
{
CXXX myclass;
int n = myclass.foo();
n = myclass.foo1(); // 正确。

请注意这一行，调用的函数int const CXXX::foo1()
n = 1000; // 正确
int const nc = myclass.foo1();
int *p = myclass.foop(); // error C2440: 'initializing' : cannot convert from 'const int *' to 'int *'
const *pc = myclass.foop(); // 正确
return 0;
}
具体的，我在上面的代码中已经注释出来了，详细的我就不再说明。