const的常见用法

原博文：http://blog.csdn.net/bizhu12/article/details/6672723

const用法主要是防止定义的对象再次被修改，定义对象变量时要初始化变量

下面介绍几种常见的用法：

1.用于定义常量变量，这样这个变量在后面就不可以再被修改

const int Val=10;

//Val=20;//错误，不可被修改

2.保护传参时参数不被修改，如果使用引用传递参数或按地址传递参数给一个函数，在这个函数里这个参数的值若被修改，则函数外部传进来的变量的值也发生改变，若想保护传进来的变量不被修改，可以使用const保护

#include "stdafx.h"
#include <iostream>
using namespace std;
void fun1(const int &val)
{
	//val=10;//出错
}
void fun2(int &val)
{
	val=10;//没有出错
}
void main()
{
	int a=2, b=2;
	fun1(a);//因为出错，这个函数结束之后a的值还是2
	fun2(b);//传引用，b的值改变为10
	cout<<"a = "<<a<<" b = "<<b<<endl;
	system("pause");
}

如果只想把值传给函数，而且这个值不能被修改，则可以使用const保护变量。有人说为什么不选择按值传递，按值传递还需要把这个值复制一遍，而引用不需要，使用引用是为了提高效率//如选择按值传递的话，没必要加const

3.节约内存空间

#define PI 3.14 //使用#define宏

const double Pi=3.14 //使用const，这个时候PI并没有放入内存中

double a=Pi;//这时候才为Pi分配内存，不过后面再有这样的定义不会再分配内存

double b=PI;//编译时分配内存

double c=Pi;//不会再分配内存

double d=PI;//编译时再分配内存

const定义的变量，系统只为它分配一次内存，而使用#define定义的常量宏，能分配好多次，这样const就很节约空间

4.类中使用const修饰函数防止修改非static类成员变量

#include "stdafx.h"
#include <iostream>
using namespace std;

class Num
{
public:
	void fun() const
	{
		//a=0;//出错，不可修改非static的值
		b=10;
	}
	void show()
	{
		cout<<a<<"   "<<b<<endl;
	}
private:
	int a;
	static int b;
};
int Num::b=0;
int main()
{
	Num num;
	num.fun();
	num.show();
	system("pause");
	return 0;
}

5.修饰指针

const int *A; 或int const *A;//const修饰指向的对象，A可变，A指向的对象不可变

int *const A;//const修饰指针A，A不可变，A指向的对象可变

const int *const A;//指针A和A指向的对象都不可变。

#include "stdafx.h"
#include <iostream>

using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
	int i=1,j=100;//在栈中申请两个内存地址i,j;
	const int *A;//const修饰指向的对象，A可变，A指向的对象不可变
	A=&i;
	cout<<"A的内存为:"<<A<<" A内存中存的值为:"<<*A<<endl;
	A=&j;
	cout<<"改变内存块"<<endl;
	cout<<"A的内存为:"<<A<<" A内存中存的值为:"<<*A<<endl;
	//*A=10;//错误，A指向的对象不可变，只能通过改变内存块来改变内存值
	//cout<<"改变指针指向的值"<<endl;
	//cout<<"A的内存为:"<<A<<" A内存中存的值为:"<<*A<<endl;
	int const *B;//同A
	B=&i;
	cout<<"B的内存为:"<<B<<" B内存中存的值为:"<<*B<<endl;
	B=&j;
	cout<<"改变内存块"<<endl;
	cout<<"B的内存为:"<<B<<" B内存中存的值为:"<<*B<<endl;
	//*B=10;//同A
	/*cout<<"B的内存为:"<<B<<" B内存中存的值为:"<<*B<<endl;*/
	int * const C= &i; //C必须设定初始值,C不可变，C指向的值可变
	cout<<"C的内存为:"<<C<<" C内存中存的值为:"<<*C<<endl;
	//C=&j;//错误，C内存块不能变，
	*C=10;//内存块不能改变，但内存块指向的值可以改变
	cout<<"改变指针指向的值"<<endl;
	cout<<"C的内存为:"<<C<<" C内存中存的值为:"<<*C<<endl;
	const int *const D=&i;
	//*D=10;//错误，同A
	//D=&j;//错误，同C
	cout<<"D的内存为:"<<D<<" D内存中存的值为:"<<*D<<endl;
	system("pause");
	return 0;
}

6.修饰函数返回值，防止返回值被改变

const int fun();

接收返回值的变量也必须加const

const int a=fun();//接收变量也要是const的，int a=fun()是错误的。

7.修饰类的成员变量

使用const 修饰的变量必须初始化，在类中又不能再定义时初始化。

如：

#include "stdafx.h"
#include <iostream>
using namespace std;

class Num
{
public:
	Num():c(50)
	{}
	void fun()
	{
		a=0;
		//c=100;//出错，const声明的c不能改变
		//b=10;//静态变量为不可修改值
	}
	void show()
	{
		cout<<a<<"   "<<b<<" "<<c<<endl;
	}
private:
	int a;
	const static int b=5;
	const int c;
};
//int b=5;
//int Num::b=5;
int main()
{
	Num num;
	num.fun();
	num.show();
	system("pause");
	return 0;
}

静态变量的初始化不加const得在类外进行初始化，加const可以在类中声明时初始化，也可以在类外进行初始化。const int Num::b=5;
8.const定义的对象变量只能作用于这个程序该C/C++文件，不能被该程序其他C/C++文件调用

如file1.cpp中，const int Val;

如file2.cpp中，extern int Val;//错误，无法调用

要想const定义的对象变量能被其他文件调用，定义时必须要使用extern修饰为

extern const int Val;

非const 变量默认为extern，要是const能被其他文件访问，必须显示指定为extern。