程序说到底就是对数据的处理，所以首先要弄清楚需要处理哪些数据，计算机如何存储这些数据。C语言根据需要，抽象出了一些基本数据类型和衍生数据类型。这些可以满足大部分需求，更复杂的抽象数据类型亦可通过它们来组成。

1. 数据存储

　　计算机存储的最小单位是bit，它表示0或1。而计算机可寻址的最小单位是byte，它至少由8个bit组成，内存就是由许多个byte组成并编址的。有OS时，C操作的是逻辑地址，OS会最终转为物理地址。

　　一个数据由多个bit组成，按照二进制的表示习惯，将最左侧的bit叫做MSB（Most Significant Bit），最右侧的bit叫做LSB（Least Significant Bit），这里的significant当然是指该bit表示的数量级。这些bit会划分到连续的byte中，存储时byte的顺序基于系统或平台。这又引出了大小端（Endian）的概念，LSB存储在高地址时叫Big Endian，否则叫Little Endian。但无论如何，该数据的地址都是指最低地址。而且进一步讲，数组和结构成员的地址也是按它们的指数或定义顺序向高地址增长的，即使在栈里也不例外（栈底一般在高地址，栈顶向低地址增长）。

　　C提供了关键字sizeof获取数据或类型占用内存的大小，结果以byte为单位。sizeof后如果跟括号，里面可以是类型或表达式，否则后面只能跟表达式。sizeof是运算符而不是函数，它的结果在编译时确定。如果操作对象是表达式，则返回其对应类型的大小，而不会执行表达式。

int a = 1;sizeof(char);  // always 1sizeof char;   // illegalsizeof(a);     // oksizeof a;      // oksizeof(++a);   // a = 1

　　计算机处理数据的单位叫word，我们一般说的32位64位计算机就是指word。为了提高处理效率，数据尽量不要或少跨word存储。这就需要数据的存储地址是数据长度的整数倍，和类型长度一样，对齐的单位一般是2的幂。基本类型对齐单位是其类型长度，组合类型（数组、结构、联合）的对齐单位是其成员的最大对齐单位。由于默认对齐的存在，组合类型的成员之间可能有一些空隙，sizeof的结果可能不是简单的累加了。但要注意，组合类型的成员总是尽量向低地址靠齐，所以组合类型的开头是不会有空隙的。

struct S1 {char c; int i;};struct S2 {int i; char c;};// assume sizeof(int) = 4int a;         // align to 4struct S1 s1;  // align to 4struct S2 s2;  // align to 4sizeof(s1);    // 8sizeof(s2);    // 5

　　新规范中引入了关键字_Alignof和_Alignas（同sizeof一样不是函数），新引入的关键字一般以‘_‘和大写字母开头（为了不和编译器的扩展或用户自定义冲突），如果想用小写字母开头的，需要include对应的标准库（宏定义）。_Alignof后跟类型，得到类型的对齐单位。_Alignas后跟类型或整数常量，用来修饰类型或变量定义，但它不能小于其原有的对齐单位。

#include <stdalign.h>alignof(char);                           // always 1alignas(int) char c;                     // the same as alignas(alignof(int))alignas(char) int i;                     // illegalstruct alignas(4) S {char c; short i;};  // c and i all aligned to 4

　　C中数据一般叫object，不同的数据会有不同的类型（type）。类型决定了数据的长度和格式，除此之外的类型属性（比如const）只有编译器能看到，而对计算机是透明的。C定义了char、int、float、double四种基本型，还有两个特殊类型void和枚举，以及它们的衍生（derived）类型（指针、数组、结构、联合、函数）。基本型和枚举并称为代数型（arithmetic），代数型和指针并称为度量型（scalar），数组和结构并称为聚合型（aggregate）。整型（interger）包括char、int和枚举，浮点型包括float和double，整型和浮点型并称实数型（real）。新规范中还定义了可选关键字_Bool、_Complex和_Imaginary，个人认为可以当做基本型，而且_Bool可以划到整型里。

