C语言学习第三章——顺序程序设计_#include int main(void){ unsigned char a

转义字符
常量分类:
（1）字面常量(直接常量)：数值常量(分为整型常量和浮点型常量)，字符串常量和字符常量

#include<stdio.h>
int main(void){
	//1.整型常量
	printf("%d\n",234);
	//2.浮点型常量
	printf("%lf,%lf\n",3.24,3e-2);	//3e-2	代表3的10的-2次方 
	//3.字符串常量
	printf("%s","%dabc\n");		//字符串使用的是格式说明符为%s,输出：%dabc 
	printf("%%dabc\n");		//在printf格式字符串中输出“百分号”，需要再加一个“百分号”,输出：%dabc 
	//4.字符型变量		字符也是以整型方式存储在内存中的 
	printf("%c,%d\n",'a','a'); 		//普通字符常量 输出a,97
	
	//转义字符 
	printf("%c,%c,%c,%c\n",'\\','\'','\?','\"');	//可显的转义字符 输出：\,',?," 
	printf("\a");		//输出一个声音 		其中'\a'会产生声音或视觉信号 
	printf("1111\babc\n");		//输出：111abc 	其中'\b'是退格符 将当前位置后退一个字符 
	printf("2222\r3333\n");		//输出：3333 	其中'\r'是回车符 将当前位置滚回到本行开头 
	printf("4444\t5555\n");		//输出：4444	5555 		其中'\t'是水平制表符（tab）将当前位置移到下一个tab位置上 
	printf("\101\102\103\n");		//输出：ABC 		把8进制的101，102，103转成十进制则为65，66，67 分别对应了'A','B','C' 
	printf("\x41\n");		//输出：A 		16进制的x41=4x16^1+1x16^0=65 
	return 0; 
} 
//'\f'换页	
//'\v'垂直制表符
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

（2）符号常量
（3）常变量

