C语言——变量和常量的区别用法

目录：

一：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   
  
int main()   
{  
      
    int a;  
    int b;  
  
    printf("a的地址是%p\nb的地址是%p\n",&a,&b);  
    return 0;  
     
}  

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

#include   
  
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 
  
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 
 
#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 
 
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) 宏替换只作替换，不做计算，不做表达式求解

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