　　类型前可以有多种修饰符，它们有不同种类和用途，这里先介绍一类叫类型说明符（非规范定义）。包括short、long、long long（新规范）、signed和unsigned，它们仅作用于基本型，且长度和符号可以组合使用。所有的说明符都可以修饰int，int默认为signed（可不写），有说明符时int可不写。signed、unsigned可修饰char，long可修饰double，其它用法皆非法。

unsigned    ui;   // unsigned intlong long   ll;   // signed long long intchar        c;    // signed char or unsigned charlong double ld;   // ok

2. 数据类型

2.1 整型

　　整型数有不同的长度，其中char始终为1，int一般为字长，枚举与int一样，_Bool基于实现。short至少16bit且不超过int，long至少32bit且不低于int，long long至少64bit且不低于long。无符号整型的值即它的二进制数的值，有符号整型的值基于平台实现。少数老的平台采用的是反码表示法（1‘s complement），它概念简单直观，但却不方便计算，个人认为注定被淘汰，没有讨论价值。现在几乎所有的平台都使用补码表示法（2‘s complement），该模型更符合问题的本质，自然也更便于计算。对于负数，补码即0减去它的绝对值（有underflow），实现了正负数的平滑连接。

　　字符型包含char、wchar_t、char16_t和char32_t，其中char是基本类型，其它为int（带说明符）的宏定义。char类型永远是1个byte，可表示basic字符集，它的符号是基于实现的。字符常量用一对单引号表示，引号里为字符或转义序列，引号前有可选前缀L、u和U（分别对应后3种字符型）。字符常量本身的类型为int或unsigned int，它的值为引号中字符的编码或转义序列的值。引号中可以有多个字符，但它们在int中的存储位置是不定义的。下表中列出了转义序列及其含义：

int magic   = ‘abcd‘;         // may be 0x61626364char end    = ‘\0‘;           // 0wchar_t wc  = L‘\xaaaa‘;char32_t uc = U‘\Uaaaaaaaa‘;

 　　int型常量以非0数字开头则表示10进制数，0x或0X开头表示16进制数，0开头表示8进制数。后面可以有后缀U、L或LL（不限大小写），分别表示unsigned、long和long long。U可以和L或LL组合，且顺序随意。int型可以按它能表示的最大数来排序，如果能表示的最大数相同，则按int、long、long long排序。一个可能的队列为int、long、unsigned int、unsigned long、long long、unsigned long long。int型常量的类型以后缀类型（默认为int）为起点，从队列中寻找第一个满足规则且能包含其值的类型。规则是：（1）如果起点为unsigned，则尝试signed；（2）如果起点为signed且为10进制数，则不尝试unsigned。另外要注意，不存在负常量，它只是对正常量的负运算。

1234LLU;                                  // the same as 1234ULL0XFF;                                     // 255011;                                      // 9// assume int and long 32 bits, long long 64 bits1ULL;                                     // unsigned long long int, start from it0x100000000U;                             // unsigned long long int, start from unsigned int, not try signed0x80000000;                               // unsigned int, start from signed int, hex can try unsigned2147483648L;                              // signed long long int, start from singed long, not try unsigned// from <limits.h>#define INT_MIN      (-2147483647 - 1)    // signed int, then negtive, then decrease#define INT_MAX      2147483647           // signed int#define UINT_MAX     0xffffffff           // start from signed int, hex can try unsigned// wrong!#define INT_MIN      -2147483648          // start from signed int, then try signed long and signed long long, then negtive#define UINT_MAX     4294967295           // start from signed int, then try signed long and signed long long

　　枚举（enumeration）是一个特殊的自定义的类型，它为其每一个常量定义了名字，这些常量的值都是int型（可为负数）。枚举常量的值可以显式指明，或者为其前一常量加1，第1个常量的隐式值为0。枚举常量可以像宏一样使用，往往用于简单的编号。

