C | 数据和C_c语言int类型常量-CSDN博客

本文链接：https://blog.csdn.net/weixin_42019459/article/details/126351817

示例程序

/* platinum.c -- your weight in platinum */
#include <stdio.h>
int main(void)
{
	float weight; /* 你的体重 */
	float value; /* 相等重量的白金价值 */
	printf("Are you worth your weight in platinum?\n");
	printf("Let's check it out.\n");
	printf("Please enter your weight in pounds: ");
	/* 获取用户的输入 */
	scanf("%f", &weight);
	/* 假设白金的价格是每盎司$1700 */
	/* 14.5833用于把英镑常衡盎司转换为金衡盎司*/
	value = 1700.0 * weight * 14.5833;
	printf("Your weight in platinum is worth $%.2f.\n",// 此处换行不会报错
		value);
	printf("You are easily worth that! If platinum prices drop, \n"); // ""内部中途换行会报错
	printf("eat more to maintain your value.\n");
	getchar();
	getchar();
	return 0;
}

1、错误与警告

错误消息表明程序中有错，不能进行编译。而警告则表明，尽管编写的代码有效，但可能不是程序员想要的。

第一行的错误是由于scanf（）函数的不安全性造成，scanf_s仅适用于VS编译环境，解决方法参照文章Microsoft Visual Studio常见问题

第二行的警告是由于默认1700.0和14.5833为double型，转化为float丢失精度。

2、getchar()的使用

getchar()函数读取下一个输入字符，因此程序会等待用户输入。键入数字并按下Enter（或Return）键（发送一个换行符），然后scanf()读取键入的数字，第1个getchar()读取换行符，第2个getchar()让程序暂停，等待输入。

3、%.2f中的.2用于精确控制输出，指定输出的浮点数只显示小数点后面两位。

4、scanf()函数

%f说明scanf()要读取用户从键盘输入的浮点数，&weight告诉 scanf()把输入的值赋给名为 weight 的变量。scanf()函数使用&符号表明找到 weight变量的地点。

变量与常量数据

有些数据类型在程序使用之前已经预先设定好了，在整个程序的运行过程中没有变化，这些称为常量（constant）。其他数据类型在程序运行期间可能会改变或被赋值，这些称为变量（variable）。

数据：数据类型关键字

1、C通过识别一些基本的数据类型来区分和使用这些不同的数据类型。如果数据是常量，编译器一般通过用户书写的形式来识别类型。对变量而言，要在声明时指定其类型。

2、数据类型关键字

int表示基本的整数类型。
long、short、unsigned、signed用于提供基本整数类型的变式。
char用于指定字母和其他字符，也可以表示较小的整数。
float、double和long double表示带小数点的数。
_Bool表示布尔值（true或false）。
_complex和_Imaginary分别表示复数和虚数。

3、通过这些关键字创建的类型，按计算机的储存方式可分为两大基本类型：整数类型和浮点数类型。

4、位、字节和字

位（bit）：最小的存储单元，计算机内存的基本构建块。

字节（byte）：常用的计算机存储单位。对于几乎所有的机器，1字节均为8位。

字（word）：设计计算机时给定的自然存储单位。字长越大，数据转移越快，允许的内存访问也更多。

5、浮点数和整数

浮点数和整数的储存方案不同。计算机以二进制数字储存整数。把浮点数分成小数部分和指数部分来表示，而且分开储存这两部分。
浮点数可以表示的范围比整数大。
对于一些算术运算（如，两个很大的数相减），浮点数损失的精度更多。
计算机的浮点数不能表示区间内所有的值。浮点数通常只是实际值的近似值。
浮点运算比整数运算慢。

C语言基本数据类型

一、int类型

有符号整型，一般而言，储存一个int要占用一个机器字长。ISO C规定int的取值范围最小为-32768～32767（即16位，2个字节）。一般而言，系统用一个特殊位的值表示有符号整数的正负号。

1、int变量

声明，为int大小的变量赋予名称并分配空间

int erns;

int hogs, cows, goats;

为变量提供值

方法1，赋值cows = 112;

方法2，通过函数（如，scanf()）获得值

方法3，初始化（initialize）变量：为变量赋一个初始值。

int hogs = 21;

int cows = 32, goats = 14;

2、int常量

C语言把大多数整型常量视为int类型，但是非常大的整数除外。（还有long常量和long long常量）

3、打印int值

如果没有给%d提供任何值，那么打印出的值是内存中的任意值。

