目录：

一：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: 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)
 
转载请注明出处

 

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

C语言中const定义常量和宏常量的区别
1.const定义常量
cons修饰指针时：
2.宏常量
3.两者区别
(1) 编译器处理方式不同
(2) 类型和安全检查不同
(3) 存储方式不同

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定义常量会分配内存。