C++ | 初识const关键字、常量与常变量

文章目录

      • C语言的const
          • 1. const关键字
          • 2. const 修饰的只读变量
          • 3. 节省空间,避免不必要的内存分配,同时提高效率
          • 4. 使用cosnt修饰
            • 4.1 修饰一般变量
            • 4.2 修饰数组
            • 4.3 修饰指针
            • 4.4 修饰函数的参数
            • 4.5 修饰函数的返回值
      • C与C++中cosnt的区别
          • 1. 在C语言中
          • 2. 在C++语言中
          • 3. cosnt修饰指针
            • 3.1 常量指针
            • 3.2 指针常量
            • 3.3 指向常量的指针常量
          • 4. cosnt修饰二级指针
          • 5. cosnt指针练习

C语言的const

注:c语言部分cosnt引用自《c语言深度剖析》一书。

1. const关键字

const 是 constant 的缩写,是恒定不变的意思,也翻译为常量、常数等。很不幸,正是因为这一点,很多人都认为被 const 修饰的值是常量。这是不精确的,精确的说应该是只读的变量,其值在编译时不能被使用,因为编译器在编译时不知道其存储的内容。或许当初这个关键字应该被替换为 readonly。那么这个关键字有什么用处和意义呢?

const 推出的初始目的,正是为了取代预编译指令,消除它的缺点,同时继承它的优点。我们看看它与 define 宏的区别。 (很多人误以为 define 是关键字,然而并不是)。在C和C++中都有const关键字,但是他们的各自表示的意义是有所差别的。

2. const 修饰的只读变量

定义 const 只读变量,具有不可变性。
例如:
const int Max=100;
intArray[Max];
这里请在 Visual C++6.0 里分别创建.c 文件和.cpp 文件测试一下。你会发现在.c 文件中,编译器会提示出错,而在.cpp 文件中则顺利运行。为什么呢?我们知道定义一个数组必须指定其元素的个数。这也从侧面证实在 C 语言中, const 修饰的 Max 仍然是变量,只不过是只读属性罢了;而在 C++里,扩展了 const 的含义,我们在后面讨论。

注意: const 修饰的只读变量必须在定义的同时初始化,想想为什么?

答:只读,不可写。因此定义后不可再次赋值。

留一个问题: case 语句后面是否可以是 const 修饰的只读变量呢?请动手测试一下。

答:case后面只能跟整形或者字符型的常量或常量表达式;因此,在C语言中不可以,C++中可以。
void select(int a)
{
 const int b = 10;
 switch (a)
 {
 case  b: cout << "hello" << endl;
   break;
  default:
   break;
 }
}

int main()
{
 select(10);
 return 0;
}
3. 节省空间,避免不必要的内存分配,同时提高效率

编译器通常不为普通 const 只读变量分配存储空间,而是将它们保存在符号表中,这使
得它成为一个编译期间的值,没有了存储与读内存的操作,使得它的效率也很高。
例如:

#define M 3 //宏常量
const int N=5; //此时并未将 N 放入内存中
......
int i=N; //此时为 N 分配内存,以后不再分配!
int I=M; //预编译期间进行宏替换,分配内存
int j=N; //没有内存分配										// 注:取第一次分配时的地址给 j
int J=M; //再进行宏替换,又一次分配内存!

const 定义的只读变量从汇编的角度来看, 只是给出了对应的内存地址, 而不是象#define一样给出的是立即数,所以, const 定义的只读变量在程序运行过程中只有一份拷贝(因为它是全局的只读变量,存放在静态区),而#define 定义的宏常量在内存中有若干个拷贝。

#define 宏是在预编译阶段进行替换,而 const 修饰的只读变量是在编译的时候确定其值。
#define 宏没有类型,而 const 修饰的只读变量具有特定的类型。

4. 使用cosnt修饰
4.1 修饰一般变量

一般常量是指简单类型的只读变量。这种只读变量在定义时,修饰符 const 可以用在类型说明符前,也可以用在类型说明符后。例如:
int const i=2;const int i=2;

4.2 修饰数组

定义或说明一个只读数组可采用如下格式:
int const a[5]={1, 2, 3, 4, 5};
const int a[5]={1, 2, 3, 4, 5};

4.3 修饰指针
const int *p; // p 可变, p 指向的对象不可变
int const *p; // p 可变, p 指向的对象不可变
int *const p; // p 不可变, p 指向的对象可变
const int *const p; //指针 p 和 p 指向的对象都不可变

先忽略类型名(编译器解析的时候也是忽略类型名),我们看 const 离哪个近。 “近水楼
台先得月”,离谁近就修饰谁。

const int *p; //const 修饰*p,p 是指针, *p 是指针指向的对象,不可变
int const *p; //const 修饰*p,p 是指针, *p 是指针指向的对象,不可变
int *const p; //const 修饰 p, p 不可变, p 指向的对象可变
const int *const p; //前一个 const 修饰*p,后一个 const 修饰 p,指针 p 和 p 指向的对象
都不可变
4.4 修饰函数的参数

const 修饰符也可以修饰函数的参数,当不希望这个参数值被函数体内意外改变时使用。例如:
void Fun(const int i);
告诉编译器 i 在函数体中的不能改变, 从而防止了使用者的一些无意的或错误的修改。