/* print1.c - 演示printf()的一些特性 */
#include <stdio.h>
int main(void)
{
	int ten = 10;
	int two = 2;
	printf("Doing it right: ");
	printf("%d minus %d is %d\n", ten, 2, ten - two);
	printf("Doing it wrong: ");
	printf("%d minus %d is %d\n", ten); // 遗漏2个参数
	getchar();
	return 0;
}

运行结果：

Doing it right: 10 minus 2 is 8
Doing it wrong: 10 minus 13111371 is 13111371
大部分函数都需要指定数目的参数，编译器会检查参数的数目是否正确。但是，printf()函数的参数数目不定，可以有1个、2个、3个或更多，编译器也爱莫能助。

4、8进制和16进制

0x或0X前缀表示十六进制值。0前缀表示八进制。

以十进制显示数字，使用%d；
以八进制显示数字，使用%o；
以十六进制显示数字，使用%x。
要显示各进制数的前缀0、0x和0X，必须分别使用%#o、%#x、%#X。

/* bases.c--以十进制、八进制、十六进制打印十进制数100 */
#include <stdio.h>
int main(void) {
	int x = 100;
	printf("dec = %d; octal = %o; hex = %X\n", x, x, x);
	printf("dec = %d; octal = %#o; hex = %#X\n", x, x, x); 
	getchar();
	return 0;
}

运行结果：
dec = 100; octal = 144; hex = 64
dec = 100; octal = 0144; hex = 0X64

二、其他整数类型

short int类型（或者简写为short）占用的存储空间可能比int类型少，常用于较小数值的场合以节省空间。
long int或long占用的存储空间可能比int多，适用于较大数值的场合。
long long int或long long（C99标准加入）占用的储存空间可能比long多，适用于更大数值的场合。该类型至少占64位。
unsigned int或unsigned只用于非负值的场合。无符号整型可以表示更大的数。
在任何有符号类型前面添加关键字signed，可强调使用有符号类型的意图。

1、使用多种整数类型的原因

C语言只规定了short占用的存储空间不能多于int，long占用的存储空间不能少于int。这样规定是为了适应不同的机器。个人计算机上最常见的设置是，long long占64位，long占32位，short占16位，int占16位或32位（依计算机的自然字长而定）。原则上，这4种类型代表4种不同的大小，但是在实际使用中，有些类型之间通常有重叠。

C 标准对基本数据类型只规定了允许的最小大小。

对于 16 位机，short 和 int 的最小取值范围是[−32767,32767]；（2字节）
对于32位机，long的最小取值范围是[−2147483647,2147483647]。（4字节）
对于unsigned short 和unsigned int，最小取值范围是[0,65535]；
对于unsigned long，最小取值范围是[0,4294967295]。
long long类型是为了支持64位的需求，最小取值范围是[-9223372036854775807,9223372036854775807]；（8字节）
unsigned long long的最小取值范围是[0,18446744073709551615]

2、如何选择int类型

· unsigned类型的数常用于计数，因为计数不用负数。而且，unsigned类型可以表示更大的正数。
· 如果一个数超出了int类型的取值范围，且在long类型的取值范围内时，使用long类型。对于那些long占用的空间比int大的系统，使用long类型会减慢运算速度。如非必要，请不要使用long类型。
· 如果在long类型和int类型占用空间相同的机器上编写代码，当确实需要32位的整数时，应使用long类型而不是int类型，以便把程序移植到16位机后仍然可以正常工作。类似地，如果确实需要64位的整数，应使用long long类型。
· 如果在int设置为32位的系统中要使用16位的值，应使用short类型以节省存储空间。通常，只有当程序使用相对于系统可用内存较大的整型数组时，才需要重点考虑节省空间的问题。使用short类型的另一个原因是，计算机中某些组件使用的硬件寄存器是16位。

3、long常量和long long常量

数字被储存为int类型，若超出int范围，视为long int类型；若超出long int范围，视为unsigned long类型；若超出unsigned long范围，视为long long或unsigned long long类型。

八进制和十六进制常量被视为int类型。编译器会依次尝试使用unsigned int、 long、unsigned long、long long和unsigned long long类型。

指定常量的类型

l（小写的L）或L后缀：作为long类型对待。l或L后缀也可用于八进制和十六进制整数，如020L和0x10L。
ll或LL后缀：long long类型。
u或U后缀：unsigned类型。如5ull、10LLU、6LLU或9Ull

