C++ const详解

关键字const

1、可以修饰内置对象              const int a = 1;

2、可以修饰类对象                  const A a;

3、可以修饰指针                      const int* p;

                                                    int * const p = &a;

4、可以修饰类成员函数          void Run（）const;           （只能修饰成员函数，不能修饰普通函数）

1、修饰内置对象。

(1)

int _tmain(int argc, _TCHAR* argv[])
{
	const int a;
}

结果：编译出错。

（2）

int _tmain(int argc, _TCHAR* argv[])
{
	const int a = 0;
}

结果：编译成功。

分析：因为const常量只能被初始化，不能被赋值。

2、修饰类对象。

（1）

class A
{

};

int _tmain(int argc, _TCHAR* argv[])
{
	const A b;
}

结果：编译成功。

（2）

class A
{

};

int _tmain(int argc, _TCHAR* argv[])
{
	A a;
	const A b = a;
}

结果：编译成功。

分析：其实不管是类对象还是内置对象，都只能是被初始化，不能被赋值。由于const A b;语句在定义b的时候会调用默认构造函数，所以就不会出现1中的情况了。

3、修饰指针。

对于 const int* 定义方式：

（1）

int _tmain(int argc, _TCHAR* argv[])
{
	const int* p;
}

结果：编译正确。

（2）

int _tmain(int argc, _TCHAR* argv[])
{
	int a, b;
	const int* p;
	p = &a;
	p = &b;
}

结果：编译正确。

（3）

int _tmain(int argc, _TCHAR* argv[])
{
	int a, b;
	const int* p;
	*p = 1;
}

结果：编译错误。

分析：const int* 这种定义方式是定义了一个指向常量整型的指针，所以指针本身是可以修改的，但是它所指的那个变量是不能修改的。

对于int* const定义方式。

（1）

int _tmain(int argc, _TCHAR* argv[])
{
	int* const p;
}

结果：编译错误。

（2）

int _tmain(int argc, _TCHAR* argv[])
{
	int a = 0;
	int* const p = &a;
}

结果：编译正确。

（3）

int _tmain(int argc, _TCHAR* argv[])
{
	int a = 0;
	int b = 0;
	int* const p = &a;
	p = &b;
}

结果：编译错误。

（4）

int _tmain(int argc, _TCHAR* argv[])
{
	int a = 0;
	int* const p = &a;
	*p = 1;
}

结果：编译正确。

分析：对于int* const这种定义方式，其实是定义了一个指向整型变量的常指针，指针本身不能改变，但是指针所指向的整型可以改变。

4、修饰类成员函数。

void print()const
{

}

int _tmain(int argc, _TCHAR* argv[])
{
	print();
}

结果：编译错误。

class A
{
public:
	A()
	{
		a = 0;
	}
	void print()const
	{
		cout << a;
	}

private:
	int a;
};

int _tmain(int argc, _TCHAR* argv[])
{
	A a;
	a.print();
}

结果：编译成功，输出0。

（2）
<pre name="code" class="cpp">class A
{
public:
	A()
	{
		a = 0;
	}
	void print()const
	{
		a = 1;
		cout << a;
	}

private:
	int a;
};

int _tmain(int argc, _TCHAR* argv[])
{
	A a;
	a.print();
}

结果：编译出错

分析：普通函数是不能被const修饰的。被const修饰的成员函数不能修改内部的数据。

另外还有如下情况

（1）

class A
{
public:
	A()
	{
		a = 0;
	}

	void print1()const
	{
		cout << a;
	}

	void print2()
	{
		a = 1;
		cout << a;
	}

private:
	int a;
};

int _tmain(int argc, _TCHAR* argv[])
{
	const A a;
	a.print1();
}

结果：编译成功，输出1；

（2）

class A
{
public:
	A()
	{
		a = 0;
	}

	void print1()const
	{
		cout << a;
	}

	void print2()
	{
		a = 1;
		cout << a;
	}

private:
	int a;
};

int _tmain(int argc, _TCHAR* argv[])
{
	const A a;
	a.print2();
}

结果：编译失败。

（3）

class A
{
public:
	A()
	{
		a = 0;
	}

	void print1()const
	{
		cout << a;
	}

	void print2()
	{
		cout << a;
	}

private:
	int a;
};

int _tmain(int argc, _TCHAR* argv[])
{
	const A a;
	a.print2();
}

结果：编译失败

分析：被const修饰的类对象，只能调用被const修饰的成员函数。