精华内容
下载资源
问答
  • c语言常量和变量有什么区别c语言常量 常量是固定值,在程序执行期间不会改变。这些固定值,又叫做字面量。常量可以是任何基本数据类型,比如整数常量、浮点常量、字符常量,或字符串字面值,也有枚举常量。 ...
  • 变量的定义声明的区别: 4.C 语言中的左值(Lvalues)右值(Rvalues) 5.变量的内存寻址(与系统有关) 二:C语言中的常量 1.常量的定义 2.整数常量 整数常量的实例: 各种类型的整数常量的实例: 3.浮点...

    目录:

    一:C语言中的变量

    1.变量的定义

    举例:

    2.变量初始化

    举例:

    3.变量声明

    举例:

    变量的定义和声明的区别: 

    4.C 语言中的左值(Lvalues)和右值(Rvalues)

    5.变量的内存寻址(与系统有关)

    二:C语言中的常量

    1.常量的定义

    2.整数常量

    整数常量的实例:

    各种类型的整数常量的实例:

    3.浮点常量

    浮点常量的实例:

    4.字符常量

    转义序列码:

    5.字符串常量

    举例:

    6.定义常量

    1.定义常量的方式

    2.#define 预处理器

    实例:

    3.const 关键字

    实例:

    4.const和define 的区别

    (1) 编译器处理方式不同

    (2) 类型和安全检查不同

    (3) 存储方式不同

    (4) const 可以节省空间,避免不必要的内存分配

    举例:

    (5) 提高了效率

    (6) 宏替换只作替换,不做计算,不做表达式求解


    一:C语言中的变量

    变量的名称可以由字母、数字和下划线字符组成

    它必须以字母或下划线开头

    写字母和小写字母是不同的,因为 C 是大小写敏感的。

    1.变量的定义

    type variable_list;

    解释:

    type 必须是一个有效的 C 数据类型,可以是 char、w_char、int、float、double 或任何用户自定义的对象

    variable_list 可以由一个或多个标识符名称组成

    多个标识符之间用逗号分隔。

    举例:

    int    i, j, k;
    char   c, ch;
    float  f, salary;
    double d;

    2.变量初始化

    type variable_name = value;

    举例:

    extern int d = 3, f = 5;    // d 和 f 的声明与初始化
    int d = 3, f = 5;           // 定义并初始化 d 和 f
    byte z = 22;                // 定义并初始化 z
    char x = 'x';               // 变量 x 的值为 'x'

    3.变量声明

    变量的声明有两种情况:

    • 1、一种是需要建立存储空间的

    例如:int a 在声明的时候就已经建立了存储空间。

    • 2、另一种是不需要建立存储空间的,通过使用extern关键字声明变量名而不定义它。

    例如:extern int a 其中变量 a 可以在别的文件中定义的。

    • 除非有extern关键字,否则都是变量的定义。

    举例:

    extern int i; //声明,不是定义
    int i; //声明,也是定义

    如果需要在一个源文件中引用另外一个源文件中定义的变量,我们只需在引用的文件中将变量加上 extern 关键字的声明即可。

    变量的定义和声明的区别: 

    变量定义:用于为变量分配存储空间,还可为变量指定初始值。程序中,变量有且仅有一个定义

    变量声明:用于向程序表明变量的类型和名字

    定义也是声明:当定义变量时我们声明了它的类型和名字

    extern 声明不是定义:通过使用 extern 关键字声明变量名而不定义它。

    [注意]

    变量在使用前就要被定义或者声明。

    在一个程序中,变量只能定义一次,却可以声明多次。

    定义分配存储空间,而声明不会。

    4.C 语言中的左值(Lvalues)和右值(Rvalues)

    C 中有两种类型的表达式:

     左值(lvalue):

    指向内存位置的表达式被称为左值(lvalue)表达式。

    左值可以出现在赋值号的左边或右边

     

     右值(rvalue):

    术语右值(rvalue)指的是存储在内存中某些地址的数值

    右值是不能对其进行赋值的表达式,也就是说,右值可以出现在赋值号的右边,但不能出现在赋值号的左边

    左值必须是变量

    右值可以是变量,常量或者表达式

    总结:

    •   当需要保存数据的时候,需要lvalues
    •   当需要读取数据的时候,需要rvalues

    lvalues 和 rvalues 角色的相互转换:

    1、 根据表达式的上下文情况,lvalues 在需要 rvalues 的地方会自动转换为 rvalues。例如:

    int n;
    
    int m;
    
    m = n+2; // 这个表达式里 n 是 rvalues

    2、 rvalues 永远不能转换为 lvalues

    5.变量的内存寻址(与系统有关)

    (1)内存寻址由大到小,优先分配内存地址比较大的字节给变量,所以说变量越先定义,内存地址就越大。 如下面代码,先定义变量 a,再定义变量 b,打印出 a 的地址是 0x7fff5fbff828,b 的值是 0x7fff5fbff824。a 的地址比 b 的地址大 4 字节。

    (2)变量地址的获取方式:& 变量名。

    (3)输出地址的方式:%p

    #include <stdio.h>  
      
    int main()   
    {  
          
        int a;  
        int b;  
      
        printf("a的地址是%p\nb的地址是%p\n",&a,&b);  
        return 0;  
         
    }  

    (4)一个变量一定要先初始化才可以使用,因为 c 语言中默认一个没有初始化的变量值是一个不可知的很大值。如下面所示,a 没有初始化,打印出 a 的值是 1606422582。

    #include <stdio.h>  
      
    int main()   
    {  
          
        int a;  
      
        printf("a的值是%d\n",a);  
        return 0;  
         
    }  

     

    二:C语言中的常量

    1.常量的定义

    常量是固定值,在程序执行期间不会改变。这些固定的值,又叫做字面量

    常量可以是任何的基本数据类型,比如整数常量、浮点常量、字符常量,或字符串字面值,也有枚举常量

    常量就像是常规的变量,只不过常量的值在定义后不能进行修改

    2.整数常量

    整数常量可以是十进制、八进制或十六进制的常量

    前缀指定基数0x 或 0X 表示十六进制,0 表示八进制

    不带前缀默认表示十进制

     

    整数常量也可以带一个后缀,后缀是 U 和 L 的组合:

    U 表示无符号整数(unsigned);

    L 表示长整数(long);

    后缀可以是大写,也可以是小写,U 和 L 的顺序任意。

    整数常量的实例:

    212         /* 合法的 */
    215u        /* 合法的 */
    0xFeeL      /* 合法的 */
    078         /* 非法的:8 不是八进制的数字 */
    032UU       /* 非法的:不能重复后缀 */

    各种类型的整数常量的实例:

    85         /* 十进制 */
    0213       /* 八进制 */
    0x4b       /* 十六进制 */
    30         /* 整数 */
    30u        /* 无符号整数 */
    30l        /* 长整数 */
    30ul       /* 无符号长整数 */

    3.浮点常量

    浮点常量由整数部分、小数点、小数部分和指数部分组成

    您可以使用小数形式或者指数形式表示浮点常量

     

    当使用小数形式表示时:必须包含整数部分、小数部分,或同时包含两者

    当使用指数形式表示时: 必须包含小数点、指数,或同时包含两者。带符号的指数是用 e 或 E 引入的。

    浮点常量的实例:

    3.14159       /* 合法的 */
    314159E-5L    /* 合法的 */
    510E          /* 非法的:不完整的指数 */
    210f          /* 非法的:没有小数或指数 */
    .e55          /* 非法的:缺少整数或分数 */

    4.字符常量

    字符常量是括在单引号中

    例如,'x' 可以存储在 char 类型的简单变量中。

     

    字符常量可以是一个普通的字符(例如 'x')、一个转义序列(例如 '\t'),或一个通用的字符(例如 '\u02C0')。

     

    在 C 中,有一些特定的字符,当它们前面有反斜杠时,它们就具有特殊的含义,被用来表示如换行符(\n)或制表符(\t)等。

    转义序列码:

    转义序列 含义
    \\ \ 字符
    \' ' 字符
    \" " 字符
    \? ? 字符
    \a 警报铃声
    \b 退格键
    \f 换页符
    \n 换行符
    \r 回车
    \t 水平制表符
    \v 垂直制表符
    \ooo 一到三位的八进制数
    \xhh . . . 一个或多个数字的十六进制数

    反斜杠(\) 开头是叫转义序列(Escape Sequence)。

     

    \ooo 是对用三位八进制数转义表示任意字符的形象化描述。

    比如 char ch = '\101'; 等价于 char ch = 0101; (以0开头的表示八进制)。

     

    \xhh 里面是 x 是固定的,表示十六进制(hexadecimal),h 也表示十六进制。

    举例,char ch = '\x41'; 就是用十六进制来表示,它与前面的 \101 是等价的。

     

    可用如下代码证明它们等价:

    #include <stdio.h>
      
    int main(){
        printf("%c,%c,%c,%c", 0101, '\101', '\x41', 'A');
        return 0;
    }

     

     

    5.字符串常量

    字符串字面值或常量是括在双引号 "" 中的

    一个字符串包含类似于字符常量的字符:普通的字符、转义序列和通用的字符。

    您可以使用空格做分隔符,把一个很长的字符串常量进行分行

    举例:

    下面这三种形式所显示的字符串是相同的 

    "hello, dear"
    
    "hello, \
    
    dear"
    
    "hello, " "d" "ear"

    6.定义常量

    1.定义常量的方式

    使用 #define 预处理器

    使用 const 关键字

    2.#define 预处理器

    定义常量的形式:

    #define identifier value

    实例:

    #include <stdio.h>
     
    #define LENGTH 10   
    #define WIDTH  5
    #define NEWLINE '\n'
     
    int main()
    {
     
       int area;  
      
       area = LENGTH * WIDTH;
       printf("value of area : %d", area);
       printf("%c", NEWLINE);
     
       return 0;
    }

    运行结果:

    value of area : 50

    3.const 关键字

    使用 const 前缀声明指定类型的常量:

    const type variable = value;

    实例:

    #include <stdio.h>
     
    int main()
    {
       const int  LENGTH = 10;
       const int  WIDTH  = 5;
       const char NEWLINE = '\n';
       int area;  
       
       area = LENGTH * WIDTH;
       printf("value of area : %d", area);
       printf("%c", NEWLINE);
     
       return 0;
    }

    运行结果:

    value of area : 50

    4.const和define 的区别

    const 定义的变量不是常量

    只是这个变量的值不允许改变是常变量!带有类型

    编译运行的时候起作用存在类型检查

    并不是去定义一个常量

    而是去改变一个变量的存储类,把该变量所占的内存变为只读

     

    define 定义的是不带类型的常数

    只进行简单的字符替换

    在预编译的时候起作用

    不存在类型检查

    不能定义常量

    但宏定义可以实现在字面意义上和其它定义常量相同的功能,本质的区别就在于 #define 不为宏名分配内存

    (1) 编译器处理方式不同

    • #define 宏是在预处理阶段展开
    •  const 常量是编译运行阶段使用

    (2) 类型和安全检查不同

    •  #define 宏没有类型做任何类型检查,仅仅是展开
    •  const 常量有具体的类型,在编译阶段执行类型检查

    (3) 存储方式不同

    • #define宏仅仅是展开,有多少地方使用,就展开多少次,不会分配内存
    • (宏定义不分配内存,变量定义分配内存)
    •  
    • const常量会在内存中分配
    • (可以是堆中也可以是栈中)

    (4) const 可以节省空间,避免不必要的内存分配

    举例:

    #define NUM 3.14159 //常量宏
    const doulbe Num = 3.14159; //此时并未将Pi放入ROM中 ......
    double i = Num; //此时为Pi分配内存,以后不再分配!
    double I= NUM; //编译期间进行宏替换,分配内存
    double j = Num; //没有内存分配
    double J = NUM; //再进行宏替换,又一次分配内存!

    const 定义常量从汇编的角度来看,只是给出了对应的内存地址

    #define 一样给出的是立即数

    const 定义的常量在程序运行过程中只有一份拷贝(因为是全局的只读变量,存在静态区)

    #define 定义的常量在内存中有若干个拷贝

    (5) 提高了效率

     编译器通常不为普通const常量分配存储空间,而是将它们保存在符号表中,这使得它成为一个编译期间的常量,没有了存储与读内存的操作,使得它的效率也很高。

    (6) 宏替换只作替换,不做计算,不做表达式求解

    宏预编译时就替换了,程序运行时,并不分配内存。

    展开全文
  • Q: 常量和变量的本质区别是什么? A: 常量是不可改变的"变量", 变量是可改变的"常量". 我中有你你中有我是世界的本质,常量和变量只是为了方便表达特定含义的代名词,它们都是一种实体存在。 我们可能会关注常量和...

    Q: 常量和变量的本质区别是什么?

    A: 常量是不可改变的"变量", 变量是可改变的"常量". 我中有你你中有我是世界的本质,常量和变量只是为了方便表达特定含义的代名词,它们都是一种实体存在。

        我们可能会关注常量和变量在编译器或者运行期表达方式的不同,常量的不可改变特性有优化和保护的可能。

     

    Q: const int i = 1和int i = 1有何差异?

    A: const是写给编译器看的, 为防止修改i的代码出现,而汇编代码不受const影响。

    const int i = 1;
    int i = 1;

       对应的汇编代码是一样的:

    movl	$0x1, %esi

        

    Q: const变量有何种方式可以修改?

    A: 我们可以绕过普通的变量赋值手法, 找到变量的地址,用地址解引用的方式绕过编译器的"小脑袋瓜"。

    /*
       Xi Chen(511272827@qq.com)
       cxsjabcabc
    */
    #include <stdio.h>
    #include <unistd.h>
    #include <fcntl.h>
    
    int main(int argc, char *argv[])
    {
    	const int i = 1;
    	int *p;
    
    	// modify i = 2
    	p = &i;
    	*p = 2;
    
    	printf("%d %d\n", i, *p);
    
    	return 0;
    }
    

      运行结果: 

    1 2

      虽然我们透过i的地址修改了i的数值, 但是输出i还是最初的数值。这不难理解,编译器早知道i的常量,不管后面怎么间接修改i, printf方式输出i都只会拿最初的数值,但*p就不一样了。

    pushq	%rbp
    movq	%rsp, %rbp
    leaq	0x35(%rip), %rdi
    movl	$0x1, %esi   // 直接拿常量1
    movl	$0x2, %edx   // 直接拿常量2
    xorl	%eax, %eax
    callq	0x100000f8e
    xorl	%eax, %eax
    popq	%rbp
    retq
    

     

    Q: 既然编译器知道const变量不能被修改, 为何不建立一个特别的区域保护const变量避免间接修改呢?

    A: 程序区段布局模型决定了如上的代码没办法保护,位于堆栈区域本身可读写,如下放入全局区域才有机会做到。

    /*
       Xi Chen(511272827@qq.com)
       cxsjabcabc
    */
    #include <stdio.h>
    #include <unistd.h>
    #include <fcntl.h>
    
    const int i = 1;
    
    int main(int argc, char *argv[])
    {
    	int *p;
    
    	// modify i = 2
    	p = &i;
    	*p = 2;
    
    	printf("%d %d\n", i, *p);
    
    	return 0;
    }
    

      运行:  

    Bus error: 10

      i位于全局区域,而且是只读区域,代码*p = 2修改全局只读区域将被操作系统挡掉。

          

      0x3e(%rip)即是全局只读i的地址: 

        

     

    作者:     陈曦
    环境:     MacOS 10.14.5 (Intel i5)
             Apple LLVM version 10.0.1 (clang-1001.0.46.4)
             Target: x86_64-apple-darwin18.6.0
     
             Linux 3.16.83 (Ubuntu)
     
    转载请注明出处

     

    展开全文
  • 符号常量和变量的区别

    千次阅读 2016-09-27 16:40:16
    符号常量C语言中,可以用一个标识符来表示一个常量,称之为符号常量。 符号常量在使用之前必须先定义,其一般形式为: ...习惯上符号常量的标识符用大写字母,变量标识符用小写字母,以示区别
    符号常量
    在C语言中,可以用一个标识符来表示一个常量,称之为符号常量。
    符号常量在使用之前必须先定义,其一般形式为:
    #define 标识符 常量
    其中#define 也是一条预处理命令(预处理命令都以"#"开头),称为宏定义命令,其功能是把该标识符定义为其后的常量值。一经定义,以后在程序中所有出现该标识符的地方均代之以该常量值。习惯上符号常量的标识符用大写字母,变量标识符用小写字母,以示区别。
    注意:符号常量虽然有名字,但它不是变量。它的值在其作用域内是不能改变的,也不能被赋值。
    使用符号常量的好处是:1、含义清楚。2、在需要改变一个常量时能做到“一改全改”。
    常变量
    常变量是在定义变量时,如果加上关键字const,则变量的值在程序运行期间不能改变,这种变量称为常变量。如:
    const  int  a = 3;
    在定义常变量时必须同时对它初始化,此后它的值不能再改变,常变量不能出现在赋值符号的左边。
    区别:常变量与符号常量的区别:符号常量不占用内存空间,在预编译时就全部由符号常量的值替换了,而常变量占用内存空间,只是此变量在存在期间不能重新赋值。

    
    
    
    
    
    
    展开全文
  • C语言中const定义常量和宏常量的区别1.const定义常量2.宏常量3.两者区别(1) 编译器处理方式不同(2) 类型安全检查不同(3) 存储方式不同 1.const定义常量 关键字const 定义的是变量不是常量, 而是去改变一个变量的...

    1.const定义常量

    关键字const 定义的是变量不是常量, 而是去改变一个变量的存储类,把该变量所占的内存变为只读。这就是变量的值不允许改变的常变量。该常量带有数据类型。编译运行的时候起作用存在类型检查。

    #include <stdio.h>
    
    const int a = 1;     
    const static int b;
    
    void  foo(int *p, int val)
    {
        *p = val;
    }
    int main()
    {
    
        const int c = 1;
        const static int d;
    
        printf("a = %d\n", a);
        foo((int *)&a, 3);
        printf("a= %d\n", a);
        
        printf("b = %d\n", b);
        foo((int *)&b, 3);
        printf("b = %d\n", b); 
    
        printf("c = %d\n", c);
        foo((int *)&c, 3);
        printf("c = %d\n", c);
    
        printf("d = %d\n", d);
        foo((int *)&d, 3);
        printf("d = %d\n", d); 
    
        return 0;
    }
    

    运行结果:
    a = 1
    Segmentation fault (core dumped)
    其中a是全局变量,b是静态全局变量,c是局部变量,d是静态局部变量。

    【特别地】
    静态存储区分为DATA段和BSS段。
    BSS段存放的是未初始化的普通全局变量、静态局部变量、静态全局变量,
    DATA段存放的是已初始化的普通全局变量、静态局部变量、静态全局变量,其中DATA段又分为只读段和可读可写段。

    现代编译器中关键字const修饰的全局变量、静态局部变量变量和静态全局变量就是存放在DATA段中的只读段,所以这些变量为只读属性,其值通过指针也不可改变。而const修饰的局部变量存放在栈中,可以通过指针改变其值。

    【注意】:字符串常量就是存储在DATA段的只读段,不能通过指针改变其值。

    cons修饰指针时:

    const int p; //p可变,p指向的内容不可变
    int const
    p; //p可变,p指向的内容不可变
    int * const p; //p不可变,p指向的内容可变
    cons int* cons p;//p不可变,p指向的内容不可变

    注:
    当const出现在 *号左边的时候,指针指向的数据不可改变,但是指针本身的值可以改变;
    当const出现在 *号右边的时候,指针本身不能改变但是它指向的数据可以改变

    2.宏常量

    预处理器#define 定义的是不带数据类型的常数,只进行简单的字符替换。 在预编译的时候起作用,不存在类型检查。
    #define 是宏定义,它不能定义常量,但宏定义可以实现在字面意义上和其它定义常量相同的功能。

    3.两者区别

    (1) 编译器处理方式不同

    #define 宏是在预处理阶段展开。
    const 常量是编译运行阶段使用。

    (2) 类型和安全检查不同

    #define 宏没有类型,不做任何类型检查,仅仅是展开。
    const 常量有具体的类型,在编译阶段会执行类型检查。

    (3) 存储方式不同

    #define 宏仅仅是展开,有多少地方使用,就展开多少次,不会分配内存。(宏定义不分配内存,变量定义分配内存。)
    const定义常量会分配内存。

    展开全文
  • 1、指针常量:主语是常量,定语是指针,所以...是常量的话,值就是固定,不能被改变,否则就是变量了,所以p++,p--,p = &c,都是错误。 char a[2];//a就是一个指针常量,数组名a就相当于上述p指针常量。 ...
  • C语言中被const修饰的变量被称为 常变量,并且定义一个常变量时可以不对它进行初始化。如下图所示,我们没有对常变量a进行初始化,但程序依然可以正常运行。 当如果我们在定义一个常变量时没有对它进行初始化,则...
  • 而“a”则属于字符串常量,在C语言中没有直接储存字符串的变量,一般是通过数组存储。 另外,对于字符常量的内存占一个字节,对于字符创常量则会占2个字节,因为字符串常量,系统会在末尾自动加一个结束标志服'\0'...
  • 严格说,C语言中用#define伪命令定义对象称为常数,用const限定词定义并初始化对象称为常量(相对于变量而言)。 常数值在编译时确定,常量的值则在运行时初始化后确定(不过此后只能作为右值使用)。 ...
  • c语言的变量和常量

    2016-11-27 21:49:12
    2.内存与硬盘的区别:内存保存动态数据,硬盘保存静态数据;断电时,内存数据丢失,硬盘数据不丢失。   3.内存是共享设备,是稀缺资源。操作系统用来管理资源,给每个进程抽象出4G虚拟地址空间,虚拟空间通过MMU...
  • 字符串常量这玩意是由双引号罩着,这跟字符常量的定界符(‘’)不一样 长度不同 字符型就单引号里面一个,字符串就不一样双引号里面可以为0也能为其他整数 储存要求不同 字符常量存储是字符ASCLL码值 而...
  • 无论是什么量,最终归为0 101 变量常量“变”“常”数学概念解释“常”“变”常量变量是数学中反映事物量一对范畴。常量亦称“常数”,是反映事物相对静止状态量;变量亦称“变数”,是反映事物...
  • C语言常量变量

    2016-01-09 19:12:00
    1.常量 ...短整型长整型都可省虑后面的int,三者唯一的区别就是内存大小的区别,从小到大依次为short < int < long.   int a; short int b; long int c; printf("%d,%d",a,b);...
  • 1、指针是C语言中一个非常重要概念,在这之前用比较多是一级指针,由于理解不够透彻,导致在碰到二级指针时吃了不少憋,今天花了点时间搞清楚了,特此将其记录下来。 1、什么是指针? 要了解什么是指针,...
  • 全局变量局部变量在内存里的区别?  一、预备知识—程序的内存分配  一个由c/C++编译的程序占用的内存分为以下几个部分  1、栈区(stack)— 由编译器自动分配释放 ,存放函数的参数值,局部变量的值...
  • 在这篇文章中,我们将解释常量指针,指针常量,const pointer to const(ps:楼主以为这可以翻译成指向常量常量指针)的区别 常量指针 让我们先来理解什么是常量指针。常量指针是指指针指向的地址是常量。换句话说...
  • 就是给类,接口,方法,变量等起名字字符序列 组成规则 英文大小写字母数字$_ 注意事项 不能以数字开头标识符必须是由字母下划线开头字母下划线数字组合 2.以下不正确说法是:C 语言规定()。 ...
  • #defineconst有何区别? 大家在学C语言的时候肯定知道有两种形式来定义常量, #define PI 3.1415926 const float PI = 3.1415926;...const定义变量其实是C++写法,而**#define定义符号常量**是C语言原始...
  • 背景: 我在大学学过C++,没有学C。 到了公司,只能用C从事开发,虽然感觉C++应该都...在C++中,常量包括字面值只读变量: int a=12345; const int b=123; 这里,12345是字面值,a是变量,b是只读变量。 12.
  • 目录: 一:全局变量 二:局部变量 三:C语言经过编译之后将内存分为以下几个区域 ...全局变量保存在内存全局存储区中,占用静态存储单元 二:局部变量 局部变量保存在栈中,只有在所在函数被调用时才动态...
  • 1. C语言中被const修饰叫常变量 #include <stdio.h> void main() { const int v;...这里报错是因为C语言中,即使名字前面有个‘常’字,但是它终归是个变量,不能用在应该使用常量的地方,不
  • Lr常量和变量(二)

    2013-09-02 22:58:18
    本节主要学习二者的区别 参数是可以直接在系统函数中应用的,绝大多数情况下都可以直接...参数和变量的作用域 参数是全局的,在脚本的任何一个Action中都可以使用;变量是局部的,如果跨Action调用会出现未声明的错误
  • 变量和常量 定义声明区别

    万次阅读 2016-07-26 21:12:39
    常量:计算机内存里不变变量:经常改变数据 变量命名规则:1:标识符 :不能以数字开头,只能以字母或者下划线开头 而且只能由字母,数字,下划线组成 (例如C#就不可以)。函数名也是这种命名规则。 c语言...
  • 这三者之间存在区别 #define 宏名字 替代正文 是完全没有约束正文替代,他结果不受任何限制,完全不顾程序语法语义。尽量少用。  const 变量 变量名= 值; 这个本意是变量,只是在定义时候进行了初始化,...
  • 栈空间存放局部变量,函数形参堆空间存放malloc,relloc,calloc分配空间、数据段里面有BSS区,rodate区,date区,BSS存放未初始化全局变量,rodate存放常量,date存放全局变量和static修饰的变量的区别:...
  • 常数和常量的区别

    2020-01-16 15:55:24
    常数和常量的区别C语言中使用#define定义的对象称为常数; 用const限定词定义并初始化的对象称为常量;(相对于变量而言) 常数的值 ========> 编译时就确定了 常量的值 ========> 运行时初始化后才确定 ....
  • 字符串常量和字符常量是不同量。它们之间主要有以下区别: 1) 字符常量由单引号括起来,字符串常量由双引号括起来。 2) 字符常量只能是单个字符,字符串常量则可以含一个或多个字符。 3) 可以把一个字符常量...
  • C语言中*p p的区别

    2021-03-03 10:20:07
    C语言中*p p的区别 C语言中,*p p都常用在指针当中表示一个指针变量,*p p的区别: 表示的含义不同 *p表示此指针指向的内存地址中存放的内容。 p表示一个指针变量的名字,指此指针变量所指向的内存地址。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 520
精华内容 208
关键字:

常量和变量的区别c语言

c语言 订阅