整数溢出

如果整数超出了相应类型的取值范围，会重新从起始点开始。

/* toobig.c-- 超出系统允许的最大int值*/
#include <stdio.h>
int main(void)
{
	int i = 2147483647;
	unsigned int j = 4294967295;
	printf("%d %d %d\n", i, i + 1, i + 2);
	printf("%u %u %u\n", j, j + 1, j + 2);
	getchar();
	return 0;
}

运行结果：

2147483647 -2147483648 -2147483647
4294967295 0 1

注：溢出行为是未定义的行为，C 标准并未定义有符号类型的溢出规则。以上描述的溢出行为比较有代表性，但是也可能会出现其他情况。

4、打印short、long、long long和unsigned类型

打印unsigned int类型的值：%u转换说明
打印long类型的值：%ld转换说明

注：如果系统中int和long的大小相同，使用%d就行。但是，这样的程序被移植到其他系统（int和long类型的大小不同）中会无法正常工作。

以十六进制格式打印long类型整数：%lx转换说明
以八进制格式打印long类型整数：%lo转换说明

注：虽然C允许使用大写或小写的常量后缀，但是在转换说明中只能用小写。

以十进制显示short类型的整数：%hd转换说明
以八进制显示short类型的整数：%ho转换说明
以十六进制格式打印short类型整数：%hx转换说明
注：
h和l前缀都可以和u一起使用，用于表示无符号类型。对于支持long long类型的系统，%lld和%llu分别表示有符号和无符号类型。
#用来显示打印数据的格式，如%#lx，打印结果为0x10001。

实例

/* print2.c--更多printf()的特性 */
#include <stdio.h>
int main(void)
{
	// 2^15 = 32,768
	// 2^31 = 2, 147, 483, 648
	// 2^63 = 9,223,372,036,854,775,808
	unsigned int un = 3000000000; /* int为32位和short为16位的系统 */
	short end = 200;
	long big = 65537;
	long long verybig = 12345678908642;
	printf("un = %u and not %d\n", un, un);
	printf("end = %hd and %d\n", end, end);
	printf("end = %u and %d\n", end, end);
	printf("big = %ld and not %hd\n", big, big);
	printf("big = %#lx and not %#hx\n", big, big);
	printf("verybig= %lld and not %ld\n", verybig, verybig);
	getchar();
	return 0;
	
}

结果：

un = 3000000000 and not -1294967296
end = 200 and 200
end = 200 and 200
big = 65537 and not 1
big = 0x10001 and not 0x1
verybig= 12345678908642 and not 1942899938

3000000000 和有符号值−129496296 在系统内存中的内部表示完全相同；对于较小的正数，有符号和无符号类型的存储、显示都相同。
在给函数传递参数时，C编译器把short类型的值自动转换成int类型的值。
原因：int类型被认为是计算机处理整数类型时最高效的类型。
h修饰符作用：使用h修饰符可以显示较大整数被截断成 short 类型值的情况。65537 以二进制格式写成一个 32 位数是00000000000000010000000000000001。使用%hd，printf()只会查看后16 位，所以显示的值是 1。同样地，使用%ld，printf()只显示储存在后32位的值。

总结:

必须确保转换说明的数量和待打印值的数量相同。
必须根据待打印值的类型使用正确的转换说明。

三、char类型

char类型用于储存字符（如，字母或标点符号），但是从技术层面看，char是整数类型。计算机使用数字编码来处理字符，美国最常用的编码是ASCII编码。标准ASCII码的范围是0～127，只需7位二进制数即可表示。通常，char类型被定义为8位的存储单元。

注：许多字符集都超过了127，商用的统一码（Unicode）创建了一个能表示世界范围内多种字符集的系统，目前包含的字符已超过110000个。国际标准化组织（ISO）和国际电工技术委员会（IEC）为字符集开发了ISO/IEC10646标准。统一码标准也与ISO/IEC 10646标准兼容。

C语言把1字节定义为char类型占用的位（bit）数。

1、声明char类型变量

char response;

char itable, latan;

2、字符常量和初始化

用单引号括起来的单个字符被称为字符常量（character constant）。双引号括起来的叫字符串。
字符是以数值形式储存的，所以也可使用数字代码值来赋值（前提是系统使用ASCII码），这是一种不好的编程风格。最好使用字符常量，而不是数字代码值。
C语言将字符常量视为int类型而非char类型。把4个独立的8位ASCII码储存在一个32位存储单元中，只有最后8位有效。

