【c++】常量周边之const应用：常变量

景鹤

于 2024-09-04 22:05:57 发布

阅读量256

点赞数 7

分类专栏： c++ 文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/m0_73726899/article/details/141683476

版权

c++ 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

【c++】常量周边：常量概念及定义

承接上文，我们学习了常量的基础知识，在此基础上，本篇文章对于宏定义 #define 和常量 const进行深入学习。

#define 预处理器

1.宏定义是字符替换，没有数据类型的区别，同时这种替换没有类型安全检查，可能产生边际效应等错误；
#define N 2+3     // 我们预想的 N 值是 5，我们这样使用 
Ndouble a = N/2;  // 我们预想的  a 的值是 2.5，可实际上 a 的值是 3.5

2.宏定义是一个"编译时"概念，在预处理阶段展开，不能对宏定义进行调试，生命周期结束在编译时期

3.宏定义是直接替换，不会分配内存，存储于程序的代码段中；

4.注意！！

预处理 #define 变量定义值以后，不能用分号，否则就会计算错误，但是程序不会报错

#define 常量名  常量值

5.宏定义是可以取消的！！利用 #undef
定义： #define    N    21
取消： #undef    N     21

使用实例：

#include <iostream>
using namespace std;
 
#define LENGTH 10   
#define WIDTH  5
#define NEWLINE '\n'
 
int main()
{
 
   int area;  
   
   area = LENGTH * WIDTH;
   cout << area;
   cout << NEWLINE;
   return 0;
}

const:在常量方面应用

使用技巧

1. const常量是常量的声明，有类型区别，需要在编译阶段进行类型检查

2. const限定符定以后是不可以改变的，所以在定义时必须赋初始值，要不然是错误的，除非这个变量是用extern修饰的外部变量。
const int A=10;       //正确。
const int A;          //错误，没有赋初始值。
extern const int A;   //正确，使用extern的外部变量。

3. const常量需要进行内存分配，存储于程序的数据段中

const与指针的结合

const 关键字出现在 * 的左边：指针指向的内容不能被修改。称其为指向常量打的指针，此时也被称为底层const
const 关键字出现在 * 的右边：指针本身不能被修改，但指向的内容可以改变，称其为常量指针，此时也被称为顶层const，
const 关键字出现在 * 的两边: 指针指向的内容和指针本身都不能被修改。此时同时拥有底层和顶层const。

几点注意：

（1）底层指针指向的内容并非不可修改，只是无法通过该指针进行修改，换句话来说，底层指针“自作多情”地认为自己指向的内容是无法修改的，实际上可以通过赋值等方法改变其指向的内容。

（2）在使用中，顶层const只用来修饰指针，无法修饰引用（因为引用不是变量）；而底层const可以修饰指针和引用，其意义为指向或引用的内容是一个常量。只需要记住，底层const限定指向或引用的对象是常量，对指针或引用并没有限定；顶层const限定指针是常量，对其指向的内容没有限定。

（3）底层const会给变量施加一个限制，在执行拷贝操作时，非底层const的对象无法给具有底层const的变量赋值。（底层const的权限只能读，非底层const的对象的权限可以读和写。非底层const的对象无法给具有底层const的变量赋值，权限被放大了，是被禁止的行为！！）
#include <iostream>
using namespace std;

int main()
{
    int a = 1;
    const int* p1 = &a;         //底层const, 也可以用int const *p1 = &a;.
    *p1 = 2;                    //非法, 无法通过p1更改a的值.
    p1++;                       //合法, p1的值(指向的地址)是可以更改的.
    a = 2;                      //合法, 只是无法通过p1解引用的方式更改a的值, 其他方式可以.

    int* const p2 = &a;         //顶层const, p2是常量.
    *p2 = 3;                    //合法, p2指向地址的内容可以更改.
    p2++;                       //非法, p2的值(指向的地址)无法更改.
    a = 4;                      //合法, p2指向地址的内容可以更改.
    const int* const p3 = &a;   //同时具有底层和顶层const, p3的值(指向的地址)无法修改, 且无法通过p3解引用进行更改.
    int* p4 = p1;               //非法, p1是const *int(底层const), 无法给普通int*赋值.
    int* p5 = p2;               //合法, p2是*const int(顶层const), 赋值时没有限制.
    const int* p6 = p1;         //合法, p6也是const *int(底层const), 可以获得p1的赋值.
}

const 与 #define 的区别

角度1：就定义常量说的话， const 定义的常数是变量也带类型， #define 定义的只是个常数不带类型。

角度2：就起作用的阶段而言，#define 是在编译的预处理阶段起作用，而 const 是在编译、运行的时候起作用。

角度3：就起作用的方式而言，#define 只是简单的字符串替换，没有类型检查。而 const 有对应的数据类型，是要进行判断的，可以避免一些低级的错误。正因为 define 只是简单的字符串替换会导致边界效应，具体举例可以参考下面代码：
#define N 2+3     // 我们预想的 N 值是 5，我们这样使用 
Ndouble a = N/2;  // 我们预想的  a 的值是 2.5，可实际上 a 的值是 3.5

const int WIDTH = 100;
#define WIDTH "100"        // 没有类型检查，可能引发错误
 
int array[WIDTH];          // 使用 const 时是正确的，有类型检查
int array[WIDTH];          // 使用宏定义，可能导致错误，因为没有类型检查

角度4：就空间占用而言，例如：

#define PI 3.14     //预处理后 占用代码段空间
const float PI=3.14;    // 本质上还是一个 float，占用数据段空间

角度5：从代码调试的方便程度而言, const 常量可以进行调试的，#define 是不能进行调试的，因为在预编译阶段就已经替换掉了

角度6：从是否可以再定义的角度而言, const 不足的地方，是与生俱来的，const 不能重定义，而 #define 可以通过 #undef 取消某个符号的定义，再重新定义。
const int PI = 3.14;      // 不能重定义
#define PI 3.14
#undef PI                 // 取消定义
#define PI 3.1416         // 可以重定义