#include<stdio.h>
//1.符号常量		只存在于预编译阶段，编译阶段就不存在了，经过预编译后，全部变为字面变量 
#define PI 3.14
#define ID 101
#define CH 'A'
#define S "haha" 
int main(void){
	printf("%lf,%d,%c,%s\n",PI,ID,CH,S);		//输出：3.140000,101,A,haha
//2.常变量	C99中新增内容
	const int a=45;		//常变量必须在定义时初始化，初始化之后其值不可以被修改
	//const int b; 		//error未指定初值 
	//a=90;		//error变量的值不可以被修改 
	return 0; 
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

整型
（一）补码：整型以补码的形式存放
（1）一个正数的补码是此数的二进制形式。
求一个正整数的二进制：除以2，直至商为o，余数倒数排序。
（2）一个负数的补码，先求其绝对值的补码，然后该补码所有位取反，所得之数最后加1。
（3）0的补码，所有位全都是0
注意：在存放整型的存储单元中最左边一位是用来表示符号的。
8位二进制补码所代表的整数：自然数0-127，负数-128-1
n位：-2ⁿ——2ⁿ-1

（二）整型数据的存储空间及范围
（1）Turbo C中 int 是2个字节。VC ++6.0中 int 是4个字节。C标准没有具体规定各种数据类型所占用储存单元的长度，这是由各编译系统自行决定的。

注意：只有整型〈包括字符型〉数据可以加 signed 或 unsigned 修饰符，实数型不能加；对无符号整型数据用 %u 格式输出。C99新增的整型类型有 long long 和 bool(布尔型)


注意：黑色的格式声明 scanf 可用，黑色和红色的格式声明 printf 可用。

整型常量的类型转换

#include<stdio.h>
int main(void){
	//1.定义整型变量 ——带符号整型 ——signed + 整型关键字 + int + 变量名（其中 signed 和 int 可省)
	short a = 1;		//与short int a = 1; 和 signed short int a = 1; 和 signed short a = 1;等价 
	int b = 2;
	long c = 3;
	long long d = 4;	//long long 是 C99 中新增的内容，有些编译器还未实现此功能，会报错 

	//2.定义整型变量 ——无符号整型 ——unsigned + 整型关键字 + int + 变量名（其中int可省)
	unsigned short e = 5;	//与unsigned short int e = 5;等价 
	unsigned int f = 6;
	unsigned long g = 7; 
	
	//3.求一个数据类型或者数值所占的字节数 ——使用sizeof运算符,注意他不是个函数，一般我们习惯对它的操作数加个圆括号(sizeof后如果是关键字必须加个圆括号否则报错 
	printf("%d,%d,%d\n",sizeof(short),sizeof(int),sizeof 5);	//输出：2,4,4 
	
	//4.整型数据输出10进制数，所使用的格式声明
	printf("%hd,%d,%ld\n",a,b,c);		//与printf("%hi,%i,%li\n",a,b,c);等价 
	printf("%hu,%u,%lu\n",e,f,g); 
	
	//5.整型数据输出8进制或16进制数，所使用的格式声明
	printf("%o,%x,%X,%#x,%#X\n",123,123,123,123,123);		//输出：173,7b,7B,0x7b,0X7B
	
	//6.scanf函数中不可以使用带"#"的格式字符
	scanf("%#x",&b);
	printf("%d\n",b);		//随便输入一个16进制数，scanf函数会因为错误而终止。所以并未把任何值赋给b，所以最终输出b的值还是为2
 
 	//7.隐式数据类型转换 ——长 赋 短，截断 
	unsigned short us = -1;		//"长的"整型数据赋给"短的"整型数据时，会只将低几位赋给"短的"整型数据
	printf("%hu,%hd\n",us,us);	//输出65535，-1
	
	//8.隐式数据类型转换 ——"无符短" 赋 "长"，先把"短的"全部内容复制到"长的"低几位，"长的"高几位填0
	unsigned int ui = us;
	printf("%u\n",ui);		//输出65535
	
	//9.隐式数据类型转换 ——"带符短" 赋 "长"，先把"短的"全部内容复制到"长的"低几位，如果"短的"是自然数，"长的"高几位填0，否则 1 
	short ss = -1;
	ui = ss;
	printf("%u\n",ui);		//输出4294967295
	
	ss = 1;
	ui = ss;
	printf("%u\n",ui); 		//输出1
	
	//10.隐式数据类型转换 ——等长，则保留原有补码
	ui = -1;
	printf("%u\n",ui);  	//输出4294967295
	
	//11.整型常量 ——显示数据类型转换 
	printf("%u,%ld,%lu\n",1U,1L,1UL);		//1U ——unsigned int类型，1L ——long类型，1UL ——unsigned long类型 	1,1,1
	
	//12.整形数据的强制数据类型转换 ——（数据类型）该处的圆括号为强制数据类型转换符，是一个单目运算符 
 	printf("%hu,%d\n",(unsigned short)-1,(int)ui);		//65535,-1
	return 0; 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

字符型数据
（一）字符是以整数形式（ASCII码）存放在内存单元中。ASCII共128个字符（也就是说最多用7位就可以表示）。
一个小写字母比其大写字母的ASCII码大32。

（二）字符型数据的存储空间和值

注意：
1.C99 把字符型数据作为整型类型的一种。
2.在使用有符号字符型变量时，允许储存的值为负数，但是字符的代码不可能是负值，所以在存储字符时只用到了0 — 127这一部分。

#include<stdio.h>
int main(void){
	//1.定义字符型变量
	signed char sc;
	unsigned char uc;
	char ch;		//在vc++中，char类型的变量是signed char类型的，在其他的编译器中char类型的变量可能是unsigned char类型的
	printf("%d,%d,%d\n",sizeof(sc),sizeof(uc),sizeof(ch));		//1,1,1 
	
	//2.分析下段代码的运行结果
	uc = -1;
	ch = -1;
	printf("%d,%d\n",ch,uc);		//-1,255 
	/*
	该句相当于： 
	int w;
	printf("%d,%d\n",w=ch,w=uc);
	*/ 
	return 0; 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

getchar和putchar函数

#include<stdio.h>		//该头文件有getchar和putchar函数的函数声明 
void f1(void){			//从键盘读入一个字符并输出 
	char ch = getchar();		//返回类型为int型，返回值为用户输入的ascⅡ码，出错返回-1
	putchar(ch);		//putchar向屏幕输出一个字符 
}
void f2(void){			//从键盘读入3个字符并输出 
	putchar(getchar());
	putchar(getchar());
	putchar(getchar());
} 
int main(void){
	//f1();
	f2();
	/*
	输入boy按回车，输出boy;
	输入b按回车，输出b和换行符，再输入o按回车，输出o 
	*/ 
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

浮点型数据
包括：单精度浮点型，双精度浮点型，长双精度浮点型，复数浮点型

（一）规范化的指数形式，把小数部分中小数点前的数字为0，小数点后第一位数不为0。如：0.314159e1 就是3.14159 的规范化的指数形式。

（二）实数储存空间及范围（Turbo C 中 long double 占16个字节，yc++6.0中占 8个字节)

注：从数值的左边第一个不为 0 的数字起，一直数到这个数字结束，中间的数字叫这个值的有效数字（如 0.618 的有效数字有三个,分别是 6,1,8）

/* 
注:
（一）所有常量末尾加的数据类型转换符可以大小写不分
（二）在目前学习过的所有格式声明中只有x、e、g可以不分大小写
*/
#include<stdio.h>
int main(void){
	//1.定义实型变量 ——当把一个"长的"浮点型教据赋给一个较"短的"浮点型变量时，可能造成精度的损失。而且在有的编译器中会出现警告
	float a = 1.1F;		//1.1F表示1.1是个float型数据 
	double b = 1.1;		//默认情况下，凡是小数都是double型 
	long double c = 1e-8L;		//1e-8L是个long double的数据 
	printf("%d,%d,%d\n",sizeof(1.1F),sizeof(1.1),sizeof(1e-8L)); 	//4,8,8 
	
	//2.实型数据在格式化输入输出时所使用的格式声明 ——默认情况下使用带F和带e的格式声明只输出小数点后6位（第7位四舍五入）
	//小数形式
	printf("%f,%lf,%Lf\n",a,b,c);		//输出1.100000，1.100000，-0.000000 
	//指数形式 
	printf("%e,%le,%LE\n",a,b,c);		//输出1.100000e+000，1.100000e+000,-1.041128E-097
	//小数或者指数形式（哪一种形式简短就用哪一种形式） 
	printf("%g,%lg,%LG\n",a,b,c);		//输出1.1，1.1，-1.04113E-097 
	return 0;
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

printf用到的格式附加字符

//格式声明 - % 格式附加字符 格式字符	%lf 
#include<stdio.h>
int main(void){
	printf("%5d\n",-12);
	printf("%5c\n",'a');
	printf("%5s\n\n","abcd");
	
	printf("%-5dA\n\n",-12);
	
	printf("%7.2lf\n",12.345); 
	printf("%7.lf\n",12.345); 	//%7.lf和%7.0lf等价 
	printf("%.5lf\n",12.345);
	printf("%11lf\n",12.345);
	printf("%-11lf\n",12.345);
	return 0;
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

scanf函数的注意事项

//scanf函数中不可以使用#，-，m.n的格式附加字符(m, n属于自然数）,可以使用域宽的格式附加字符
#include<stdio.h>
int main(void){
	int a;
	/*
	scanf("%5d",&a);
	printf("%d\n",a);
	*/
	/*
	scanf("%-5d",&a);
	printf("%d\n",a);
	*/
	double b;
	scanf("%7.2d",&b);
	printf("%lf\n",b);
	char ch;
	while((ch = getchar())!='\n')
		putchar(ch);
	putchar('\n');
	return 0;
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

运算符2

#include<stdio.h>
int main(void){
	int i = 1,j = 4;		//前自减运算符它表达式的值是该变量减1之后的值，后自减运算符它表达式的值是该变量没有被减1之前的值
	printf("%d,%d\n",--i,j--);		//0,4
	printf("%d,%d\n",i,j);		//0,3
	//printf("%d\n",--(i+j)); 		//error 自增自减运算符不能用于一个数值，只能用于一个变量
	i = 1;j = 4;
	printf("%d\n",i+++j);	//vc++中i+++和（i++）+j等价，但在其他的编译器上也可能和i+(++j)等价，对于不可移植的操作我们应该尽量避免使用 
	
	int a;
	printf("%d\n",sizeof((double) a));		//8	(double) a是把a这个数值表达式转化成double型数据，而不是把a变量转化成double型变量
	printf("%d\n",sizeof(a)); 		//4 
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14