3、非打印字符

有些ASCII字符打印不出来，C语言提供2种方法：

1、使用ASCII码。例如，蜂鸣char beep = 7;

2、使用特殊的符号序列（转义序列（escape sequence））表示一些特殊的字符。把转义序列赋给字符变量时，必须用单引号把转义序列括起来。

C标准规定警报字符不得改变活跃位置。活跃位置（active position）指的是显示设备（屏幕、电传打字机、打印机等）中下一个字符将出现的位置。

换页符（\f）把活跃位置移至下一页的开始处；
换行符（\n）把活跃位置移至下一行的开始处；
回车符（\r）把活跃位置移动到当前行的开始处；
水平制表符（\t）将活跃位置移至下一个水平制表点（通常是第1个、第9个、第17个、第25个等字符位置）；
垂直制表符（\v）把活跃位置移至下一个垂直制表点。
\\、\'、\"用于打印\、'、"字符。
\0oo和\xhh（\Xhh）是ASCII码的特殊表示，代表八进制和十六进制。

注：

注意数字和数字字符的区别。字符4对应的ASCII码是52。'4'表示字符4，而不是数值4。
无论是普通字符还是转义序列，只要是双引号括起来的字符集合，就无需用单引号括起来。双引号中的字符集合叫作字符串。
如果要在转义序列（假设使用'\f'）和ASCII码（'\014'）之间选择，请选择前者（即'\f'）。这样的写法不仅更好记，而且可移植性更高。'\f'在不使用ASCII码的系统中，仍然有效。
如果要使用ASCII码，为何要写成'\032'而不是032？首先，'\032'能更清晰地表达程序员使用字符编码的意图。其次，类似\032这样的转义序列可以嵌入C的字符串中。

4、打印字符

如果用%d转换说明打印 char类型变量的值，打印的是一个整数。而%c转换说明告诉printf()打印该整数值对应的字符。printf()函数中的转换说明决定了数据的显示方式，而不是数据的储存方式。

/* charcode.c-显示字符的代码编号 */
#include <stdio.h>
int main(void)
{
	char ch;
	char beep = 7;
	printf("Please enter a character.\n");
	scanf("%c", &ch); /* 用户输入字符 */
	printf("The code for %c is %d.\n", ch, ch);
	printf("%c", beep);
	//printf("\a");
	getchar();
	getchar();
	return 0;
}

运行结果：

Please enter a character.
6
The code for 6 is 54.

5、有符号还是无符号

有些C编译器把char实现为有符号类型，有些C编译器把char实现为无符号类型，可查阅编译器手册或limits.h头文件。无论编译器默认char是什么类型，signed char表示有符号类型，而unsigned char表示无符号类型。

四、_Bool类型

C99标准添加了_Bool类型，用于表示布尔值，即逻辑值true和false。它也是一种整数类型。但原则上它仅占用1位存储空间。

五、可移植类型：stdint.h和inttypes.h

C99 新增了两个头文件stdint.h和inttypes.h，以确保C语言的类型在各系统中的功能相同。

C语言为现有类型创建了更多类型名。这些新的类型名定义在stdint.h头文件中。

精确宽度整数类型（exact-width integer type），int32_t 表示整数类型的宽度正好是32位。精确宽度整数类型是可选项。

最小宽度类型（minimum width type），int_least8_t 是可容纳8位有符号整数值的类型中宽度最小的类型的一个别名。

最快最小宽度类型（fastst minimum width type），int_fast8_t 被定义为系统中对8位有符号值而言运算最快的整数类型的别名。

最大的有符号整数类型 intmax_t，可储存任何有效的有符号整数值。类似地，uintmax_t 表示最大的无符号整数类型。

C99 和 C11 不仅提供可移植的类型名，还提供相应的输入和输出。inttypes.h头文件中定义了PRId32字符串宏，代表打印32位有符号值的合适转换说明（如d或l）。

注：在C语言中，可以把多个连续的字符串组合成一个字符串，如：printf("me16 = %" "d" "\n", me16);等价于printf("me16 = %d\n", me16);

