“ 所谓常量,就是在代码运行过程中值恒定不变的标识符,该标识符的值可以是一个常数,也可以是字符串。”
在C/C++中,通常使用define宏定义或者const来定义常量,比如:
#define PI 3.1415926
const int a = 5;
接下来我们来总结const常量的相关用法与注意事项。
01
—
为什么使用常量?
1. 使用常量可增加程序的可读性。
程序员应该都有这种经历:看别人的代码时为代码中某个数字而纠结,不知道这个数字表示什么意义,甚至自己写的代码,过一段时间再回头看,有可能都不记得代码里某个数字代表什么意思。比如计算一天包含的秒数,如果按照下式计算,虽然没错,但很可能会让人懵逼。24代表什么?两个60又分别代表什么?
int s = 24*60*60;
比较推荐的做法是类似这样的,这样看起来就比较清晰了:
const int oneday_hour = 24;
const int onehour_minute = 60;
const int oneminute_second = 60;
const int oneday_second = oneday_hour * onehour_minute * oneminute_second;
2. 使用常量可减少出错的概率。
程序员写代码时,经常需要在多个地方使用同一个数字或者同一个字符串,如果都是直接输入数字或者字符串,万一某个地方写错了,造成该处与其它地方的数字或字符串不一致,很可能导致严重bug。
比如以下代码,多个地方要用到Π值3.1415926,如果把3.1415926定义为一个常量,使用起来就方便多了,也不容易出错:
//不好的使用示例
double a = sin(3.1415926*5);
double b = cos(3.1415926*10);
double b = sin(3.1415926*100)*cos(3.1415926/2);
//推荐的使用示例
const double PI = 3.1415926;
double a = sin(PI*5);
double b = cos(PI*10);
double b = sin(PI*100)*cos(PI/2);
3. 使用常量可以减少代码维护的工作量。
使用常量的情况下,程序员维护代码时如果要修改代码中某个数值,他只需要修改常量的值,那么代码中多处用到该常量的地方也就自己改了过来,而不需要程序员去一个地方一个地方地修改。
比如以下代码,计算b、c、d都要要到5.0这个数值,如果哪一天需求改变,需要把5.0改为20.0,在不好的示例中需要修改三行代码,在我们推荐的示例中只需要修改一行代码——把常量a的值改为20.0即可:
//不好的使用示例
float b = 5.0*3;
float c = 5.0 + 10;
float d = exp(5.0);
//推荐的使用示例
const float a = 5.0;
float b = a*3;
float c = a + 10;
float d = exp(a);
4. 使用常量可提升程序的健壮性
编写代码时,我们经常希望某一个变量的值不被意外改变,或者某指针指向的对象不被意外改变,又或者某指针指向的对象的值不被意外改变(这里可能有点懵逼,读者暂时不用纠结,下文我们再详说)。然而在代码的汪洋大海中,难免会有意外发生,我们能做的就是使用常量来减小这种意外发生的概率。
比如以下函数,指针p作为输入参数,在该函数内部我们不希望p由其原本指向的地址被改为指向别的地址,同时希望指针p指向地址的值是可以改变的,那么可以使用const来修饰p,这样p指向的地址就不会被意外改变啦~
void func(int *const p)
{
int a = 3;
p = &a; //这样的操作是无效的,因为指针p被const修饰,其指向的地址不能被改变
*p = a; //这样的操作是有效的,p指向地址的值会被修改为a的值
}
02
—
const常量与define常量的区别
在C/C++中,有const和define两种定义常量的方式,不过const常量相比define常量有更多的优点:
1. const常量有数据类型,define宏定义常量没有,编译器会对const常量可以进行数据类型的安全检查,但是对于define宏定义,编译器只是将其进行字符替换,这样的字符替换很容易出错。比如以下代码,如果使用不加括号的宏定义,将不能正确计算(a+b)/5.0,而是变成计算a+(b/5.0)了。
//define宏定义的做法
#define a 2.0
#define b 9.0
#define c1 a+b //不好的定义方法
#define c2 ((a)+(b)) //推荐的定义方法
void func1(void)
{
float d1 = c1/5.0; //本意是想计算(a+b)/5.0,但字符替换使计算变成了a+b/5.0
float d2 = c2/5.0; //正确计算了((a)+(b))/5.0 = (a+b)/5.0
}
//推荐的const常量的做法
const float a = 2.0;
const float b = 9.0;
const float c = a + b;
void func2(void)
{
float d = c/5.0; //正确计算了(a+b)/5.0
}
2. 有一些调试工具可以对const常量进行调试,但却无法调试define宏定义常量。
因此,我们还是建议尽量使用const常量。
03
—
建议的const常量定义规则
1. const常量应在.c或.cpp文件中定义,尽量不要在头文件中定义,因为假如头文件被多个.c或.cpp文件包含,那么定义于头文件中的常量将被多次重复定义,很可能造成严重错误。比如以下代码:
推荐的做法,在.c或.cpp文件中定义:
const int x = 15;
不建议的做法,在头文件中定义:
#ifndef _TEST_H_
#define _TEST_H_
const int x = 15;
#endif
虽然不建议在头文件中定义常量,但是对于全局常量,也就是我们不仅希望该常量能在其定义的.c或.cpp文件中使用,还可以在别的.c或.cpp文件中使用,那么可以在头文件中对其进行extern声明,这样一来只要别的.c或.cpp文件include了该头文件,它也就可以使用该常量了,比如以下代码:
#ifndef _TEST_H_
#define _TEST_H_
extern const int x;
#endif
2. 如果一个常量与别的常量有联系,在定义的时候尽量把它们的联系包含进去:
//不推荐的做法
const int a = 5;
const int b = 5*100;
const int c = 5 + 5*100 - 64;
//建议的做法,在定义时把a、b、c的联系包含了进去
const int a = 5;
const int b = a*100;
const int c = a + b - 64;
04
—
容易混淆的const常量定义
1. 某个量的值恒定不变:
const float x = 5.0; //定义x并将x的值初始化为5.0之后,在程序运行期间x的值将保持5.0不变
2. 指针指向的地址恒定不变,但可以通过指针来修改其指向地址的值:
float x = 1.23;
//初始化指针p指向x的地址之后,p将不能改为指向其它地址
float *const p = &x;
//无效操作
float a = 6.3;
p = &a;
//有效操作
*p = 100.0; //等效于x = 100.0
3. 指针指向的地址可以改变,但不能通过指针来修改其指向地址的值,该情况与上述第2种情况相反:
float x = 1.23;
//初始化指针p指向x的地址之后,将不能通过指针p来修改x的值
float const *p = &x;
//有效操作
float a = 6.3;
p = &a;
//无效操作
*p = 100.0; //这样并不能修改x的值,x的值还是1.23
另外,以下两种定义方式是等效的,都属于此种情况:
float const *p;
const float *p;
05
—
const常量与类
在类内部定义的const常量,仅在该类的某个对象的生命周期内是恒定不变的,对于整个类而言却是可以改变的,也即该类的不同对象可以将该常量初始化为不同的值。
声明类时,其内部的const常量成员是不能被初始化的,比如以下代码是有问题的,声明类A时len的值并不能被初始化为50,而是一个不确定的值。
class A
{
const int len = 50; //实际len的值并不能被初始化为50,而是一个不确定的值
int x[len];
}
不过类内部的const常量成员可以通过构造函数的初始化表进行初始化:
class A
{
const int len;
A(int length); //构造函数
};
A::A(int length):len(length) //构造函数的初始化表
{
}
A a(100); // 对象a的len值被初始化为100
A b(200); // 对象b的len值被初始化为200
如果非要定义在类的所有对象中都恒定不变的常量,可以通过以下两种方法:
1. 使用枚举来实现,如以下代码,不过这样做的缺陷是枚举定义的len1和len2只能是整型数,不能是浮点数。
class A
{
enum { len1 = 20, len2 = 58}; //len1和len2的值在所有对象中都是不变的
int x1[len1];
int x2[len2];
};
2. 使用static关键字,加上static修饰之后,常量len不再保存在存储对象的区域(堆、栈等),而是保存到了静态存储区,因此对所有该类的对象来说len是恒定不变的常量。
class A
{
static const int len = 30;
int x[len];
}
欢迎扫码关注本微信公众号,接下来会不定时更新更加精彩的内容,敬请期待~
点击进入留言区