最近几天和同事讨论一个功能的代码时，涉及常量数据的存放，几乎所有.c、.cpp都要使用的常量数据需要放在同一个公共头文件.h中，又考虑到这个.h中的常量后期会增加/删除/改定义顺序等，所以一直在讨论是使用宏定义合适还是使用const定义合适。

基于这个契机，把我对宏和const的理解与看法跟大家分享一下(大家也可以先阅读我以前写的对比列表《「C++」define、const、constexpr分别有哪些特点？》)。

宏和const的优缺点对比

①使用宏

优点：

• 在预编译期进行字符串模板的替换；
• 即使对.h中定义的宏进行增加/删除/改定义顺序等，也不用全系统代码重编，只编译需要使用新修改的宏的代码即可。
• 扩展方便。比如当前宏定义的是整数，以后可以批量替换成字符串类型，业务代码使用宏的地方不用做过多的修改(最终使用的实际函数参数需要适当修改)

缺点：

• 只是符号替换，代码不进行类型检查（宏本身没有具体的类型）；
• 宏是全局有效的，有效范围不可控；

②使用const定义的常量

优点：

• 对数据进行只读性限制，从而在运行期可以保证常量是只读的，不能改变；
• 代码会进行类型检查。

缺点：

• cont修饰的变量也不能保证一定不会被修改。
• const声明的变量有效范围在当前cpp中。比如：
• 在cpp中定义的常量，只有当前文件能访问，其他文件要是想访问，必须通过extern声明的方式才可以。
• 如果在.h中定义的常量，违反“声明位于.h文件，定义(实现)位于.cpp文件”的规律。且被每个cpp文件include时，都会在这个cpp文件中生成一个备份(普通的全局变量同样存在这个现象，因为代码的预编译是把.h拷贝到引用它的cpp中的)，所以每个cpp文件中都要分配内存去存放这个常量/全局数据，尤其是全局数据就达不到预想的全局效果了。
• 基于上一条的原因，const变量定义位置建议：const常量的定义在.cpp中，在.h中使用extern const形式进行全局声明。以确保其在程序中只被赋值一次。这也就导致使用const需要.cpp+.h两个文件，不像宏定义一个.h就能完成。
• 使用const全局变量(在.cpp中定义，.h中声明的方式)，如果后期调整变量声明顺序的话，所有使用此全局变量的地方需要重新编译。因为定义顺序变量，地址的顺序也发生了变化，如果同一个进程中使用的两个动态库，一个使用的是旧顺序，一个使用的新顺序，在进程启动时，cpu对此常量的地址寻址就出错了，程序崩溃，所以扩展性不好。

const的内存分配方式

全局变量、静态变量、常量的内存分组

#include <stdlib.h>
#include <cstdio>
//#include<iostream>
//using namespace std;

int a1;
int b1;
int a2=1;
int b2=2;
static int a3;
static int b3;
static int a4=3;
static int b4=4;

const int a5=5;
const int b5=5;
const char * p_str="abc";

int main() 
{
    //全局变量未初始化区
    printf("&a1=%p, &b1=%p \n",&a1,&b1);//&a1=0x40404c, &b1=0x404050 
    //全局变量初始化区
    printf("&a2=%p, &b2=%p \n",&a2,&b2); //&a2=0x404030, &b2=0x404034 
    //静态全局变量未初始化区
    printf("&a3=%p, &b3=%p \n",&a3,&b3);//&a3=0x404054, &b3=0x404058 
    //静态全局变量初始化区
    printf("&a4=%p, &b4=%p \n",&a4,&b4);//&a4=0x404038, &b4=0x40403c 
    
    //const存储数据的位置不和"普通全局变量"在一个内存段
    printf("&a5=%p, &b5=%p \n",&a5,&b5);//&a5=0x402004, &b5=0x402008 
    //常量字符串
    printf("p_str=%p \n",p_str);//p_str=0x40200c 
}

结论：

①c和c++对此代码的内存分类是一样的。

②全局变量未初始化区、静态全局变量未初始化区==>属于“全局未初始化区”段

③全局变量初始化区、静态全局变量初始化区==>属于“全局初始化区”段

④常量数据存储在“全局变量区”的“常量区”段。c语言和c++一些编译器中，常整数和常量字符串是放一起的，有一些c++编译器中常整数和常量字符串是分开放的。

⑤“全局未初始化区”和“全局初始化区”、“常量区”都属于一个大的段===>“全局变量区”

const变量内存占用方式

ps：与前面的程序相比，多定义了5个常整数，测试常整数对原有非常量数据地址分配的影响。

#include <stdlib.h>
#include <cstdio>
//#include<iostream>
//using namespace std;

int a1;
const int c1=1;
int b1;

int a2=1;
const int c2=1;
int b2=2;

