精华内容
下载资源
问答
  • C++ 变量常量、符号常量
    千次阅读 多人点赞
    2018-12-08 15:13:52

    变量:

    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

     

    更多相关内容
  • C++ 变量和常量

    千次阅读 2018-03-14 20:36:17
    一、变量程序运行时,所需的数据要放在内存值才能使用,内存被格式化成一个个小的存储单元,数据保存在这些存储单元中。这些存储单元被编上序号(内存地址)。高级语言设计的程序不能直接通过地址来访问所保存的数据...

    一、变量
    程序运行时,所需的数据要放在内存值才能使用,内存被格式化成一个个小的存储单元,数据保存在这些存储单元中。
    这些存储单元被编上序号(内存地址)。
    高级语言设计的程序不能直接通过地址来访问所保存的数据、向单元中写数据。
    为了访问这些数据,必须给内存中的存储区域命名,用标识符来标志它。
    存储区域存放的数据可以读取、修改、写入,则此标识符被称为变量。
    变量不仅向编译器宣告变量的存在,同时为它分配所需的存储空间。
    变量的类型决定类怎么去理解和操作该变量和该变量所对应的数据,
    变量名为程序提供了内存块的首地址和操作它的媒介。
    编译时,编译器把该名字与其对应的存储区块的地址一起放到符号表中,当需要访问该变量时,编译器就到符号表中去查找。

    变量的声明
    变量声明:只是向编译器说明将有一个变量存在,而不为它分配所需的存储空间,仅起占位符的作用。
    格式: extern type var1,var2,…;
    extern 是 C++ 的关键字,表示定义的变量是 “外部”(要么中另一个文件中,要么在本文件后面某处)的,
    使用关键字 extern 声明一下变量,可以先使用后定义,可以避免编译时报告变量不存在的错误。

    注:
    1、因为变量的声明并没有给变量分配存储空间,所以不能在声明时给它赋初值,因为它实际上还不存在。
    2、如果用 extern 声明类某个变量,则必须确保这个变量真的存在于 “外部” 中,并被 #include 指令包含进来,或真的存在于本文件后面某处。

    例:
    创建 test.cpp 文件:
    #include
    using namespace std;
    #include “test.h”
    extern int a;
    extern int b;
    int main(void)
    {
    int c = 2; //定义变量 c
    cout << “a = ” << a <<endl; //变量 a 时声明,在另一个文件内
    cout << “b = ” << b <<endl; //变量 b 是声明,在本文件后面
    cout << “c = ” << c <<endl; //变量 c 是定义
    return 0;
    }
    int b = 1; //定义变量 b
    创建 test.h 文件,并放在 test.cpp 同一目录下:
    #include
    using namespace std;
    int a = 3;
    然后 gcc test.cpp 即可

    变量的存储
    变量的存储:变量从哪里得到保存数据所需的内存空间,以变量的定义方式而定。
    1、如果变量定义在函数体内,且无 static 修饰,则该变量将从堆栈中得到存储空间。当程序执行进入函数后,才为变量分配存储空间。退出后,自动释放分配的空间。
    2、如果变量定义时被 static 修饰,则无论是在函数体内,还是函数体外,都将从全局空间中得到存储空间。
    3、如果变量定义在函数体外,则在全局内存空间中得到存储空间。

    例:
    #include
    using namespace std;
    double d1,d2; //定义变量 d1 和 d2
    static int s1; //定义静态变量 s1
    int main(void)
    {
    static char ch; //定义静态变量 ch
    int s2; //定义变量 s2
    d1 = 3.14; //使用在 main() 外部定义的变量
    d2 = d1;
    d1 = d1 + d2;
    s1 = 10; //使用在 main() 外部定义的静态变量
    ch = ‘a’; //使用在 main() 内部定义的静态变量
    s2 = 1;
    return 0;
    }

    注:
    变量 d1、d2、s1 定义在函数体内,所以存储于全局内存中,
    ch 虽然定义函数体内,但有关键字 static 修饰,所以也放在全局内存中,
    s2 在函数体内定义又无 static 修饰,所以将从堆栈中得到存储空间。

    每一个变量,都有两个信息与其相关联:
    数据值(右值):变量的数据值就是存储在变量对应的存储单元中的数据。右值意指被读取,既在赋值运算符的右边,代表的是数据。
    地址值(左值):变量的地址值就是变量对应的存储单元的首地址。左值意指被写入,既在赋值运算符的左边,代表的是地址。

    按变量的作用域划分
    1、局部变量(自动变量):在函数内部或函数参数中定义,存储在堆栈中,在程序进入函数时才分配空间,退出时就释放。不同的函数内可以有相同名称的局部变量。
    2、全局变量:定义在函数外部,存储在固定的存储区域内,具体由编译器来决定,在程序的生存期内都有效,除非手工释放,否则直到程序运行结束才释放所占空间。全局变量绝不重名。

    按变量的存储位置划分
    1、全局空间变量:就是全局变量,存储在某一固定区域内,全程有效,用 extern 关键字声明的变量属于全局空间变量的一种。
    2、堆栈空间变量:就是局部变量,存储在函数自有的堆栈空间内。
    3、寄存器变量:数据保存在 CPU 的寄存器内的变量,用关键字 register 说明,也是局部变量,仅限于整型和字符型。操作速度快,但不能定义太多,也不能长久占据。

    按变量的存储方式划分
    1、静态变量:用关键字 static 说明,在程序所占据的数据段(Data Segment,在内存中某处保留的一段大小固定的空间)内分配永久存储空间,整个执行过程中都不释放。静态变量分为:
    1.1、静态局部变量:只在定义它的函数或语句块内有效,只在第一次调用时定义,以后每次调用函数时都不再重新定义,仍然保留上次函数调用结束时的值(静态局部变量时有记忆的)。
    1.2、静态全局变量:只在定义它的文件内全程有效,在整个运行期间均存在并且保持原来的存储单元位置不变,因此不能用 extern 关键字从其他文件中引用静态全局变量。
    2、动态变量:用关键字 auto 说明,且 auto 一般省略,自动变量的赋值时在函数调用时进行的,每调用一次就重新赋值一次。

    例:
    int a = 100 ; //定义变量 a
    extern int b ; //引入外部变量 b
    static int c ; //定义静态变量 c
    extern int d ; //引入外部变量 d
    int main(void)
    {
    register int g = 100 ; //定义寄存器变量 g
    cout << “g = ” << g << endl ;
    cout << “d = ” << d << endl ;
    cout << “a = ” << a << endl ;
    return 0 ;
    }
    int d = 100 ;
    注:
    a 是全局变量,可以被引出到其他文件中,
    b 是从外部引入的,也是全局变量,
    c 是静态全局变量,只在本文件内有效,不能引出到其他文件中,
    d 是用 extern 声明的全局变量,其定义在 main() 函数后,
    g 是寄存器变量。

    变量初始化:
    变量被定义后,就在内存中给它分配类一块存储单元,用于存放数据,他可能包含预料不到的数据(曾经存储在其中过的数据)。
    因此直接使用而不初始化的话,可能会数据越界、堆栈溢出等。
    注:
    一般编译器会默认给没初始化的变量 0(int、float型时)或 NULL(字符型时)

    二、常量

    1、符号常量:用标识符代替程序中保持不变的数据,用 #define 来说明,属于宏定义的范畴。
    格式:#define NAME expression
    例:
    #define _PI_ 3.1415926
    #define e 2.71828
    #define MAX (100+1) //加括号时 2*MAX=202 ; 不加括号时 2*MAX=201
    注:
    1、末尾不加分号
    2、定义的常量没有类型,内存中不存在以符号常量命名的存储单元,因此不能进行类型检查
    3、给出的时立即数,不可寻址,预处理时直接进行替换,因此出现几次就有几个副本
    4、运行时常量表中没有用 #define 定义的常量,因此系统不会给它分配内存,但它的副本会占据内存
    5、它定义的常量是全局的,全程有效
    6、当 expression 中有运算时,必须加 (),不然会出逻辑问题。因为 #define 定义的常量是宏,完成的是直接宏替换。
    7、用 #define 说明的常量可以用 #undef 指令取消
    8、实现的是符号到值的替换,并没有给它分配任何存储空间,定义时符号的值必须确定,不存在初始化的说法

    2、常变量:内容不变的变量,在变量的定义前面加 const 修饰符即可。只能赋一次值,不能修改,具有变量的一切性质。
    格式:const type var=value;
    注:
    1、它有类型,便于编译器进行类型检查
    2、可以寻址,即使出现多个副本,只需分配一次空间
    3、可以在任何地地方定义常量,编译器像对待变量一样处理它,只是分配内存的地方不同而已
    4、在内存中存在着以它命名的存储单元,除非在语句中出现,否则编译时不会为它分配空间
    5、一旦定义完就不能修改,所以必须赋初值,且一定要在定义语句中赋值(唯一的初始化机会)
    6、程序运行时,它被记录在专门的常量表中
    7、常变量在静态区分配存储空间,不像变量时在堆栈中

    用 const 说明常量有两点好处:
    1、如果编译程序知道一个变量的值不会改变,就会在编译时对它进行优化
    2、编译程序会力图保证该变量的值不会因为程序员的疏忽而被改变

    1、#define 定义的符号常量才是真正意义上的常量,其目的就是为了用标识符代替一个不变的常量,
    2、const 说明的常变量,更多的目的时为了保护和优化
    3、#define 时 C 语言中采用的方法, C++ 更多用的时 const 定义常变量,C++ 保留 #define 以兼容 C,推出 const以替代 #define

    有些调试工具可以调试常变量,不能调试符号常量,
    因为符号常量在编译时就进行了符号到数据的替换,编译后,符号常量已不存在,取而代之的是它所保存的常数。

    除了在定义时,否则不能将 const 修饰的对象、引用和指针作为赋值表达式的左值,即不能出现在赋值运算符的左边

    展开全文
  • C++变量常量

    2018-05-28 20:56:40
    1. 关于全局变量全局变量一旦定义好,则可以在整个程序任何地方引用,包括main函数与自己定义的其他函数;...运行结果:这里的24都指的是字节数,也就是说int占四个字节,也就是32个bit,那他的长度就是 0...

    1. 关于全局变量

    全局变量一旦定义好,则可以在整个程序任何地方引用,包括main函数与自己定义的其他函数;但切记,全局变量不能随便用,因为他哪里都能用,很可能造成这个变量的值各种来回变。


    2. 关于数据类型的长度:

    可以用sizeof这个函数来查看,具体方法:


    任何类型的数据,都可以用这个函数进行查看。

    运行结果:


    这里的2和4都指的是字节数,也就是说int占四个字节,也就是32个bit,那他的长度就是 0~ 2^16。


    3. 枚举的定义:

    要在main之前定义,枚举是在定义自己独特的数据类型,已经确定这个数据类型里面的数据范围;


    这个程序中,就是定义了一个MyFruit的数据类型,它的数据范围包括四个,在main中我也可以定义MyFruit类型的变量,并给他赋值;

    值得注意的是,枚举中的第一个数据需要赋初值,之后的数据依次加一!

    更值得注意的是,这里面这个  Myfruit whatHeLike = Apple 的写法不对!!!赋初值应该写成 int whatHeLike = Apple!!切记

    展开全文
  • ’’,“c++” cout << 2020; 常量:不能改变的量 字面常量(字面量,直接常量):直接写出的数据 符号常量:用符号表示数据,但它一旦确定了表示那个数据,以后它不再改变 ①符号常量 说明一个符号表示常量 ⚮ ...
  • 1.认识临时变量常量性 关于临时变量常量性,先看一段代码。 void print(string& str) { cout<<str<<endl; } //如此调用会报编译错误 print("hello world"); 在Linux环境使用g++编译,会出现: ...
  • c++入门基础知识——常量和变量

    热门讨论 2022-04-23 09:34:45
    想学习c++的朋友可以来关注一下a,从入门的知识开始。

    系列文章目录

    提示:这里可以添加系列文章的所有文章的目录,目录需要自己手动添加
    例如:第一章 Python 机器学习入门之pandas的使用


    提示:写完文章后,目录可以自动生成,如何生成可参考右边的帮助文档


    前言

    前面我们了解了c++的数据类型,下面来学习c++中变量和常量。

    提示:以下是本篇文章正文内容,下面案例可供参考

    一、什么是常量和变量?

    常量是程序运行中其值始终保持不变的量,根据常量的类型,可以分为整形常量,实型常量,字符常量和字符串常量,逻辑常量。
    注意:常量可以带后缀,如123u,1.23f和123ll,分别表示无符号整形常量,单精度常量,长长整形。

    二、常量

    1.常量的种类

    在这里插入图片描述

    代码如下(示例):

    2.代码演示——常量的输出和定义。

    c++:
    在这里插入图片描述
    c语言:
    在这里插入图片描述

    代码如下(示例):

    c++语言:
    #include<iostream>
    #include<iomanip>//控制符头文件;
    using namespace std;
    int main(void)
    {
    	const double pi = 3.141592653589793;//关键字const定义常量,和c语言中的宏作用结果相同。
    	cout << pi << endl;
    	cout << fixed << setprecision(2) << pi << endl;
    	cout << fixed << setprecision (5)<< pi<<endl;
    }
    
    
    c语言:
    #include<stdio.h>
    #define pi 3.141592653589793
    int main(void)
    {
    	printf("%f\n", pi);
    	printf("%.2f\n", pi);
    	printf("%.3f\n", pi);
    }
    
    
    

    上面两个例子可以看出,cout输出时默认保留6位有效位,printf输出时默认保留6位小数位;在c++语言中,如果要对数据进行取舍处理,则要用到cout<<fixed<<setprecision(int n)<<m<<endl;格式,其中m是变量,n是要保留的小鼠位数;

    3.oj题中保留小数的题目(简单)。

    在这里插入图片描述
    代码演示:

    #include<iostream>
    #include<iomanip>
    using namespace std;
    int main(void)
    {
    	double a, b, c;
    	double s;
    	cin >> a >> b >> c;
    	s = (a + b + c) / 3;
    	cout << fixed << setprecision(1) << s << endl;
    }
    

    三、变量

    1.变量的定义

    变量是程序运行中其值可以改变的量,变量需要指定数据类型,变量由变量名,变量值组成。

    2.变量的使用

    在这里插入图片描述
    变量的值可以随意改变,例如,输入两个数,要求输出这两个数的值,然后将他们的值对调输出:

    
    #include<iostream>
    #include<iomanip>
    using namespace std;
    int main(void)
    {
    	int a, b;
    	cin >> a >> b;
    	swap(a, b);//swap函数是c++中的库函数,用来交换两个变量的值;后面学到会讲;
    	cout << a << b;
    }
    

    在c++语言中定义变量的时候,不是简简单单定义a,b,c等字符,要做到见名知意,这里为了方便教学,就用字符代替。

    总结

    提示:这里对文章进行总结:

    以上就是今天的内容,学习了c++中的数据类型和变量,常量。后面将会学习c++中的运算符,比较适合刚入门的小白。

    展开全文
  • 2)赋值函数中不能赋值,起到保护常量数据成员的作用,友元作用相反。 2.常量成员函数,形式:type funname(type1 arg1,type2 arg2,…) const 1)常量成员函数,不能修改类数据成员,不能调用非常量函数。 2)常量...
  • C++中,要定义一个常量,有两种主要的做法  1. 符号常量 (#define)  2. 常值变量 (const)  符号常量的定义方式,其实与C++本身没有关系,它是一个编译器指令,或者称为预处理指令(有关的预处理指令还有#...
  • C++ 全局变量和全局静态变量的根本区别还是作用域的区别</span></strong></em> 1.全局变量是不显示用static修饰的全局变量,但全局变量默认是静态的,作用域是整个工程,在一个文件...
  • 一.基本概念: (1)变量:顾名思义,就是值可以改变的量。 作用:给一段指定的内存空间起名,方便操作这段内存。 语法:数据类型 变量名 = 初始值 ... #define 宏常量:#define 常量常量值 b. const...
  • C和C++中全局变量,局部变量,静态变量和常量

    万次阅读 多人点赞 2016-08-14 22:54:15
    C/C++常量,静态变量,全局变量和局部变量的区别作用。把局部变量改变为静态局部变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态全局变量是改变了它的作用域, 限制了它的使用范围。因此...
  • 函数或变量在声明时,并没有给它实际的物理内存空间,它有时候可以保证你的程序编译通过, 但是当函数或变量定义的时候,它就在内存中有了实际的物理空间与区别。
  •  (2) 类型安全检查不同  define宏没有类型,不做任何类型检查,仅仅是展开。  const常量有具体的类型,在编译阶段会执行类型检查。  (3) 存储方式不同  define宏仅仅是展开,有多少地方使用,展开多少次...
  • C++学习笔记(一):变量常量和命名规则 变量 变量的意义:方便管理内存空间 变量语法:数据类型 变量名 = 变量初始值; 常量 常量的意义:用于记录程序中不可更改的数据 常量的语法: 宏常量:#define 常量名 ...
  • 现在我有四个变量,但是我想用这几个数字使用switch..case,有什么办法 可以将这四个变量转化为四个常量吗?![图片说明](https://img-ask.csdn.net/upload/202005/11/1589194364_357321.png)
  • 计算机二级C语言变量和常量知识点

    千次阅读 2021-05-20 05:13:40
    计算机二级C语言变量和常量知识点C语言的运算符包含的范围很广泛,共有34种运算符。C语言把括号、赋值、强制类型转换等都作为运算符处理。下面是关于计算机二级C语言变量和常量知识点,希望大家认真阅读!一、变量(一...
  • C++ 临时变量常量

    千次阅读 多人点赞 2015-08-25 09:55:18
    Linux环境运行,使用g++编译,观察如下代码,会出现: invalid initialization of non-const reference of type ‘std::...其中文意思为临时变量无法为非const的引用的初始化。也就是在参数传递的过程中,出现错误。
  • C++类的常量和静态

    2020-01-10 12:52:00
    常量成员有常量属性和常量函数;静态成员有静态属性静态函数。 常量成员 常量属性(在声明最前面加const):要在初始化列表初始化,然后不能再次更改其的值,也就是该属性为常量常量函数(在声明最后面加const...
  • C++变量 变量:给一段指定的内存空间起名,方便操作这段内存。 变量存在的意义:方便我们管理内存空间。 常量:用于记录程序中不可更改的数据。 C++中定义常量的两种方式: #define宏常量: 通常在文件上方定义,...
  • C/C++中指针常量和常量指针用法及区别 前言 指针是一种特殊的变量,指针的值为内存地址。 一、基本概念 1、指针常量:指针常量就是指针本身是常量,换句话说,就是指针的值(内存地址)是常量,不能改变。但是,...
  • c++常量和常量表达式

    千次阅读 2019-08-03 18:49:31
    const引用:对常量的引用不能被用作修改它所绑定的对象 const int ci(5); const int &rci(ci); rci = 90;//错误 不能修改 允许常量引用绑定到非常量的对象、字面值或表达式上 int i = 20; const int &...
  • C++常量转换

    千次阅读 2020-04-22 10:13:08
    先看如下代码 const int * p = NULL;...newp中保存的地址p中保存的地址完全一样,唯一区别是,newp不再是一个常量指针了。 常量转换,第二层含义是,将非常量转化为常量,具体代码如下 int * p...
  • C++ 常量表达式 常量值是指不会更改的值。C + + 提供了两个关键字,它们使你能够表达不打算修改对象的意图,还可让你实现该意图。 C++ 需要常量表达式(计算结果为常量的表达式)以便声明: 数组边界 case 语句中...
  • 1初识c++ 1.1变量 作用:给一段指定的内存空间起名,方便操作这段内存 语法:数据类型 变量名 = 初始值; 实例: #include <iostream> using namespace std; int main() { 数据类型 变量名 = 初始值; int ...
  • 指针是一种特殊的变量,它里面存储的内容是内存地址。常量是指其里面存储的内容不能发生改变的量。明白了这两个概念后,我们现在正式进入指针常量常量指针。 1.指针常量常量指针的概念 指针常量就是指针本身是...
  • 背景: 我在大学学过C++,没有学C。 到了公司,只能用C从事开发,虽然感觉C++应该都...在C++中,常量包括字面值只读变量: int a=12345; const int b=123; 这里,12345是字面值,a是变量,b是只读变量。 12.
  • 最近复习C++的一些知识,遇到了一个我比较容易混淆、傻傻分不清的知识点,那就是C++变量的类型初始化或赋初值,大致有普通成员变量、静态成员变量、成员常量这三种,还有一种组合的静态成员常量。 看到这几种数据...
  • 变量和常量的区别

    万次阅读 多人点赞 2018-07-04 22:11:09
    常量和变量就是在内存中做数据交换的一个过程。 1.常量 常量指的是在程序运行期间不变的数据,常量又分为直接常量和符号常量。 直接常量:  例如: 整数常量:24小时,365天 小数常量:圆周率3.14 字符:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 218,645
精华内容 87,458
关键字:

c++变量和常量

c++ 订阅