注:void Fun(int i) 在 void Fun(const int i)在C++中是一个函数,不会被认为是重载。
可使用 typeid(i).name() 函数查看类型都为 int 类型
4.5 修饰函数的返回值

const 修饰符也可以修饰函数的返回值,返回值不可被改变。例如:
const int Fun (void);
在另一连接文件中引用 const 只读变量:
extern const int i; //正确的声明
extern const int j=10; //错误!只读变量的值不能改变。
注意这里是声明不是定义,注意声明和定义的区别。


C与C++中cosnt的区别

首先,const的作用表示,使用const修饰的变量不能作左值。在初始化完成后不能被修改。

1. 在C语言中
  1. const修饰的量,可以不用初始化(测试得)。
  2. cosnt修饰的量,称之为常变量,不可以用来初始化数组长度。
  3. cosnt修饰的量,无法直接修改,但可以通过指针或汇编指令等方式修改。

.c 文件中

	const int b;	// 无初始化, ok

	const int a = 10;
	//int arr[a] = {};		// 初始化数组长度 ,error

	int* p = (int*)&a;

	*p = 30;			// 30 30 30
	printf("%d %d %d \n", a, *p, *(&a));
2. 在C++语言中
  1. const修饰的量,必须初始化。
  2. cosnt修饰的量,称之为常量,预编译阶段全部替换,可以用来初始化数组长度。
  3. cosnt修饰的量,无法修改。

.cpp 文件中

	//const int b;	// error

	const int a = 10;
	int arr[a] = {};

	int* p = (int*)&a;

	*p = 30;			// 10 30 10
	printf("%d %d %d \n", a, *p, *(&a));
	// 注,这里的 a 和 *(&a) ,以及int arr[a]中的常量a在与编译阶段都被替换成10.

关于C++中通过指针修改常量这一点,可参考博客:C++中如何修改const变量

特殊情况:常量退化为常变量

	int b = 20;
	const int a = b;
3. cosnt修饰指针
3.1 常量指针

常量指针,即指向常量的指针

const int *p;
int const *p; // const 与 int 不分先后,意义相同。
此类指针我们称之为常量指针。顾名思义,指针指向的值是一个常量(语法上的,编译器认为该值不可通过指针修改)。
记忆方法:const修饰的 (*p),*p解引用后就是指针所指向的值。则const直接修饰该值,该值为常量。所以常量指针修饰的值为常量(不可做左值被修改)。
示例代码:

    {
       int a = 10;
       const int* p = &a;
       int *q = p;      // 此语句错误的,   int*  <==  const int*   的指向赋值,普通指针存在修改常量的风险,编译器报错。
    }
3.2 指针常量

指针常量。即指针本身是一个常量

int* const p;

指针是常量,即不可改变指针的指向。而指针指向的内容任然是可修改的。
特点:指针常量本身任然是一个指针,也就是说 int* const p 与 int p 的类型都是 "int "类型指针。因此,我们可以认为指针常量是一个限定了指向的指针
记忆方法:const 修饰了 (p),p是一个指针,也就是说const限制的p不能改变指向。
示例代码:

    {
       int a = 10;
       int* const p = &a;
       int *q = p;      // 此语句正确,本质上是指针的   int*  <==  int*   的指向赋值
    }
3.3 指向常量的指针常量

不可改变指向,且不可修改内容的指针。
const int* const p = &a;

4. cosnt修饰二级指针

const修饰一级指针:

	int a;
	const int* p1 = &a;
	int const* p2 = &a;
	int* const p2 = &a;

const修饰二级指针:

	int a;
	int* p = &a;
	const int* p1 = &a;

	/*  cosnt无修饰类型 */
	int**       pp0 = &p;
	int** const pp1 = &p;

	/*  cosnt修饰一级指针 */
	int* const* pp2 = &p;

	/*  cosnt修饰二级指针 */
	int const** pp3 = &p1;		// int const** pp31 = &p;	// 无法从“int * *”转换为“const int** ”
	const int** pp4 = &p1;		// const int** pp41 = &p;	// ..
	
	/*  cosnt修饰一级和二级指针 */
    const int* const* pp5 = &p;
	int const* const* pp6 = &p;
5. cosnt指针练习

题目一:下列表达式语句赋值错误的是?

	int a = 10;
	const int* p = &a;
	int* q = p;		

	int a = 10;
	int* const p = &a;
	int* q = p;

	int a = 10;
	int* const p = &a;
	int* const q = p;

	int a = 10;
	int* const p = &a;
	const int* q = p;

题目二:下列表达式语句错误的有。

// 选项A
int a = 10;
int* p1 = &a;
const int** q1 = &p1;	

// 选项B
int a = 10;
int* p2 = &a;
int* const* q2 = &p2;

// 选项C
int a = 10;
int* p3 = &a;
int** const q3 = &p3;

// 选项D
int a = 10;
int* const p4 = &a;
int** q4 = &p4;	

// 选项E
int a = 10;
const int* p5 = &a;
int* const* q5 = &p5;	

题目解析请参看博客 练习题:C++指针练习 。

你可能感兴趣的:(#,C++,c++,指针,const)