4.常量

Posted 2020-12-29 traditional

//C常量
/*
常量是固定的值，在程序执行期间不会改变。这些固定的值又叫做字面量
常量和变量一样，可以是任意的数据类型，但是在定义之后就不可以再修改了
*/

//整数常量
/*
整数常量可以十进制、八进制、十六进制的的常量。0x或者0X表示十六进制，0b表示八进制，不带前缀表示十进制
整数常量也可以带一个后缀，后缀是u和l的组合，u表示无符号（unsigned），l表示长整数（long），
后缀既可以大写也可以小写，顺序随意
212  合法
215u 合法
0xF  合法
078  不合法，八进制逢八进一，所以不可能出现8
032uu不合法，后缀不可以重复

85 十进制
0213 八进制
0x4b 十六进制 
30 整数
30u 无符号整数
30l 长整数，注意是30l，不是301，最后一个字符是英文字符l
30ul 无符号长整数
*/

//浮点常量
/*
浮点常量由整数部分，小数点，小数部分，和指数部分组成。
可以使用小数部分或者整数部分来表示浮点类型常量
3.14159 合法
314159e-5l，合法，指数部分使用e|E表示，
50e， 不合法，不完整的指数
21f，不合法，没有小数或者指数
.e55,不合法，缺少整数部分或分数
*/

//字符常量
/*
字符常量是括在单引号中，例如，‘x‘可以存储在char类型的简单变量中
字符常量可以是一个普通的字符，也可以是一个转义序列(‘	‘)，或一个通用字符(‘U02C0‘)
在c中，有一些特定的字符，当它们前面具有反斜杠的时候，具有特殊的含义
\, 字符
‘, ‘字符
", "字符
?, ?字符
a, 报警铃声
, 退格键
f, 换页符

, 换行符

, 回车，使光标回到行首
	, 水平制表符
v, 垂直制表符
*/
#include <stdio.h>
int main01()
{
	printf("hello	 wo	rld
");  //hello    wo     rld
	printf("i love
 aragaki yui
");// aragaki yui,为啥产生这个结果。当打印i love之后遇见了
								   // 光标有退回了行首，表示从行首打印，因此把i love 覆盖了
}


//定义常量
/*
在c中定义常量有两种方式
1.使用#define预处理器
2.使用const关键字
*/

//#define预处理器
#define length 10
#define width 5
#define newline ‘c‘
int main02()
{
	int area;
	area = length * width;
	printf("area=%d
",area); //area=50
	printf("char=%c
",newline); //char=c
}

//使用const关键字
//const type variation
int main()
{
	const int LENGTH=10;
	const int WIDTH=5;
	const char NEWLINE=‘c‘;
	int area;
	area = LENGTH * WIDTH;
	printf("area=%d
", area);  //area=50
	printf("char=%c
", newline); // char=c
}

//笔记
/*
#define是宏定义，它不能定义常量，但宏定义字面上可以实现其他定义常量相同的功能
本质的区别就在于#define不为宏名分配内存，而const也不为常量分配内存
其实const不是定义一个常量，而是改变一个变量的存储类型，把该变量所占的内存改为只读
*/

/*
反斜杠,开头的叫做转义序列(escape sequence)
char ch=‘101‘  等价于 char ch=0101
*/

/*
const 定义的是变量而不是常量，只是这个变脸过的值不允许改变，是常变量。
带有类型，编译运行的时候起作用，存在类型检查
define 定义的是不带类型的常数，只进行简单的字符替换。在预编译的时候起作用，不存在类型检查。
两者的区别
1.编译器处理的方式不同
#define 宏是在预处理阶段展开
const 常量是在编译运行阶段使用

2.类型和安全检查不同
#define 宏没有类型，不做任何类型检查，仅仅是展开
const 常量有具体的类型，在编译阶段会执行类型检查

3.存储方式不同
#define 宏仅仅是展开，有多少地方使用就展开多少次，不会分配内存
const 常量会分配内存，可以是在栈中也可以是在堆中

4.const可以节省空间，避免不必要的内存分配
#define num 3.1415 常量宏
double m=num; 编译期间进行宏替换，分配内存
double n=num; 再进行宏替换又一次分配内存
const double NUM=3.14159; 此时并未将NUM放入内存中
double i = NUM; 此时为NUM分配内存，以后不再分配
double j = NUM; 不再为NUM分配内存

const定义的常量从汇编的角度来看，只是给出了对应的内存地址，而不是像#define立即给出数
所以const定义的常量在程序运行的过程中只有一份拷贝(全局的只读变量，放在静态区)
而#define定义的常量在内存中有若干份拷贝

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

6.宏替换只做替换，不做计算，不做表达式求解
*/

/*
#define要注意边缘效应，如#define N 2+3，N的值是5
如果int a=N/2;
在程序编译运行的时候，我们以为会打印2.5，实际上打印的是3.5
原因是，编译器将N/2，处理成了2+3/2，这就是宏的边缘效应，因此要改成#define N (2+3)
*/