众所周知，C语言一开始只有#define，C程序员用#define定义符号常量。但后来ANSI C加入了const限定符，而const应该比#define更好，为什么现在的C程序员还在大量使用#define来定义常量呢？
这并不是我没有根据地乱说的。这样的例子有很多，例如&limits.h&，例如Windows API，例如OpenGL……
&limits.h&是C标准头文件，发明C语言的人难道不知道const吗？
Windows是Microsoft开发的，难道Microsoft的代码很差劲？
开发OpenGL的难道写的代码也很烂吗？
太奇怪了吧！因此，肯定是有什么特殊原因让他们使用#define……
曾今我在百度上用中文查这个问题，发现根本查不到；昨天我Google了“why use #define instead of const”，才在stackoverflow上找到了一个同样的问题：
于是我阅读了这个问题的答案，然后挑选出一些答案，翻译出来。下面就是一些回答的原文和翻译（稍有修改），包括回答者的名字我也列出来了~
1. Bart van Ingen Schenau的回答
There is a very solid reason for this: const in C does not mean something is constant. It just means a variable is read-only.
In places where the compiler requires a true constant (such as for array sizes for non-VLA arrays), using a const variable, such as fieldWidth is just not possible.
这有个很可靠的原因：const在C中不表示一个变量是常量。const只表示一个变量是只读的。
在编译器需要一个真正的常量的情况下（例如不可变长数组的大小），使用const变量，例如fieldWidth是不可能的。
2. Vovanium回答
They're different.
const is just a qualifier, which says that a variable cannot be changed at runtime. But all other features of the variable persist: it has allocated storage, and this storage may be addressed. So code does not just treat it as a literal, but refers to the variable by accessing the specified memory location (except if it is static const, then it can be optimized away), and loading its value at runtime. And as a const variable has allocated storage, if you add it to a header and include it in several C sources, you'll get a "multiple symbol definition" linkage error unless you mark it as extern. And in this case the compiler can't optimize code against its actual value (unless global optimization is on).
#define simply substitutes a name with its value. Furthermore, a #define'd constant may be used in the preprocessor: you can use it with #ifdef to do conditional compilation based on its value, or use the stringizing operator # to get a string with its value. And as the compiler knows its value at compile time it may optimize code based on that value.
For example:
#define SCALE 1
scaled_x = x * SCALE;
When SCALE is defined as 1 the compiler can eliminate the multiplication as it knows that x * 1 == x, but if SCALE is an (extern) const, it will need to generate code to fetch the value and perform the multiplication because the value will not be known until the linking stage. (extern is needed to use the constant from several source files.)
A closer equivalent to using #define is using enumerations:
enum dummy_enum {
constant_value = <span style="color: #010
But this is restricted to integer values and doesn't have advantages of #define, so it is not widely used.
const is useful when you need to import a constant value from some library where it was compiled in. Or if it is used with pointers. Or if it is an array of constant values accessed through a variable index value. Otherwise, const has no advantages over #define.
它们不一样。
const只是个限定符，表示一个变量不能在运行时间被修改。但其他所有属于变量的特性仍保留着：它有已分配的存储器（原文是allocated storage），而且这个存储器可能有地址。所以代码不将它（const变量）看作常量，而通过访问指定的内存位置指代该变量（除非是static const，这样它就会被优化），然后再运行时间加载它的值。然后因为const变量有已分配的存储器，如果你将它加入一个头文件然后在多个C源代码文件中包含它，你会得到一个“符号重定义”的链接错误，除非你将它标记为extern。而且在这种情况下，编译器不能针对其真实值优化代码（除非打开全局优化）。
#define简单地用一个值替代一个名字。此外，一个#define定义的常量可以在预处理器中使用：你可以将其和#ifdef一起使用，在它的值的基础上做条件编译，或者使用连接符#以获取一个值对应的字符串。并且因为编译器在编译时知道它的值，编译器将可以在该值的基础上进行优化。
举个例子：
#define SCALE 1
scaled_x = x * SCALE;
当SCALE被定义为1时，编译器可以直接去掉这个乘法运算，因为它知道x * 1 == x。但如果SCALE是一个（extern）const变量，编译器就会需要生成代码以获取其值，然后进行乘法运算，因为SCALE的值在链接阶段以前都是未知的（在多个源代码文件中使用该const变量时需要extern）。
另一个更接近于#define的方法是枚举量：
enum dummy_enum {
constant_value = <span style="color: #010
但枚举量被限制为整数，与#define相比没有优势，因此使用不广泛。
在需要从库中导入常量值时const很有用；或者其和指针一起使用；或者其为一个通过索引值访问的常量数组。否则，const对于#define没有优势。
3. R..的回答
The reason is that most of the time, you want a constant, not a const-qualified variable. The two are not remotely the same in the C language. For example, variables are not valid as part of initializers for static-storage-duration objects, as non-vla array dimensions (for example the size of an array in a structure, or any array pre-C99).
原因是因为在大多数情况下，你想要一个常量，而不是有const限定符的变量。两者在C中不完全一样（原文是note remotely the same，不知道有没有犯错）。例如，变量作为静态存储周期对象的initializer的一部分是非法的，例如不可变长数组的大小（例如结构中一个数组的大小，或者C99前的任何数组）。
翻译了一部分，也不知道有没有错误，如果有错误请指出~
看了3个回答，我想答案已经十分明显了。
C中的const和C++的不同。在C中，const定义的常量和#define定义的常量不完全相同。#define是预处理器指令，在编译前就会把所有#define定义的常量的名字全部替换为其值。const定义的常量等同于只读变量，值在链接时才会知道。（我想，我之所以会有这个问题，是因为我直接学了C++而不是先学C，而C和C++中的const不一样。）
因此const定义的常量对于编译器就不是100%的常量，数组长度不能是const常量，只能是#define定义的常量。条件编译的时候也只能使用#define定义的常量。
那么也不是每个常量都是表示数组大小的吧，剩下的常量为什么也是用#define定义的呢？以我naive的思维，估计是因为为了代码风格上的统一吧。
那么在C++中为什么还有很多#define呢？那估计就是继承了C的习惯吧，或者为了兼容C吧……不过，如果是C++，建议使用const，而不是#define，来定义常量。
本文可转载，转载请注明出处：。
阅读(...) 评论()const成员常量能用来定义数组大小吗？
[问题点数：60分，结帖人srxumin]
本版专家分：276
结帖率 100%
CSDN今日推荐
本版专家分：914
本版专家分：39985
2014年11月 C/C++大版内专家分月排行榜第三
本版专家分：17136
2016年10月优秀小版主
优秀小版主
本版专家分：276
本版专家分：20212
2005年4月 C/C++大版内专家分月排行榜第一2005年3月 C/C++大版内专家分月排行榜第一2005年2月 C/C++大版内专家分月排行榜第一
本版专家分：534
本版专家分：10
本版专家分：137411
2017年 总版技术专家分年内排行榜第六
2018年1月 总版技术专家分月排行榜第一2016年12月 总版技术专家分月排行榜第一2016年11月 总版技术专家分月排行榜第一2016年10月 总版技术专家分月排行榜第一
2016年10月优秀大版主2016年8月优秀大版主
2018年5月 总版技术专家分月排行榜第二2017年12月 总版技术专家分月排行榜第二2016年9月 总版技术专家分月排行榜第二
本版专家分：914
本版专家分：31777
2014年4月 C/C++大版内专家分月排行榜第二
2016年2月 C/C++大版内专家分月排行榜第三2016年1月 C/C++大版内专家分月排行榜第三
本版专家分：15068
2015年10月 C/C++大版内专家分月排行榜第二
2015年12月 C/C++大版内专家分月排行榜第三2015年11月 C/C++大版内专家分月排行榜第三
本版专家分：15068
2015年10月 C/C++大版内专家分月排行榜第二
2015年12月 C/C++大版内专家分月排行榜第三2015年11月 C/C++大版内专家分月排行榜第三
本版专家分：15068
2015年10月 C/C++大版内专家分月排行榜第二
2015年12月 C/C++大版内专家分月排行榜第三2015年11月 C/C++大版内专家分月排行榜第三
本版专家分：276
匿名用户不能发表回复！|
其他相关推荐转载请注明出处：
应用中我们经常会用到一些应用场景，如使用Const 关键字定义一个数组到Flash地址单元，但是具体该数组放在Flash的那个位置，通常是由编译器自己分配的（和LCF连接配置文件设置有关），以及定义函数到RAM区域，增快程序代码的执行速度。所以在这些场合我们会去思考如何指定一段数组或者一个函数到特定的Flash，EEPROM或者RAM区间中，下面简单给出几个实例。
1. 指定数组到特定的Flash单元
#pragma location = 0x000FFF00
&__root const char Flash_config[] =&
0x0,0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9,0xA,0xB,0xC,0xD,0xE,0xF,
0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,
0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,
0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,
0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,
0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,
0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0x2F,
执行结果如下：
2. 定位到Flash区域，这个需要两个步骤：
第一步：在LCF文件分配一段代码；
char Function_Relocted_to_Address(int flag) @&.funflash&
& if (flag & 0)
& &return 1;
& return 0;
& 2010 - 2018 苏州灵动帧格网络科技有限公司 版权所有.
ICP经营许可证 苏B2-&C语言程序的存储区域与const关键字的使用方法
我的图书馆
C语言程序的存储区域与const关键字的使用方法
一.C语言程序的存储区域
1.由C语言代码（文本文件）形成可执行程序（二进制文件），需要经过编译-汇编-连接三个阶段。编译过程把C语言文本文件生成汇编程序，汇编过程把汇编程序形成二进制机器代码，连接过程则将各个源文件生成的二进制机器代码文件组合成一个文件。
2.C语言编写的程序经过编译-连接后，将形成一个统一文件，它由几个部分组成。在程序运行时又会产生其他几个部分，各个部分代表了不同的存储区域：
1&代码段（Code或Text）
代码段由程序中执行的机器代码组成。在C语言中，程序语句执行编译后，形成机器代码。在执行程序的过程中，CPU的程序计数器指向代码段的每一条机器代码，并由处理器依次运行。
2&只读数据段(RO&data)
只读数据段是程序使用的一些不会被更改的数据，使用这些数据的方式类似查表式的操作，由于这些变量不需要更改，因此只需要放置在只读存储器中即可。
3&已初始化读写数据段(RW data)
已初始化数据是在程序中声明，并且具有初值的变量，这些变量需要占用存储器的空间，在程序执行时它们需要位于可读写的内存区域内，并且有初值，以供程序运行时读写。4&未初始化数据段(BBS)
未初始化数据是在程序中声明，但是没有初始化的变量，这些变量在程序运行之前不需要占用存储器的空间。
5&堆(heap)
堆内存只在程序运行时出现，一般由程序员分配和释放。在具有操作系统的情况下，如果程序没有释放，操作系统可能在程序(例如一个进程)结束后会后内存。
6&栈（statck）
堆内存只在程序运行时出现，在函数内部使用的变量，函数的参数以及返回值将使用栈空间，栈空间由编译器自动分配和释放。
3.代码段、只读数据段、读写数据段、未初始化数据段属于静态区域，而堆和栈属于动区域。代码段、只读数据段和读写数据段将在连接之后产生，未初始化数据段将在程序初始化的时候开辟，而对堆和栈将在程序饿运行中分配和释放。
4.C语言程序分为映像和运行时两种状态。在编译-连接后形成的映像中，将只包含代码段(Text)、只读数据段(R0 Data)和读写数据段（RW Data）。在程序运行之前，将动态生成未初始化数据段(BSS)，在程序的运行时还将动态生成堆(Heap)区域和栈（Stack）区域。
注：1.一般来说，在静态的映像文件中，各个部分称之为节(Section)，而在运行时的各个部分称之为段(Segment)。如果不详细区分，统称为段。
2.C语言在编译连接后，将生成代码段(TEXT)，只读数据段(RO Data)和读写数据段(RW Data)。在运行时，除了上述三个区域外，还包括未初始化数据段(BBS)区域和堆（heap）区域和栈（Stack）区域。
二.C语言程序的段
1.段的分类
每一个源程序生成的目标代码将包含源程序所需要表达的所有信息和功能。目标代码中各段生成情况如下：
1&代码段（Code）
代码段由程序中的各个函数产生，函数的每一个语句将最终经过编译和汇编生成二进制机器代码
2&只读数据段(RO Data)
只读数据段由程序中所使用的数据产生，该部分数据的特点在运行中不需要改变，因此编译器会将数据放入只读的部分中。C语言的一些语法将生成只读数据数据段。
2& 只读数据段(RO Data)
只读数据段(RO Data)由程序中所使用的数据产生，该部分数据的特点是在运行中不需要改变，因此编译器会将数据放入只读的部分中。以下情况将生成只读数据段。
n& 只读全局变量
定义全局变量const&
char&a[100]=”abcdefg”将生成大小为100个字节的只读数据区，并使用字符串“abcdefg”初始化。如果定义为const
char a[]=”abcdefg”,没有指定大小，将根据“abcdefgh”字串的长度，生成8个字节的只读数据段。
n& 只读局部变量
例如：在函数内部定义的变量const&char& b[100]=””;其初始化的过程和全局变量。
n& 程序中使用的常量
例如：在程序中使用printf("information\n”),其中包含了字串常量，编译器会自动把常量“information \n”放入只读数据区。
注：在const &char a[100]={“ABCDEFG”}中，定义了100个字节的数据区，但是只初始化了前面的8个字节（7个字符和表示结束符的‘\0’）。在这种用法中，实际后面的字节米有初始化，但是在程序中也不能写，实际上没有任何用处。因此，在只读数据段中，一般都需要做完全的的初始化。
3.读写数据段（RW Data）
读写数据段表示了在目标文件中一部分可以读也可以写的数据区，在某些场合它们又被称为已初始化数据段。这部分数据段和代码，与只读数据段一样都属于程序中的静态区域，但是具有科协的特点。
n& 已初始化全局变量
例如：在函数外部，定义全局的变量char& a[100]=”abcdefg”
n& 已初始化局部静态变量
例如：在函数中定义static &char b[100]=””。函数中由static定义并且已经初始化的数据和数组将被编译为读写数据段。
读写数据区的特点是必须在程序中经过初始化，如果只有定义，没有初始值，则不会生成读写数据区，而会定义为未初始化数据区(BSS)。如果全局变量（函数外部定义的变量）加入static修饰符，写成static& char&a[100]的形式，这表示只能在文件内部使用，而不能被其他文件使用。
4.未初始化数据段(BSS)
未初始化数据段常被称之为BSS(英文名为Block start by symbol的缩写)。与读写数据段类似，它也属于静态数据区。但是该段中数据没有经过初始化。因此它只会在目标文件中被标识，而不会真正称为目标文件中的一个段，该段将会在运行时产生。未初始化数据段只有在运行的初始化阶段才会产生，因此它的大小不会影响目标文件的大小。三.在C语言的程序中，对变量的使用还有以下注意
1.在函数体中定义的变量通常是在栈上，不需要在程序中进行管理，由编译器处理。
2.用malloc，calloc,realoc等分配分配内存的函数所分配的内存空间在堆上，程序必须保证在使用后使用后freee释放，否则会发生内存泄漏。
3.所有函数体外定义的是全局变量，加了static修饰符后的变量不管在函数内部或者外部存放在全局区（静态区）。
4.使用const定义的变量将放于程序的只读数据区。
在C语言中，可以定义static变量：在函数体内定义
的static变量只能在该函数体内有效；在所有函数体外定义的static变量，也只能在该文件中有效，不能在其他源文件中使用；对于没有使用
static修饰的全局变量，可以在其他的源文件中使用。这些区别是编译的概念，即如果不按要求使用变量，编译器会报错。使用static
和没使用static修饰的全局变量最终都将放置在程序的全局去（静态去）。四.程序中段的使用
C语言中的全局区（静态区），实际上对应着下述几个段：
只读数据段:R0 Data
读写数据段：RW Data
未初始化数据段：BSS&Data
一般来说，直接定义的全局变量在未初始化数据区，如果该变量有初始化则是在已初始化数据区（RW Data）,加上const修饰符将放置在只读区域(R0 Data).
const&char ro[]=”this& is a readonlydata”;//只读数据段，不能改变ro数组中的内容，ro存放在只读数据段。
&char &rw1[]=”this
is&global readwrite data”;//已初始化读写数据段，可以改变数组rw1中的内容。应为数值是赋值不是把”this is&
global readwrite data” 地址给了rw1，不能改变”this is&global readwrite
data”的数值。因为起是文字常量放在只读数据段中
char&&bss_1[100];//未初始化数据段
const&char& *ptrconst =
“constant data”;//”constant&
data”放在只读数据段，不能改变ptrconst中的值，因为其是地址赋值。ptrconst指向存放“constant
data”的地址，其为只读数据段。但可以改变ptrconst地址的数值，因其存放在读写数据段中。
int&main()
&&&&&&&& short&//b放置在栈上，占用2个字节
&&&&&&&& char&& a[100];//需要在栈上开辟100个字节，a的值是其首地址
chars[]=”abcde”;//s在栈上，占用4个字节，“abcde”本身放置在只读数据存储区，占6字节。s是一个地址常量，不能改变其地址数值，即s++是错误的。
&&&&&&&& char*p1;//p1在栈上，占用4个字节
&&&&&&&& char*p2 =”123456”;//”123456”放置在只读数据存储区，占7个字节。p2在栈上，p2指向的内容不能更改，但是p2的地址值可以改变，即p2++是对的。
&&&&&&&& static& char&bss_2[100];//局部未初始化数据段
&&&&&&&& static& int&& c=0 ;//局部（静态）初始化区
&&&&&&&& p1 = (char *)malloc(10*sizeof(char));//分配的内存区域在堆区
&&&&&&&& strcpy(p1,”xxx”);//”xxx”放置在只读数据存储区，占5个字节
&&&&&&&& free(p1);//使用free释放p1所指向的内存
&&&&&&&& return 0;
1.只读数据段需要包括程序中定义的const型的数据
（如：const& char ro[]）,还包括程序中需要使用的数据如“123456”。对于const& char
ro[]和const&char * ptrconst的定义，它们指向的内存都位于只读数据据区，其指向的内容都不允许修改。区别在于前者不允许在程序中修改ro的值，后者允许在程序中修改ptrconst本身的值。对于后者，改写成以下的形式，将不允许在程序中修改ptrconst本身的值：
&&&&&&&&&&&&&&&&&& const& char * const&ptrconst =& “const& data”;
2.读写数据段包含了已经初始化的全局变量static& char&rw1[]以及局部静态变量static char
rw2[]。rw1和rw2的差别在于编译时，是在函数
内部使用的还是可以在整个文件中使用。对于前者，static修饰在于控制程序的其他文件时候可以访问rw1变量，如果有static修饰，将不能在其他
的C语言源文件中使用rw1，这种影响针对编译-连接的特性，但无论有static，变量rw1都将被放置在读写数据段。对于后者rw2,它是局部的静态
变量，放置在读写数据区；如果不使用static修饰，其意义将完全改变，它将会是开辟在栈空间局部变量，而不是静态变量。
3.未初始化数据段，事例1中的bss_1[100]和
bss_2[200]在程序中代表未初始化的数据段。其区别在于前者是全局的变量，在所有文件中都可以使用；后者是局部的变量，只在函数内部使用。未初始
化数据段不设置后面的初始化数值，因此必须使用数值指定区域的大小，
编译器将根据大小设置BBS中需要增加的长度。
4.栈空间包括函数中内部使用的变量如short b和char& a[100]，以及char *p1中p1这个变量的值。
1》变量p1指向的内存建立在堆空间上，堆空间只能在程序内部使用，但是堆空间(例如p1指向的内存)可以作为返回值传递给其他函数处理。
2》栈空间主要用于以下3类数据的存储：
a.函数内部的动态变量
b.函数的参数
c.函数的返回值
3》栈空间主要的用处是供函数内部的动态变量使用，变量的空间在函数开始之前开辟，在函数退出后由编译器自动回收
4.看一个事例：
#include&stdio.h&
int main()
&&&&&&&& char*p =”tiger”;
&&&&&&&& p[1]=’I’;
&&&&&&&& p++;
&&&&&&&& printf(“%s\n”,p);
编译后提示：段错误
=”tiger”;系统在栈上开辟了4个字节存储p的数值。”tiger”在只读存储区中存储，因此”tiger”的内容不能改
变，*p=”tiger”，表示地址赋值，因此，p指向了只读存储区，因此改变p指向的内容会引起段错误。但是因为p是存放在栈上，因此p的数值是可以改
变的，因此p++是正确的。五.const的使用
const是一个C语言的关键字，它限定一个变量不允许被改变。使用const在一定程序上可以提高程序的健壮性，另外，在观看别人代码的时候，清晰理解const所起的作用，对理解被人的程序有所帮助。
2.const变量和 常量
（1）const修饰的变量，其值存放在只读数据段中，起值不能被改变。称为只读变量。
其形式为 const& int&a=5;此处可以用a代替5.
（2）常量：其也存在只读数据段中，其数值也不能被改变。其形式为”abc”,5.
3.const 变量和const限定的内容
先看一个事例：
#include&stdio.h&
typedef&& char *pS
&&&&&&&& char&&&&&& string[6] = “tiger”;
&&&&&&&& const &&&&& char*p1 =
&&&&&&&& const&&&pStr& p2 =
&&&&&&&& p1++;
&&&&&&&& p2++;
&&&&&&&& printf(“p1=%s\np2=%s\n”,p1,p2);
程序经过编译后，提示错误为
error:increment& of&read-only& variable ‘p2’
1&const 使用的基本形式为：const&
限定m 不可变
2&替换1式中的m,const&char *
限定*pm不可变，当然pm是可变的，因此p1++是对的。
3&替换1式中的char,const&newT
限定m不可变，问题中的pStr是一种新类型，因此问题中p2不可变，p2++是错误的。
（3）const 和指针
类型声明中const用来修饰一个常量，有如下两种写法：
1&const在前面
const& int&& nV//nValue是const
const&char& *pC//*pContent是const,pConst可变
const&(char *)pC//pContent是const,*pContent可变
char& *const& pC//pContent是const,*pContent可变
const&char * const& pC//pContent和*pContent都是const
2&const 在后面与上面的声明对等
int const nValue；&// nValue是const
&&char const * pC//*pContent是const,&&&&pContent可变
&&(char *) constpC//pContent是const,&&&&*pContent可变
&&char* const pC// pContent是const,&&&&&*pContent可变
&&char const* const pC//pContent和*pContent都是const
说明：const和指针一起使用是C语言中一个很常见的困惑之处,下面是两天规则：
（1）沿着*号划一条线，如果const位于*的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；如果const位于*的右侧，const就是修饰指针本身，即指针本身是常量。你可以根据这个规则来看上面声明的实际意义，相信定会一目了然。
（2）对于const (char *) ;&因为char *是一个整体，相当于一个类型(如char)，因此，这是限定指针是const。
喜欢该文的人也喜欢MDK编译 STM32 的代码 把数组定义成 const 定义的空间 也能进行读写？？？_百度知道
MDK编译 STM32 的代码 把数组定义成 const 定义的空间 也能进行读写？？？
答题抽奖
首次认真答题后
即可获得3次抽奖机会，100%中奖。
你好：可以进行读，但是不能写。你的测试代码最好简单明了，这样能完全反应问题。而且据我所知，定义为const的话，你在程序代码中进行了写的操作，连编译都不会通过的。希望我的回答能帮助到你。
采纳率：90%
来自团队：
我也觉得不行 但是测试怎么可以呢
为您推荐：
其他类似问题
const的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。