/* altnames.c -- 可移植整数类型名 */
#include <stdio.h>
//#include <stdint.h>
#include <inttypes.h> // 支持可移植类型
int main(void) 
{
	int32_t me32; // me32是一个32位有符号整型变量
	me32 = 45933945;
	printf("First, assume int32_t is int: ");
	printf("me32 = %d\n", me32);
	printf("Next, let's not make any assumptions.\n");
	printf("Instead, use a \"macro\" from inttypes.h: ");
	printf("me32 = %" PRId32 "\n", me32);
	printf("%d",sizeof(me32));
	getchar();
	return 0;
}

运行结果：

First, assume int32_t is int: me32 = 45933945
Next, let's not make any assumptions.
Instead, use a "macro" from inttypes.h: me32 = 45933945
4

六、float、double和long double

C标准规定，float类型必须至少能表示6位有效数字，且取值范围至少是10-37～10+37。通常，系统储存一个浮点数要占用32位。其中8位用于表示指数的值和符号，剩下24位用于表示非指数部分（也叫作尾数或有效数）及其符号。

double类型和float类型的最小取值范围相同，但至少必须能表示10位有效数字。一般情况下，double占用64位，这样经过分配，double类型的值至少有13位有效数字，超过了标准的最低位数规定。

long double，以满足比double类型更高的精度要求。C只保证long double类型至少与double类型的精度相同。

1、声明浮点型变量

float noah, jonah;

double trouble;

2、浮点型常量

正号可以省略。可以没有小数点（如，2E5）或指数部分（如，19.28），但是不能同时省略两者。可以省略小数部分（如，3.E16）或整数部分（如，.45E-6），但是不能同时省略两者。
不要在浮点型常量中间加空格：1.56 E+12（错误！）
默认情况下，编译器假定浮点型常量是double类型的精度。
在浮点数后面加上f或F后缀可覆盖默认设置，编译器会将浮点型常量看作float类型，如2.3f和9.11E9F。使用l或L后缀使得数字成为long double类型，如54.3l和4.32L。
C99 标准添加了一种新的浮点型常量格式——用十六进制表示浮点型常量，即在十六进制数前加上十六进制前缀（0x或0X），用p和P分别代替e和E，用2的幂代替10的幂（即，p计数法）。

3、打印浮点值

%f转换说明：打印十进制记数法的float和double类型浮点数。
%e转换说明：打印指数记数法的浮点数。
%a(%A)转换说明：打印十六进制指数记数法的浮点数。
%Lf、%Le或%La转换说明：打印long double类型。

/* showf_pt.c -- 以两种方式显示float类型的值 */
#include <stdio.h>
int main(void)
{
	float aboat = 32000.0;
	double abet = 2.14e9;
	long double dip = 5.32e-5;
	printf("%f can be written %e\n", aboat, aboat);
	// 下一行要求编译器支持C99或其中的相关特性
	printf("And it's %a in hexadecimal, powers of 2 notation\n", aboat);
	printf("%f can be written %e\n", abet, abet);
	printf("%Lf can be written %Le\n", dip, dip);
	getchar();
	return 0;
}

运行结果：
32000.000000 can be written 3.200000e+04
And it's 0x1.f400000000000p+14 in hexadecimal, powers of 2 notation
2140000000.000000 can be written 2.140000e+09
0.000053 can be written 5.320000e-05

注：给那些未在函数原型中显式说明参数类型的函数（如，printf()）传递参数时，C编译器会把float类型的值自动转换成double类型。

4、浮点值的上溢和下溢

当计算导致数字过大，超过当前类型能表达的范围时，就会发生上溢（overflow）。printf()显示该值为inf或infinity（或者具有无穷含义的其他内容）。

在计算过程中损失了原末尾有效位上的数字。这种情况叫作下溢（underflow）。C语言把损失了类型全精度的浮点值称为低于正常的（subnormal）浮点值。

另一个特殊的浮点值NaN（not a number的缩写），例如某个函数的行为是未定义的，该函数将返回NaN值。

浮点数舍入错误

给定一个数，加上1，再减去原来给定的数，结果是多少？

计算机缺少足够的小数位来完成正确的运算。就会得出一些奇怪答案。

/* floaterr.c--演示舍入错误 */
#include <stdio.h>
int main(void)
{
	float a, b;
	b = 2.0e20 + 1.0;// 改为2.0e2就没问题了
	a = b - 2.0e20;
	printf("%f \n", a);
	getchar();
	return 0;
}

运行结果：

4008175468544.000000

注：由于计算机使用的系统不同，一个程序有不同的输出。原因是实现浮点数表示法的方法有多种。为了尽可能地统一实现，电子和电气工程师协会（IEEE）为浮点数计算和表示法开发了一套标准。现在，许多硬件浮点单元都采用该标准。