enum Color {    WHITE,          // 0    BLACK,          // 1    RED    = 100,    GREAN,          // 101    BLUE   = -1,    YELLOW          // 0};

2.2 浮点型

　　浮点型的计算机表示由平台决定，但几乎所有实现都遵循规范IEC-60559（IEEE-754），这里简单介绍一下该规范中的浮点表示。根据数据长度（精度），规范将浮点分为single、double和double-extended，分别对应C中的float、double和long double。float和double的长度分别为32和64，long double未作明确定义。从MSB到LSB，浮点型被分为符号位（sign，1位）、指数（exponent，8或11位）和尾数（fraction，23或52位），它可表示为以2为底的科学计数。符号位是整个浮点数的符号，所以会存在正负0和正负无穷。指数被解释为无符号整数，并减去一个偏差（bias）。偏差值会导致\(e_{max}\)比\(e_{min}\)绝对值大1（考虑到倒数的溢出），比如float类型的偏差为127，\(e_{max}\) = 128，\(e_{min}\) = -127。指数取最大值时，若尾数为0，整个数解释为正负无穷大，否则为NaN（not a number）。指数为最小值时，尾数解释为\(0.f\)（denormalized），否则解释为\(1.f\)（normalized）。

　　实数是连续的，无法用计算机精确表示，整个浮点数空间可以看做是实数的采样。对normalized区段，每个数量级的采样数是相等的（\(f\)的每一位都有意义），对denormalized区段，每个数量级的采样数递减（\(f\)的实际有效位）。denormalized区段指数采用的是\(e_{min}+1\)，而非\(e_{min}\)，保证了和normalized区段的平滑过渡，很是巧妙！浮点数也支持正负无穷和NaN这类抽象值，为错误处理提供了很好的工具。超出表示边界的值都是无穷大，无意义的数（\(0/0\)，\(0*\infty\)）都表示为NaN，它们亦可参加运算，值视情况而定。浮点运算在运算时保持精度，但对结果进行舍入（每一个运算），舍入的方法是尾数为偶数（round to even）。

　　由于舍入或正负0的存在，和0的比较变得不可靠，所以不要判断某浮点数是否为0。在比较两个浮点数是否相等时，直接用a == b或a != b，不要将a - b与0比较。浮点的舍入会导致原本相近两个数的差被掩盖，有时调整算法可以减少误差，读者可以思考以下公式变换带来的精度提高。

\[a^{2}-b^{2}=(a+b)(a-b),\; \; (a\approx b)\]

\[b-\sqrt{b^{2}-4ac}=\frac{4ac}{b+\sqrt{b^{2}-4ac}},\; \; (b^{2}\gg 4ac)\]

　　浮点常量一般以10为底，新规范支持以2为底的浮点常量（0x开头），它可以避免精度的丢失。浮点常量的尾数部分不可少，10为底用10进制数，2为底用16进制数。尾数可以为整数或小数，若小数点前或后为0可不写，但不能同时不写。指数部分从字母e、E（10为底）或p（2为底）开始，后面都跟10进制数（为了和后缀中的F区分开来）。10为底的浮点常量可以没有指数部分，但这时尾数不能为整数，否则会被解析为整型。2为底的浮点常量必须有指数，否则后缀F无法与尾数区分。浮点常量默认为double，后缀F和L（不分大小写）分别表示float和long double，无类型提升（和常整型不同）。

123;      // int123F;     // illegal123.;     // double.123;     // double.e2;      // illegal123e2;    // double0xffF;    // int0xFFp2F;  // float

#include <complex.h>long double complex c;c = (long double)1.0 + 1.0 * I;

int a[0];                      // illegalstruct S {int a[];}            // illegalstruct S1 {char c; int a[];}   // okstruct S2 {struct S1 s1;}      // illegalsizeof(struct S1);             // 4

"this is along string";               // illegal"this string has tab    ";  // ok"must seprate \xF" "F";     // end with ‘F‘"base" L"wide";             // the same as L"basewide"char *str = "abcd";str[0] = ‘A‘;               // not definedsizeof("ab\0cd");           // 6"abcd"[2];                  // c

struct S {    int          a : 8;   // signed int or unsigned int    signed int   b : 16;    unsigned int c : 16;  // in one or two words};

// if u.i == 0x61626364, big endianunion U {    char c[4];    unsigned int i;} u = {"abcd"};

int *p = (int*)(const int[]){1, 2};p[0];                                // 1p[1] = 1;                            // not defined

void main(void);                  // no argument, no return(void)100;                        // drop the valuesizeof(void);                     // illegalsizeof(void*);                    // okvoid memset(void*, int, size_t);  // from <string.h>

　　空指针是一个特殊的指针常量，它不等于任何有意义的地址，它无法直接表示。常量0在特定语境下表示空指针，但最终的编译结果未必是0。NULL大部分时候指空指针，宏NULL一定要定义成对0的强制转换，以避免0的多义性。

#define NULL   ((void*)0)int null = NULL;           // maybe not 0printf("%p\n", 0);         // best NULL

　　还有一类指针常量就是静态存储的变量的地址以及函数的地址，它们可以用于初始化静态存储的变量（必须用常量初始化，见下章）。

typedef void (*fun_pnt)(void);extern void fun1(void);static void fun2(void){    static int a = 0;    static int *p = &a;        // ok}int b;int *p = &b;                   // okfun_pnt fp1 = &fun1;           // okfun_pnt fp2 = &fun2;           // ok

3. 类型转换

　　表达式中的操作符有时会引起操作数的类型转换（type conversion），本节对这类转换做一些总结。当新类型可以表示操作数时，转换后的值不变。任何度量类型转换为_Bool时，如果为0则转为0，否则转为1。向unsigned整型转换时，若操作数是整数则取模，若为浮点则去掉小数部分（整数部分若超出新类型则未定义），若为复数则先去掉虚部。向signed整型转换时，若操作数超出表示则未定义。向浮点数转换时，若无法精确表示则舍入方法未定义。向复数转换时，若操作数无虚部则结果虚部为0。

(int)100LL;             // 100(_Bool)NULL;            // 0(_Bool)NaN;             // 1(unsigned char)(-1);    // 255(int)3.9;               // 3(float)0x40001;         // maybe 0x4.0p4F or 0x4.0002p4F.(double _Complex)3.14;  // 3.14 + 0*I

　　整型和指针可以互相转换，但结果是未定义的。指针之间的转换也可以，但align不一致时未定义。甚至不同类型的函数指针也可以转换，但无意义。指针转换并不改变所指向地址的内容，用新指针取值时数据将被重新解释。

int i = 1;short *s = (short*)&i;*s;                    // 0 or 1

　　除了显式的强制转换外，还会发生一些隐式的转换，尤其常见于代数运算中。整型提升（integer promotion）将小整型提升为int或unsigned int，若int包含该小整型则转为int，否则转为unsigned int。整型提升仅发生于前置+-、~和移位的所有操作数，以及switch语句和常用代数转换中。常用代数转换（usual arithmatic conversion）发生在比较、算术（+-*/%）和位（&|^）运算中，它将两个操作数转换为相同的类型：

（1）若操作数中有浮点数，则向最高精度浮点数转换。但整数无需做整型提升，实数无需向复数转换。

（2）若操作数中没有浮点数，则先做整型提升。提升后若一个类型包含另一个，则转换为较大范围者，否则转换为较大范围的无符号类型。

unsigned char  c = ‘a‘;unsigned short s = 1;-c;                      // intc >> 1;                  // int~s;                      // unsigned int if short is the same size as int1 + 1.0*I;               // 1.0 + 1.0*Ic + s;                   // unsigned intc & 1;                   // int1 + 1LL;                 // long long(-1) > 1ULL;             // true, convert to unsigned long long

　　赋值操作、函数的参数传递和值返回也可以看做是隐式转换，当不知道函数参数的类型时，整型要做整型提升，float要转换为double（default argument promotion）。

extern void fun();char  c = ‘a‘;float f = 1.0f;fun(c);             // intprintf("%f\n", f);  // double

　　另外还有两个重要的隐式类型转换必须弄清楚，就是数组和函数。数组名即表示整个数组，但在除sizeof、_Alignof和&作用下，数组名自动转换为首元素的指针。字符串常量在以上3种情况和用作为数组初始化之外，也自动转换为首元素的指针。函数名是函数类型，在除sizeof和_Alignof作用下，函数名自动转换为相应函数类型的指针。

int a[2];sizeof(a);        // 8&a;               // pointer to an arraya;                // the same as &(a[0])char s1[] = "hi"; // arraychar *s2 = "hi";  // pointervoid fun(void) {}void (*pf)(void);pf = fun;         // the same as pf = &fun

【C】 03 - 数据类型