解析C与C++中的关键字const

在C与C++语言中都存在关键字const,很多人都对此关键字存在一个错误的认识，认为在C语言中关键字const是使变量作为一个常量，即将变量常量化，就像宏定义一样。而在C语言中的关键字const所起的作用并不是使变量常量话，而是限制变量，使变量除了被赋初值外，无法被重新赋值。
而在C++中关键字const不仅使该变量无法修改，也是使变量常量化，即将变量赋初值后可以当作常量使用，相当于进行了宏定义。
在编译器中输入以下代码，你会有更直观的体会。

在C语言编译器中：

/* const限制的变量的值无法修改*/
#include <stdio.h>
int main(void)
{
    const int a=1;
    int const b=1;
    a=1;
    b=1;
    system("pause");
    return 0;
}

当你将这段代码编译时，编译器会报错：在mian函数中无法修改const限制的对象。



注：在C语言中，关键字const被放在标识符之前或之后是一样的效果。

/* const限制的变量无法修改*/
#include <stdio.h>
int main(void)
{
	const int a=1;
	switch(1)
	{
		case a:prinf("variable a can be used as constant");break;
		default :printf("variable a cannot be used as constant");
	}
	system("pause");
	return 0;
}

当你编译这段代码是，编译器会报错：在main函数中要求使用常量。



关键字const对指针的限制：

/*cosnt在*前，指针指向对象的值无法修改*/
#include <stdio.h>
int main(void)
{
	int a=1,b=2;
	const int * p1=&a;
	int const * p2=&b;
	*p1=1;
	*p2=1;
	system("pause");
	return 0;
}

const在星号前对对指针变量进行限制时是对指针变量所指向的对象进行限制，针对上列代码就是对a，b进行限制，使a，b不能被重新赋值，因此编译时会报错：在mian函数中无法修改const限制的对象。但两个指针变量的值是可以修改的。编译下列代码：

/* cosnt在*前，指针变量的值可以修改*/
#include <stdio.h>
int main(void)
{
    int a=1,b=2;
    const int * p1=&a;
    int const * p2=&b;
    printf ("a=%d/nb=%d/n",*p1,*p2);
    p1=&b;
    if(p1==p2)
        printf("the address of p1 is equal to the address of p2/n");
    system("pause");
    return 0;
}

那么如何对指针变量进行限制呢？答案就是在”*”后使用限制符const

/* cosnt在*后，指针变量的值无法修改*/
#include <stdio.h>
int main(void)
{
    int a=1,b=2;
    int * const p1=&a;
    int const * p2=&b;
    p1=&b;
    system("pause");
    return 0;
}

编译时会报错：在mian函数中无法修改const限制的对象。



对上述代码进行一下思考就会发现如果这样定义：const int *const a=&b；那么就会发现指针变量a的值无法改变，指针变量a所指向的对象变量b的值也无法改变。



在C++中：

在C++中的const也具有在C中的作用。并且const限制的变量时可以当作常量来使用的。

/* const限制的变来那个可以作为常量使用*/
#include <iostream>
using namespace std;
int main(void)
{
    const int a=1;
    switch(1)
    {
        case a:cout<<"变量a可以当作常量使用";break;
        default :cout<<"变量a无法作为常量使用";break;
    }
    system("pause");
    return 0;
}

注：
1. 在C++中的注释有两种，一种是单行注释——//，在“//”后写注释；另一种是多行注释——/* */，是从C中继承过来的，只要在“/*”与“*/”之中就是注释，不论是否可以进行注释的嵌套，建议不要使用注释嵌套。
2. 上述报错原本是英文，是本人进行的翻译，有翻译不当之处包含并请指出。



const关键字的最常用方法是用作函数的形参设置，为了使形参的值不会被改变而有用const关键字进行限制。例如（以C语言为例）：

/*const 通常用作修饰函数定形参*/
#include <stdio.h>
 
void max(const int a,int const b);
 
int main(void)
{
    int a=1,b=2;
    max(a,b);
    system("pause>nul");
    return 0;
}
 
void max(const int a,int const b)
{
    a<b?printf("b is bigger than a /n"):printf("a is bigger than b /n");
}

/*const限制函数的返回值*/
#include <stdio.h>
const int a(void)
{
	int a=1;
	return a;
}
int main(void)
{
	int b=a();
	printf("b is %d/n",b);
	system("pause");
	return 0;
}

const引用
在C++中引入了“引用”这一概念，所谓的引用其实只是对一个变量又起了个名字而已，这就相当于是每个人都有个学名和乳名，虽然名字不一样但所指的人是同一个人。值得注意到是引用一定要初始化，而且该引用初始化后只要引用存在，他就保持绑定到初始化时的指向对象，不能将引用绑定到另外一个对象。
另外，引用分为非const引用和const引用，这里讲讲const引用。

//const引用可以直接引用常量
#include <iostream>
using namespace std;
int b(void)
{
 	  const int &a = 1;
 	  return a;
}
int main(void)
{
 	  int a=b();
	  const int &c=1；//非法的
 	  cout<<a<<endl;
	  cout<<c<<endl;
 	  system("pause");
 	  return 0;
}

你会发现这段代码是会报错的，因为在主函数中的非const引用直接引用了常量，这是非法的，因此只要你去掉c的引用和输出就能正常运行了，这是const引用与非const引用的区别。

//引用不能被引用
#include <iostream>
using namespace std;
int main(void)
{
	const int &a=1;//合法
	int &b=a;//非法
	cout<<a<<endl<<b<<endl;
	system("pause");
	return 0;
}

当你删除程序中的b后就能正常编译运行了。

//const引用可以初始化为不同类型的对象或初始化右值
#include <iostream>
using namespace std;
int main(void)
{
 	double a=3.14;
	const int &b=a;
 	cout<<b<<endl<<a<<endl;
 	return 0;
}

这里的b如果不是const限制的话是非法的（C++ primer上说可以引用，并且如果修改b的话a不会被修改，并且解释说其实b引用a实际上编译时会有一个中间变量，修改的是那个中间变量，但我在VC++和DEV_C++上试过，都会报错）。










这些例子都很简单，也不是特别明显可以说明问题，这只是我对收获的一点记录，只是为了表明用法，希望能对读者也有所帮助。