七、复数和虚数类型

C语言有 3 种复数类型： float_Complex 、double_Complex和long double _Complex。例如，float _Complex类型的变量应包含两个float类型的值，分别表示复数的实部和虚部。类似地，C语言的3种虚数类型是float _Imaginary、double _Imaginary和longdouble _Imaginary。

如果包含complex.h头文件，便可用complex代替_Complex，用imaginary代替_Imaginary，还可以用I代替-1的平方根。不直接把complex作为关键字的原因是为了避免以该关键字作为标识符的现有代码全部失效。

八、其他类型

· 字符串
· 衍生的其他类型：数组、指针、结构和联合。指针（pointer）指向变量或其他数据对象位置。

九、类型大小

sizeof 是C语言的内置运算符，以字节为单位给出指定类型的大小。%zd转换说明匹配 sizeof 的返回类型size_t，一些不支持C99和C11的编译器可用%u或%lu代替%zd。

我的计算机上面

* typesize.c -- 打印类型大小 */
#include <stdio.h>
int main(void)
{
	/* C99为类型大小提供%zd转换说明 */
	printf("Type char has a size of %zd bytes.\n",
		sizeof(char));
	printf("Type short has a size of %zd bytes.\n",
		sizeof(short));
	printf("Type int has a size of %ld bytes.\n",
		sizeof(int));
	printf("Type long has a size of %zd bytes.\n",
		sizeof(long));
	printf("Type long long has a size of %zd bytes.\n",
		sizeof(long long));
	printf("Type float has a size of %zd bytes.\n",
		sizeof(float));
	printf("Type double has a size of %zd bytes.\n",
		sizeof(double));
	printf("Type long double has a size of %zd bytes.\n",
		sizeof(long double));
	getchar();
	return 0;
}

运行结果：

Type char has a size of 1 bytes.

Type short has a size of 2 bytes.

Type int has a size of 4 bytes.

Type long has a size of 4 bytes.

Type long long has a size of 8 bytes.

Type float has a size of 4 bytes.

Type double has a size of 8 bytes.

Type long double has a size of 8 bytes.

使用数据类型

与Pascal相比，C在检查类型匹配方面不太严格。C编译器甚至允许二次初始化，但在激活了较高级别警告时，会给出警告。
C编译器把浮点数转换成整数时，会直接丢弃（截断）小数部分，而不进行四舍五入。
许多程序员和公司内部都有系统化的命名约定，在变量名中体现其类型。例如，用 i_前缀表示 int类型，us_前缀表示 unsigned short 类型。

参数和陷阱

printf()函数无论双引号中包含多少个字符和标点符号，一个字符串就是一个参数。
C语言用逗号分隔函数中的参数。
程序员要负责确保转换说明的数量、类型与后面参数的数量、类型相匹配。现在，C 语言通过函数原型机制检查函数调用时参数的个数和类型是否正确。但是，该机制对printf()和scanf()不起作用，因为这两个函数的参数个数可变。用%d显示float类型的值，其值不会被转换成int类型。在不同的平台下，缺少参数或参数类型不匹配导致的结果不同。

其他

退格不会擦除退回所经过的字符，但有些实现是擦除的。
\r使得光标回到当前行的起始处。
最初，printf()语句把输出发送到一个叫作缓冲区（buffer）的中间存储区域，然后缓冲区中的内容再不断被发送到屏幕上。当缓冲区满、遇到换行字符或需要输入的时候（从缓冲区把数据发送到屏幕或文件被称为刷新缓冲区）。
计算机中的浮点数和整数在本质上不同，其存储方式和运算过程有很大区别。
C语言允许编写混合数据类型的表达式，但是会进行自动类型转换，以便在实际运算时统一使用一种类型。
转义序列实例：

/* escape.c -- 使用转移序列 */
#include <stdio.h>
int main(void)
{
	float salary;
	printf("\aEnter your desired monthly salary:"); /* 1 */
	printf(" $_______\b\b\b\b\b\b\b"); /* 2 */
	scanf("%f", &salary);
	printf("\n\t$%.2f a month is $%.2f a year.", salary,
		salary * 12.0); /* 3 */
	printf("\rGee!\n"); /* 4 */
	getchar();
	getchar();
	return 0;
}

运行结果：

Enter your desired monthly salary: $666____

Gee! $666.00 a month is $7992.00 a year.