static int a3;
const int c3=1;
static int b3;

static int a4=3;
const int c4=1;
static int b4=4;

const int a5=5;
const int c5=1;
const int b5=5;
const char * p_str="abc";

int main() 
{
    int temp = c1;
    const int * p_test = &c3;
    printf("&c5=%p \n",&c5);
    
    //全局变量未初始化区
    printf("&a1=%p, &b1=%p \n",&a1,&b1);
    //全局变量初始化区
    printf("&a2=%p, &b2=%p \n",&a2,&b2);
    //静态全局变量未初始化区
    printf("&a3=%p, &b3=%p \n",&a3,&b3);
    //静态全局变量初始化区
    printf("&a4=%p, &b4=%p \n",&a4,&b4);
    
    //const存储数据的位置不和"普通全局变量"在一个内存段
    printf("&a5=%p, &b5=%p \n",&a5,&b5);
    //常量字符串
    printf("p_str=%p \n",p_str);
}

c语言的输出结果：

&c5=0x402018 
&a1=0x40404c, &b1=0x404050 
&a2=0x404030, &b2=0x404034 
&a3=0x404054, &b3=0x404058 
&a4=0x404038, &b4=0x40403c 
&a5=0x402014, &b5=0x40201c 
p_str=0x402020 

结论：

①常整数对原有非常量数据地址分配没有影响==>第一个程序已经验证出，常量数据和全局数据不在同一个内存段中。

②根据p_str的地址可以看出来，不管代码中是否对常量进行取值/取址操作，c程序都会对每个常量分配内存。

③使用c++编译，发现部分c++编译器与上一条一样，不管代码中是否对常量进行取值/取址操作，c程序都会对每个常量分配内存。

但是在另外的一些编译器中(比如vs2022常量)，如果常量数据没有被任何地方使用过或只是取值操作，则不给这些常量分配空间；对于被使用取地址操作的常量，或者使用extern修饰的常量，才会分配对应的空间(详细参考备注代码)。

思考：程序是怎么存储取值使用的那个常量数据的呢？

这是因为程序内部有个符号表，编译时发现有const声明时，就在符号表中放入这个常量。编译代码时发现有使用此常量的地方，则直接以符号表中的值替换。

总结

1.宏和常量各有优缺点，宏并不是一无是处的。

2.常量的内存分配方式跟语言有关(c语言还是c++语言)，也和编译器的版本有关。

备注代码

使用vs2022测试结果：

#if 0
#include <stdlib.h>
#include <cstdio>
#else
#include<iostream>
using namespace std;
#endif


const int a5 = 5;
const int c5 = 1;

int a1;
const int c1 = 1;
int b1;

int a2 = 1;
const int c2 = 1;
int b2 = 2;

static int a3;
const int c3 = 1;
static int b3;

static int a4 = 3;
const int c4 = 1;
static int b4 = 4;

const int b5 = 5;
extern const int bx = 6;
const int b6 = 6;

const int b7 = 7;
const int b8 = 7;
const int b9 = 7;

const char* p_str = "abc";

int main()
{
    const int* p_test = &c3;
    printf("&c5=%p \n", &c5);

    //const存储数据的位置不和"普通全局变量"在一个内存段
    printf("&a5=%p, &b5=%p \n", &a5, &b5);
    printf("&b6=%p \n", &b6);
    int temp = b8;
    printf("&b7=%p, &b9=%p \n", &b7, &b9);


    //全局变量未初始化区
    printf("&a1=%p, &b1=%p \n", &a1, &b1);
    //全局变量初始化区
    printf("&a2=%p, &b2=%p \n", &a2, &b2);
    //静态全局变量未初始化区
    printf("&a3=%p, &b3=%p \n", &a3, &b3);
    //静态全局变量初始化区
    printf("&a4=%p, &b4=%p \n", &a4, &b4);


    //常量字符串
    printf("p_str=%p \n", p_str);
}

测试结果：

&c5=00007FF7198E9FD4
&a5=00007FF7198E9FD0, &b5=00007FF7198E9FDC
&b6=00007FF7198E9FE4
&b7=00007FF7198E9FE8, &b9=00007FF7198E9FEC
&a1=00007FF7198EC190, &b1=00007FF7198EC194
&a2=00007FF7198EC000, &b2=00007FF7198EC004
&a3=00007FF7198EC198, &b3=00007FF7198EC19C
&a4=00007FF7198EC010, &b4=00007FF7198EC014
p_str=00007FF7198E9BBC

b5-a5的地址差是12，除了存放a5的空间外，还有2个int的大小，正好是41、42行使用的取地址的常量占用的地址。

b6-b5的地址差是6，除了存放b5的空间外，还有1个int的大小，正好是30行extern使用的取地址的常量占用的地址。