3. C语言数据类型¶
在开始之前，我们有必要了解下C语言的关键字
3.1. 关键字¶
下表列出了 C 中的保留字。这些保留字不能作为常量名、变量名或其他标识符名称。
auto |
else |
long |
switch |
|---|---|---|---|
break |
enum |
register |
typedef |
case |
extern |
return |
union |
char |
float |
short |
unsigned |
const |
for |
signed |
void |
continue |
goto |
sizeof |
volatile |
default |
if |
static |
while |
do |
int |
struct |
_Packed |
double |
auto |
long |
else |
3.2. 数据类型¶
在 C 语言中，数据类型指的是用于声明不同类型的变量或函数的一个广泛的系统。变量的类型决定了变量存储占用的空间，以及如何解释存储的位模式。
C 中的类型可分为以下几种：
数据类型的作用
编译器预算对象（变量）分配的内存空间大小。
3.3. 常量和变量¶
3.3.1. 常量¶
常量是固定值，在程序执行期间不会改变。这些固定的值，又叫做字面量。
常量可以是任何的基本数据类型，比如整数常量、浮点常量、字符常量，或字符串字面值，也有枚举常量。
常量就像是常规的变量，只不过常量的值在定义后不能进行修改。
3.3.1.1. 整数常量¶
整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数：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.3.1.2. 浮点常量¶
浮点常量由整数部分、小数点、小数部分和指数部分组成。您可以使用小数形式或者指数形式来表示浮点常量。
当使用小数形式表示时，必须包含小数点、指数，或同时包含两者。当使用指数形式表示时，必须包含整数部分、小数部分，或同时包含两者。带符号的指数是用 e 或 E 引入的。
下面列举几个浮点常量的实例：
3.14159 /* 合法的 */
314159E-5L /* 合法的 */
510E /* 非法的：不完整的指数 */
210f /* 非法的：没有小数或指数 */
.e55 /* 非法的：缺少整数或分数 */
3.3.1.3. 字符常量¶
字符常量是括在单引号中，例如，'x' 可以存储在 char 类型的简单变量中。
字符常量可以是一个普通的字符（例如 'x'）、一个转义序列（例如 '\t'），或一个通用的字符（例如 '\u02C0'）。
注解
在 C 中，有一些特定的字符，当它们前面有反斜杠时，它们就具有特殊的含义，被用来表示如换行符（\n）或制表符（\t）等。
3.3.1.4. 字符串常量¶
字符串字面值或常量是括在双引号 "" 中的。一个字符串包含类似于字符常量的字符：普通的字符、转义序列和通用的字符。
您可以使用空格做分隔符，把一个很长的字符串常量进行分行。
下面的实例显示了一些字符串常量。下面这2种形式所显示的字符串是相同的。
"hello, dear"
"hello, \
dear"
3.3.1.5. 定义常量¶
在 C 中，有两种简单的定义常量的方式：
使用 #define 预处理器。
使用 const 关键字。
3.3.1.5.1. #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.3.1.5.2. 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
注解
把常量定义为大写字母形式，是一个很好的编程实践。
3.3.2. 变量¶
变量（Variable）是编程语言最重要的概念之一，在程序中变量是一个名字，而这个名字代表的是计算机存储器中的一块空间，可以在里面保存一个值（Value），保存的值是可以随时变的，比如这次存个字符 'a' ，变量的值就是 'a' ，下次存个字符 'b' ，变量的值就变成 'b' ，正因为变量的值可以随时变所以才叫变量。
常量有不同的类型，变量也有不同的类型，变量的类型决定了它所占的存储空间的大小。在C语言中用声明（Declaration）来规定变量的名字和类型，例如下面有四条声明，规定了四个变量 fred 、 bob 、 jimmy 和 tom 的类型分别是字符型、整型、单精度浮点型、双精度浮点型：
char fred;
int bob;
float jimmy;
double tom;
变量的名称可以由字母、数字和下划线字符组成。它必须以字母或下划线开头。大写字母和小写字母是不同的，因为 C 是大小写敏感的。基于前面讲解的基本类型，有以下几种基本的变量类型：
类型 |
描述 |
|---|---|
char |
通常是一个八位字节（一个字节）。这是一个整数类型。 |
int |
对机器而言，整数的最自然的大小。 |
float |
单精度浮点值。 |
double |
双精度浮点值。 |
void |
表示类型的缺失。 |
C 语言也允许定义各种其他类型的变量，比如枚举、指针、数组、结构、共用体等等，这将会在后续的章节中进行讲解，本章节我们先讲解基本变量类型。
小技巧
变量特点：
变量在编译时为其分配相应的内存空间
可以通过其名字和地址访问相应内存
3.3.2.1. C 中的变量定义¶
小技巧
变量定义就是告诉编译器在何处创建变量的存储，以及如何创建变量的存储
变量定义指定一个数据类型，并包含了该类型的一个或多个变量的列表，如下所示：
type variable_list;
在这里，type 必须是一个有效的 C 数据类型，可以是 char、w_char、int、float、double、bool 或任何用户自定义的对象，variable_list 可以由一个或多个标识符名称组成，多个标识符之间用逗号分隔。下面列出几个有效的声明：
int i, j, k;
char c, ch;
float f, salary;
double d;
行 int i, j, k; 声明并定义了变量 i、j 和 k，这指示编译器创建类型为 int 的名为 i、j、k 的变量。
变量可以在声明的时候被初始化（指定一个初始值）。初始化器由一个等号，后跟一个常量表达式组成，如下所示：
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'
不带初始化的定义
带有静态存储持续时间的变量会被隐式初始化为 NULL（所有字节的值都是 0），其他所有变量的初始值是未定义的。
3.3.2.2. C 中的变量声明¶
变量声明向编译器保证变量以给定的类型和名称存在，这样编译器在不需要知道变量完整细节的情况下也能继续进一步的编译。变量声明只在编译时有它的意义，在程序连接时编译器需要实际的变量声明。
当您使用多个文件且只在其中一个文件中定义变量时（定义变量的文件在程序连接时是可用的），变量声明就显得非常有用。您可以使用 extern 关键字在任何地方声明一个变量。虽然您可以在程序中多次声明一个变量，但变量只能在某个文件、函数或代码块中被定义一次。
注解
C语言中的声明有变量声明、函数声明和类型声明三种。本节只讲变量声明
3.3.2.2.1. 实例¶
下面的实例，其中，变量在头部就已经被声明，但它们是在主函数内被定义和初始化的：
#include <stdio.h>
// 变量声明
extern int a, b;
extern int c;
extern float f;
int main ()
{
/* 变量定义 */
int a, b;
int c;
float f;
/* 实际初始化 */
a = 10;
b = 20;
c = a + b;
printf("value of c : %d \n", c);
f = 70.0/3.0;
printf("value of f : %f \n", f);
return 0;
}
当上面的代码被编译和执行时，它会产生下列结果：
value of c : 30
value of f : 23.333334
同样的，在函数声明时，提供一个函数名，而函数的实际定义则可以在任何地方进行。例如：
// 函数声明
int func();
int main()
{
// 函数调用
int i = func();
}
// 函数定义
int func()
{
return 0;
}
小技巧
从另一个角度来看，声明分为“是定义（Definition）的声明”和“不是定义的声明”，那么什么样的声明同时也是定义呢？简单地说， 分配存储空间的声明同时也是定义，不分配存储空间的声明不是定义 。具体来说：
如果一个变量声明要求程序在运行时为该变量分配存储空间，那么这个声明同时也是变量的定义。本章和接下来几章的示例代码中的变量声明都是要分配存储空间的，因而都是定义；等学到 声明和定义 我们会看到有些变量声明不分配存储空间，因而不是定义。
如果一个函数声明带有函数体，要求编译器为它生成指令（当然在运行时也需要分配存储空间来存放这些指令），那么这个声明同时也是函数的定义。在下一章我们会看到带函数体的声明和不带函数体的声明，不带函数体的声明不是函数定义。
类型声明总是不分配存储空间的，所以严格来说只有类型声明而没有类型定义，但通常我们习惯说“定义了某种类型”，所以在本书中“类型定义”和“类型声明”表示相同的含义，不加区分。
变量声明也是以;号结尾的，这一点和语句类似，但是在语法上变量声明和语句是有区别的，语句只能出现在函数体中，而变量声明既可以出现在函数体中也可以出现在所有函数之外。
3.3.2.3. C 中的左值（Lvalues）和右值（Rvalues）¶
C 中有两种类型的表达式：
**左值（lvalue）：**指向内存位置的表达式被称为左值（lvalue）表达式。左值可以出现在赋值号的左边或右边。
**右值（rvalue）：**术语右值（rvalue）指的是存储在内存中某些地址的数值。右值是不能对其进行赋值的表达式，也就是说，右值可以出现在赋值号的右边，但不能出现在赋值号的左边。
变量是左值，因此可以出现在赋值号的左边。数值型的字面值是右值，因此不能被赋值，不能出现在赋值号的左边。下面是一个有效的语句：
int g = 20;
但是下面这个就不是一个有效的语句，会生成编译时错误：
10 = 20;
3.4. 整形¶
下表列出了关于标准整数类型的存储大小和值范围的细节：
类型 |
存储大小 |
值范围 |
|---|---|---|
char |
1 byte |
-128 到 127 或 0 到 255 |
unsigned char |
1 byte |
0 到 255 |
signed char |
1 byte |
-128 到 127 |
int |
2 或 4 bytes |
-32,768 到 32,767 或 -2,147,483,648 到 2,147,483,647 |
unsigned int |
2 或 4 bytes |
0 到 65,535 或 0 到 4,294,967,295 |
short |
2 bytes |
-32,768 到 32,767 |
unsigned short |
2 bytes |
0 到 65,535 |
long |
4 bytes |
-2,147,483,648 到 2,147,483,647 |
unsigned long |
4 bytes |
0 到 4,294,967,295 |
为了得到某个类型或某个变量在特定平台上的准确大小，您可以使用 sizeof 运算符。表达式 sizeof(type) 得到对象或类型的存储字节大小。
3.4.1. int¶
3.4.1.1. 整型变量的定义和输出¶
打印格式 |
含义 |
|---|---|
%d |
输出一个有符号的10进制int类型 |
%o(字母o) |
输出8进制的int类型 |
%x |
输出16进制的int类型，字母以小写输出 |
%X |
输出16进制的int类型，字母以大写输出 |
%u |
输出一个10进制的无符号数 |
例子如下
#include <stdio.h>
int main()
{
int a = 123; //定义变量a，以10进制方式赋值为123
int b = 0567; //定义变量b，以8进制方式赋值为0567
int c = 0xabc; //定义变量c，以16进制方式赋值为0xabc
printf("a = %d\n", a);
printf("8进制：b = %o\n", b);
printf("10进制：b = %d\n", b);
printf("16进制：c = %x\n", c);
printf("16进制：c = %X\n", c);
printf("10进制：c = %d\n", c);
unsigned int d = 0xffffffff; //定义无符号int变量d，以16进制方式赋值
printf("有符号方式打印：d = %d\n", d);
printf("无符号方式打印：d = %u\n", d);
return 0;
}
3.4.1.2. 整型变量的输入¶
#include <stdio.h>
int main()
{
int a;
printf("请输入a的值：");
//不要加“\n”
scanf("%d", &a);
printf("a = %d\n", a); //打印a的值
return 0;
}
3.4.2. short、int、long、long long¶
数据类型 |
占用空间 |
|---|---|
short(短整型) |
2字节 |
int(整型) |
4字节 |
long(长整形) |
Windows为4字节，Linux为4字节(32位)，8字节(64位) |
long long(长长整形) |
8字节 |
警告
需要注意的是，整型数据在内存中占的字节数与所选择的操作系统有关。虽然 C 语言标准中没有明确规定整型数据的长度，但 long 类型整数的长度不能短于 int 类型， short 类型整数的长度不能长于 int 类型。
当一个小的数据类型赋值给一个大的数据类型，不会出错，因为编译器会自动转化。但当一个大的类型赋值给一个小的数据类型，那么就可能丢失高位。
3.4.2.1. 数据定义和输出¶
整型常量 |
所需类型 |
|---|---|
10 |
代表int类型 |
10l, 10L |
代表long类型 |
10ll, 10LL |
代表long long类型 |
10u, 10U |
代表unsigned int类型 |
10ul, 10UL |
代表unsigned long类型 |
10ull, 10ULL |
代表unsigned long long类型 |
3.4.2.2. 数据输出格式¶
打印格式 |
含义 |
|---|---|
%hd |
输出short类型 |
%d |
输出int类型 |
%ld |
输出long类型 |
%lld |
输出long long类型 |
%hu |
输出unsigned short类型 |
%u |
输出unsigned int类型 |
%lu |
输出unsigned long类型 |
%llu |
输出unsigned long long类型 |
示例如下：
#include <stdio.h>
int main()
{
short a = 10;
int b = 10;
long c = 10l; //或者10L
long long d = 10ll; //或者10LL
printf("sizeof(a) = %u\n", sizeof(a));
printf("sizeof(b) = %u\n", sizeof(b));
printf("sizeof(c) = %u\n", sizeof(c));
printf("sizeof(c) = %u\n", sizeof(d));
printf("short a = %hd\n", a);
printf("int b = %d\n", b);
printf("long c = %ld\n", c);
printf("long long d = %lld\n", d);
unsigned short a2 = 20u;
unsigned int b2 = 20u;
unsigned long c2= 20ul;
unsigned long long d2 = 20ull;
printf("unsigned short a = %hu\n", a2);
printf("unsigned int b = %u\n", b2);
printf("unsigned long c = %lu\n", c2);
printf("unsigned long long d = %llu\n", d2);
return 0;
}
3.4.3. 有符号数和无符号数¶
3.4.3.1. 有符号数¶
有符号数是最高位为符号位，0代表正数，1代表负数。
#include <stdio.h>
int main()
{
signed int a = -1089474374; //定义有符号整型变量a
printf("%X\n", a); //结果为 BF0FF0BA
//B F 0 F F 0 B A
//1011 1111 0000 1111 1111 0000 1011 1010
return 0;
}
3.4.3.2. 无符号数¶
无符号数最高位不是符号位，而就是数的一部分，无符号数不可能是负数。
#include <stdio.h>
int main()
{
unsigned int a = 3236958022; //定义无符号整型变量a
printf("%X\n", a); //结果为 C0F00F46
return 0;
}
注解
当我们写程序要处理一个不可能出现负值的时候，一般用无符号数，这样可以增大数的表达最大值。
3.4.4. sizeof关键字¶
sizeof不是函数，所以不需要包含任何头文件，它的功能是计算一个数据类型的大小，单位为字节
sizeof的返回值为size_t
size_t类型在32位操作系统下是unsigned int，是一个无符号的整数
#include <stdio.h>
int main()
{
int a;
int b = sizeof(a);//sizeof得到指定值占用内存的大小，单位：字节
printf("b = %d\n", b);
size_t c = sizeof(a);
printf("c = %u\n", c);//用无符号数的方式输出c的值
return 0;
}
3.5. 字符型：char¶
3.5.1. 字符变量的定义和输出¶
字符型变量用于存储一个单一字符，在 C 语言中用 char 表示，其中每个字符变量都会占用 1 个字节。在给字符型变量赋值时，需要用一对英文半角格式的单引号(’ ‘)把字符括起来。
字符变量实际上并不是把该字符本身放到变量的内存单元中去，而是将该字符对应的 ASCII 编码放到变量的存储单元中。char的本质就是一个1字节大小的整型。
#include <stdio.h>
int main()
{
char ch = 'a';
printf("sizeof(ch) = %u\n", sizeof(ch));
printf("ch[%%c] = %c\n", ch); //打印字符
printf("ch[%%d] = %d\n", ch); //打印‘a’ ASCII的值
char A = 'A';
char a = 'a';
printf("a = %d\n", a); //97
printf("A = %d\n", A); //65
printf("A = %c\n", 'a' - 32); //小写a转大写A
printf("a = %c\n", 'A' + 32); //大写A转小写a
ch = ' ';
printf("空字符：%d\n", ch); //空字符ASCII的值为32
printf("A = %c\n", 'a' - ' '); //小写a转大写A
printf("a = %c\n", 'A' + ' '); //大写A转小写a
return 0;
}
3.5.2. 字符变量的输入¶
#include <stdio.h>
int main()
{
char ch;
printf("请输入ch的值：");
//不要加“\n”
scanf("%c", &ch);
printf("ch = %c\n", ch); //打印ch的字符
return 0;
}
3.5.3. ASCII对照表¶
ASCII值 |
控制字符 |
ASCII值 |
字符 |
ASCII值 |
字符 |
ASCII值 |
字符 |
|---|---|---|---|---|---|---|---|
0 |
NUT |
32 |
(space) |
64 |
@ |
96 |
、 |
1 |
SOH |
33 |
! |
65 |
A |
97 |
a |
2 |
STX |
34 |
“ |
66 |
B |
98 |
b |
3 |
ETX |
35 |
# |
67 |
C |
99 |
c |
4 |
EOT |
36 |
$ |
68 |
D |
100 |
d |
5 |
ENQ |
37 |
% |
69 |
E |
101 |
e |
6 |
ACK |
38 |
& |
70 |
F |
102 |
f |
7 |
BEL |
39 |
, |
71 |
G |
103 |
g |
8 |
BS |
40 |
( |
72 |
H |
104 |
h |
9 |
HT |
41 |
) |
73 |
I |
105 |
i |
10 |
LF |
42 |
* |
74 |
J |
106 |
j |
11 |
VT |
43 |
+ |
75 |
K |
107 |
k |
12 |
FF |
44 |
, |
76 |
L |
108 |
l |
13 |
CR |
45 |
- |
77 |
M |
109 |
m |
14 |
SO |
46 |
. |
78 |
N |
110 |
n |
15 |
SI |
47 |
/ |
79 |
O |
111 |
o |
16 |
DLE |
48 |
0 |
80 |
P |
112 |
p |
17 |
DCI |
49 |
1 |
81 |
Q |
113 |
q |
18 |
DC2 |
50 |
2 |
82 |
R |
114 |
r |
19 |
DC3 |
51 |
3 |
83 |
S |
115 |
s |
20 |
DC4 |
52 |
4 |
84 |
T |
116 |
t |
21 |
NAK |
53 |
5 |
85 |
U |
117 |
u |
22 |
SYN |
54 |
6 |
86 |
V |
118 |
v |
23 |
TB |
55 |
7 |
87 |
W |
119 |
w |
24 |
CAN |
56 |
8 |
88 |
X |
120 |
x |
25 |
EM |
57 |
9 |
89 |
Y |
121 |
y |
26 |
SUB |
58 |
: |
90 |
Z |
122 |
z |
27 |
ESC |
59 |
; |
91 |
[ |
123 |
{ |
28 |
FS |
60 |
< |
92 |
/ |
124 |
| |
29 |
GS |
61 |
= |
93 |
] |
125 |
} |
30 |
RS |
62 |
> |
94 |
^ |
126 |
` |
31 |
US |
63 |
? |
95 |
_ |
127 |
DEL |
ASCII 码大致由以下两部分组成：
ASCII 非打印控制字符： ASCII 表上的数字 0-31 分配给了控制字符，用于控制像打印机等一些外围设备。
ASCII 打印字符：数字 32-126 分配给了能在键盘上找到的字符，当查看或打印文档时就会出现。数字 127 代表 Del 命令。
3.5.4. 转义字符¶
转义字符 |
含义 |
ASCII码值（十进制） |
|---|---|---|
\a |
警报 |
007 |
\b |
退格(BS) ，将当前位置移到前一列 |
008 |
\f |
换页(FF)，将当前位置移到下页开头 |
012 |
\n |
换行(LF) ，将当前位置移到下一行开头 |
010 |
\r |
回车(CR) ，将当前位置移到本行开头 |
013 |
\t |
水平制表(HT) （跳到下一个TAB位置） |
009 |
\v |
垂直制表(VT) |
011 |
\ |
代表一个反斜线字符”” |
092 |
’ |
代表一个单引号（撇号）字符 |
039 |
“ |
代表一个双引号字符 |
034 |
? |
代表一个问号 |
063 |
\0 |
数字0 |
000 |
\ddd |
8进制转义字符，d范围0~7 |
3位8进制 |
\xhh |
16进制转义字符，h范围0~9，a~f，A~F |
3位16进制 |
3.6. 实型(浮点型)：float、double¶
实型变量也可以称为浮点型变量，浮点型变量是用来存储小数数值的。在C语言中， 浮点型变量分为两种： 单精度浮点数(float)、 双精度浮点数(double)， 但是double型变量所表示的浮点数比 float 型变量更精确。
由于浮点型变量是由有限的存储单元组成的，因此只能提供有限的有效数字。在有效位以外的数字将被舍去，这样可能会产生一些误差。
不以f结尾的常量是double类型，以f结尾的常量(如3.14f)是float类型。
#include <stdio.h>
int main()
{
//传统方式赋值
float a = 3.14f; //或3.14F
double b = 3.14;
printf("a = %f\n", a);
printf("b = %lf\n", b);
//科学法赋值
a = 3.2e3f; //3.2*1000 = 3200，e可以写E
printf("a1 = %f\n", a);
a = 100e-3f; //100*0.001 = 0.1
printf("a2 = %f\n", a);
a = 3.1415926f;
printf("a3 = %f\n", a); //结果为3.141593
return 0;
}