字面常量

一、常量包括字面常量，符号常量，契约型常量，枚举常量这几种类型。

字面常量包括：整形常量，字符型常量，字符串常量。注意：不存在数组常量，结构体常量等结构型的字面常量。但是存在结构型的符号常量。

字面常量的种类：

（1）整形

整形数值 默认是int型，例如：22,33

如果要表示一个long型，则加 l、L后缀。例如：22L、33L

（2）浮点型

浮点数默认是双精度dobule型的。例如：33.3

如果要表示单精度浮点型，加f、F后缀。例如：33.3F

（3）字符串型

包含在双引号""中的字符序列，是字符串。例如：“hello，world”

（4）字符型

用单引号''包含，或者用/转义的字符，是字符型。例如：/n、'a'

转载于:https://www.cnblogs.com/prayer521/p/6277101.html

常量：C++包括两种常量，字面常量和符号常量.

 

字面常量：指的是直接输入到程序中的值

比如：in myAge=26； myAge是一个int类型变量，而26是一个字面常量。

符号常量：指的是用名称表示的常量，就像变量一样表示，但是一旦初始化，其值就不能改变.

主要指的是：

①const定义的常量：const unsigned short int studentPerClass=15;这里的studentPerClass就是一个符号常量

②使用#include定义的常量：#define studentPerClass 15 这里的studentPerClass也是一个符号变量

 

枚举常量

枚举常量可以创建一个新类型，然后定义新的类型变量，将这些变量的取值定义为一组可能值。

定义方法：  enum COLOR {RED,BLUE,GREEN,WHITE,YELLOW};

该语句执行后有两个变化：

１）COLOR成为枚举的名称，成为一种新类型

２）如果没有特殊说明，默认枚举中标示符的内容为从0开始递增的整形常数，即RED=0，BLUE=1，GREEN=2，WHITE=3，YELLOW=4

当然也可以自己定义枚举值：

enum COLOR {RED=100,BLUE=200,GREEN=300,WHITE=400,YELLOW=500};

关于枚举的几点说明：

①枚举值是常量，不是变量。不能在程序中用赋值语句再对它赋值。

②只能把枚举值赋予枚举变量，不能把元素的数值直接赋予枚举变量。

转载于:https://www.cnblogs.com/clemente/p/10756804.html

 

 

变量：

    int i = 0;  // i 是变量

    i=5;         //i 可以修改

 变量就是程序内一个内存位置的符号名，在该内存位置可以保存数据，并可以通过符号名对该内存地址存放的数据进行访问。

变量的值可以修改，是可变的，但在某个确定的时刻，变量的值是确定的，并一直保持到下次被修改之前。

 

常量：

    int a=10;       //a 是变量， 10 是常量，也是整形常量
    double  b= 3.5;  //b是变量， 3.5 这个数是常量，也叫浮点型常量
    char c= 'A' ;  //c是变量，  ‘A’ 是字符常量
    std::string  str ="1234";   // str 是变量， “1234”是字符串常量

    上面这四种常量都叫做普通常量，也称之为字面值常量。

    字面值常量在程序中是直接表示的，整型直接写出大小，字符直接写出字符 ,如上面的10 和 ‘A ’
    一个字面值常量在编译时被直接解析为立即数，编译器内部维护字面值常量的类型,

以前一直以为const修饰的变量是常量，既对，也错，应该称为  符号常量

    const int   i = 10 ; // i 是const 修饰的，i本身是变量， 但是被const 修饰后变成了符号常量，不可修改

    //当然，10 还是常量，也是字面值常量 ，而 i  是符号常量，和普通常量不一样的是，符号常量有一个名称，既i ， 而普通常量也就是字面值常量是没有名称的

 

符号常量的定义的两种方式：#define  和const

    #define A 10  

    const int B=10;

不同之处在于:
a. 宏定义: 由预处理处理,单纯的是纯文本替换。
b. const常量: 由C++编译器处理,提供类型检查和作用域检查。

ps：建议把常量定义为大写形式

 

常量存储在什么地方：

一个由C/C++编译的程序占用的内存分为以下几个部分
1、栈区（stack）— 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。
2、堆区（heap） — 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收
3、全局(静态)区（static）：
全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 - 程序结束后有系统释放
4、文字常量区 —常量字符串就是放在这里的。 程序结束后由系统释放
5、程序代码区—存放函数体的二进制代码。

例子程序:
//main.cpp：

#include<iostream>
using namespace std;
 
int a = 0;                                 全局(静态)初始化区
char *p1;                                 全局(静态)未初始化区

int  main()
{
    int b=10;                             b在栈 ，10呢？10没有存在任何地方，编译器在指令中直接把10作为立即数赋值给了b
    char *p2;                            栈
    char *p3 = "123456";         "123456"在常量区，p3在栈上。
    p1 = (char *)malloc(10);     分配得来10字节的区域在堆区
    strcpy(p1, "123456");         "123456"放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方
}

 

重点有两个：
1.为什么  int b=10;   10这个常量 没有放在文字常量区，不是说常量都放在这里吗？

这是因为编译器认为普通的整型、浮点型或字符型常量在使用的时候是可以通过立即数来实现的，没有必要额外存储到数据区，如此节省了存储空间和运行时的访问时间

2.那么什么样的数据才将放入常量区呢?
第一就是”12345“ 这样的字符串常量，但是要除掉字符数组赋值的常量
第二就是被const修饰的全局变量

除了字符串之外，其他常量也可以放在常量区，但是前提是该数据必须被存放在全局变量的空间里，并且被const关键字修饰。如下：

    #include<iostream>
    using namespace std;
     
    const int v0=5;        //5这个常量在常量区，因为是全局const, v0在全局(静态)初始化区
    const char c='t';      //'t'这个常量在常量区，因为是全局const, c在全局(静态)初始化区
    int v1=6;              //6这个常量是立即数，没有存在任何地方 ,v1在全局(静态)初始化区
     
    int main()
    {
        const int x=0;        //'0'这个常量也是立即数，因为不是全局的，x则在栈中
        double x=10;          //'10'这个常量也是立即数，x则在栈中
        string str="12345";   //"12345"在常量区，str在栈中
        char a[]="123";       //特殊，"123"也相当于立即数，没有村拽任何地方，a在栈中，保存了123
        return 0;
    }

至于为什么？要好好学习汇编，看看编译器到底做了什么？
参考：http://emb.hqyj.com/Column/Column540.htm
————————————————
版权声明：本文为CSDN博主「Bird鸟人」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/wcc27857285/article/details/84891952