C

1990 年，国际标准化组织 ISO（International Organization for Standards）接受了 89 ANSI C 为 ISO C 的标准（ISO 9899-1990），这个版本被称为 ANSI C。 1999 年，ISO 又对 C 语言标准进行修订，在基本保留原来 C 语言特征的基础上，针对应该的需要，增加了一些功能，命名为 ISO/IEC9899:1999。2011 年 12 月 8 日，ISO 正式公布 C 语言新的标准：ISO/IEC 9899:2011，即 C11。

The latest publically available version of the C99 standard is the combined C99 + TC1 + TC2 + TC3, WG14 N1256, dated 2007-09-07.
The latest publically available version of the C11 standard is the document WG14 N1570, dated 2011-04-12.

C 标准头文件的变化如表 1 所示。

参考：
C committee website: http://www.open-std.org/jtc1/sc22/wg14/
ISO/IEC 9899 - Programming languages - C: http://www.open-std.org/jtc1/sc22/wg14/www/standards

typedef 可以为现有类型创建一个新的名字， typedef 并不创建新的类型。它的用法如下：

typedef existing_type new_type_name;

下面是 typedef 的例子：

typedef char C;
typedef unsigned int WORD;

C 语言运算符位于 15 个优先级中，同一优先级的运算符，其运算先后顺序由结合性决定。

Following table lists C operators in order of precedence (highest to lowest). Their associativity indicates in what order operators of equal precedence in an expression are applied.

+-----------------+--------------------------------------------+---------------+
|    Operator     |          Description                       | Associativity |
+-----------------+--------------------------------------------+---------------+
| ()              | Function call                              | left-to-right |
| []              | Array subscript                            |               |
| .               | Member of structure via object name        |               |
| ->              | Member of structure via pointer            |               |
+-----------------+--------------------------------------------+---------------+
| ++ --           | Increment/decrement                        | right-to-left |
| + -             | Unary plus/minus                           |               |
| ! ~             | Logical negation/bitwise complement        |               |
| (type)          | Case                                       |               |
| *               | Dereference                                |               |
| &               | Address (of operand)                       |               |
| sizeof          | Determine size in bytes                    |               |
+-----------------+--------------------------------------------+---------------+
| *  /  %         | Multiplication/division/modulus            | left-to-right |
+-----------------+--------------------------------------------+---------------+
| + -             | Addition/subtraction                       | left-to-right |
+-----------------+--------------------------------------------+---------------+
| <<  >>          | Bitwise shift left, Bitwise shift right    | left-to-right |
+-----------------+--------------------------------------------+---------------+
| <  <=           | Less than/less than or equal to            | left-to-right |
| >  >=           | Greater than/greater than or equal to      |               |
+-----------------+--------------------------------------------+---------------+
| ==  !=          | Equal to/not equal to                      | left-to-right |
+-----------------+--------------------------------------------+---------------+
| &               | Bitwise AND                                | left-to-right |
+-----------------+--------------------------------------------+---------------+
| ^               | Bitwise exclusive OR                       | left-to-right |
+-----------------+--------------------------------------------+---------------+
| |               | Bitwise inclusive OR                       | left-to-right |
+-----------------+--------------------------------------------+---------------+
| &&              | Logical AND                                | left-to-right |
+-----------------+--------------------------------------------+---------------+
| ||              | Logical OR                                 | left-to-right |
+-----------------+--------------------------------------------+---------------+
| ? :             | Ternary conditional                        | right-to-left |
+-----------------+--------------------------------------------+---------------+
| =               | Assignment                                 | right-to-left |
| += -=           | Addition/subtraction assignment            |               |
| *= /=           | Multiplication/division assignment         |               |
| %= &=           | Modulus/bitwise AND assignment             |               |
| ^= |=           | Bitwise exclusive/inclusive OR assignemnt  |               |
| <<= >>=         | Bitwise shift left/right assignment        |               |
+-----------------+--------------------------------------------+---------------+
| ,               | Comma (separate expressions)               | left-to-right |
+-----------------+--------------------------------------------+---------------+

从上表中，可得知运算符的优先级有下面规律：

初等运算符 () [] . ->
    ↓
单目运算符
    ↓
算术运算符（先乘除和模运算，后加减）
    ↓
关系运算符
    ↓
逻辑运算符（不包括单目运算符!）
    ↓
条件运算符
    ↓
赋值运算符
    ↓
逗号运算符

其中，位运算符的优先级比较分散：按位取反是单目运算符，左移右移在关系运算符之前，而 &, ^, | 在关系运算符之后。

参考：
http://www.difranco.net/compsci/C_Operator_Precedence_Table.htm
The C Programming Language, 2nd, 2.12 Precedence and Order of Evaluation

C 语言的位操作符有 &, |, ^, ~, >>, << 。表 3 是前 3 个操作符 &, |, ^ 的真值表。

其中，“异或”（XOR）操作符 ^ 规则： 按位操作，两个操作数不相同时为 1，相同时为 0。

异或操作符可以用于加密。比如明文为 text，而密钥为 security，它们异或后得到密文：

text ^ security = ciphertext

拿密文 ciphertext 和密钥 security 再进行一次异或就可以解密：

security ^ ciphertext = text

结构体的内存对齐有两点要注意：

1. 每个成员变量的首地址，必须是它的类型的对齐值的整数倍，如果不是，则它与前一个成员变量之间要填充一些字节来满足要求；
   
2. 整个结构体的大小，必须是该结构体中所有成员的类型中对齐值最大者的整数倍，如果不是，则在最后一个成员后面填充一些字节以满足要求。
   

A pointer is a variable that contains the address of a variable.

The unary operator & gives the address of an object.
The unary operator *, when applied to a pointer, it accesses the object the pointer points to.

"Decay" refers to the implicit conversion of an expression from an array type to a pointer type.

int a[] = { 1, 3, 5, 7, 9 };
int *p = a;

You lose the ability of the sizeof operator to count elements in the array:

printf("%zu\n", sizeof(a));   // 输出: 20, 可算出数组中有5个元素
printf("%zu\n", sizeof(p));   // 64位机器中输出: 8, 无法推算出对应数组的元素个数

This lost ability is referred to as "decay".

参考：http://stackoverflow.com/questions/1461432/what-is-array-decaying

Since the name of an array is a synonym for the location of the initial element, the assignment pa=&a[0] can also be written as pa = a.

int a[10];             /* defines an array of size 10 */
int *pa;
pa = &a[0];            /* sets pa to point to a[0] */
pa = a;                /* same as above */

C converts a[i] to *(a+i) immediately, the two forms are always equivalent.
Thus, &a[i] and a+i are also identical.

定义了一个二维数组 a ：

int a[2][4] = { {0,1,2,3}, {4,5,6,7} };

可以通过 a[0][0] ， a[0][1] 等访问二维数组的各个元素。

C 编译器总是做这样的转换 a[i][j] = *(a[i] + j) = *(*(a+i) + j)

初值个数小于数组长度，其余的所有元素会被自动设置为空字符 \0 。

char c[5]={'a', 'b'};
char c[5]={'a', 'b', '\0', '\0', '\0'};

上面两个定义相同。

char c[]={"I am happy"};
char c[]="I am happy";
char c[]={'I',' ','a','m',' ','h','a','p','p','y','\0'};

上面三种方式是等价的（长度为 11）。注意，它们和下面数组（长度为 10）是不同的。

char c[]={'I',' ','a','m',' ','h','a','p','p','y'};

什么时候会用到指针的指针呢？

• The name of an array usually yields the address of its first element. So if the array contains elements of type t, a reference to the array has type t *. Now consider an array of arrays of type t: naturally a reference to this 2D array will have type (t *)* = t **, and is hence a pointer to a pointer.
  
• Even though an array of strings sounds one-dimensional, it is in fact two-dimensional, since strings are character arrays. Hence: char **.
  
• A function f will need to accept an argument of type t ** if it is to alter a variable of type t *.
  
• Many other reasons that are too numerous to list here.
  

参考：http://stackoverflow.com/questions/897366/how-do-pointer-to-pointers-work-in-c

storage-class-specifier 语法：

storage-class-specifier:
    typedef
    extern
    static
    auto
    register

注 1：一个变量最多用一个 storage-class-specifier
注 2：typedef 和存储类型没有任何关系，把它们放在一起仅是为了简化语法规则。
The typedef specifier is called a 'storage-class specifier' for syntactic convenience only.

参考：
http://stackoverflow.com/questions/8674236/is-typedef-a-storage-class-specifier
ISO&IEC-9899-1999(E), 6.7.1 Storage-class specifiers

type-specifier 语法：

type-specifier:
    void
    char
    short
    int
    long
    float
    double
    signed
    unsigned
    _Bool
    _Complex
    _Imaginary
    struct-or-union-specifier
    enum-specifier
    typedef-name

Type specifiers 可以指定多个，如 unsigned int 等。

参考：ISO&IEC-9899-1999(E), 6.7.2 Type specifiers

type-qualifier 语法：

type-qualifier:
    const
    restrict
    volatile

注：标准中没有限定一个变量最多用一个 type qualifier，下面是一个同时使用 const 和 volatile 的例子：

extern const volatile int real_time_clock
/* real_time_clock may be modifiable by hardware, but cannot
   be assigned to, incremented, or decremented. */

参考：ISO&IEC-9899-1999(E), 6.7.3 Type qualifiers

C 语言中的声明可以写得非常复杂，用下面的优先级规则可以帮助理解。

C 语言声明的优先级规则

A 声明从它的名字开始读取，然后按照优先级顺序依次读取。
B 优先级从高到低依次是：
  B.1 声明中被括号括起来的那部分。
  B.2 后缀操作符：括号()表示这是一个函数，而方括号[]表示这是一个数组。
  B.3 前缀操作符：星号*表示“指向...的指针”。
C 如果const和（或）volatile关键字的后面紧跟类型说明符（如int,long等），那么它作用于类型说明符。在其他情况下，const和（或）volatile关键字作用于它左边紧邻的指针星号。

参考：
C 专家编程 3.3 节
C 声明在线分析 http://cdecl.org/

``Definition'' refers to the place where the variable is created or assigned storage; ``declaration'' refers to places where the nature of the variable is stated but no storage is allocated.

if 语句形式一：

if (expression)
  statement1
else
  statement2

where the else part is optional.

if 语句形式二：

if (expression)
  statement
else if (expression)
  statement
else if (expression)
  statement
else if (expression)
  statement
else
  statement

where the else part is optional.

The switch statement is a multi-way decision that tests whether an expression matches one of a number of constant integer values, and branches accordingly.

switch (expression) {
  case const-expr: statements
  case const-expr: statements
  default: statements
}

Each case is labeled by one or more integer-valued constants or constant expressions. If a case matches the expression value, execution starts at that case. All case expressions must be different. The case labeled default is executed if none of the other cases are satisfied. A default is optional; if it isn't there and if none of the cases match, no action at all takes place. Cases and the default clause can occur in any order.

The break statement causes an immediate exit from the switch.

C 语言中有三种循环语句，分别如图 2，图 3，及图 4 所示。

C 中 break 和 continue 如表 6 所示。

说明： switch 语句中 continue 无意义，若有 continue 则属于外层的循环语句。

goto 和 label 的使用是 local to function，即只在函数内有效。

In C, all function arguments are passed by value. This means that the called function is given the values of its arguments in temporary variables rather than the originals. This leads to some different properties than are seen with call by reference languages like Fortran or with var parameters in Pascal, in which the called routine has access to the original argument, not a local copy.

When the name of an array is used as an argument, the value passed to the function is the address of the beginning of the array - there is no copying of array elements.

如何实现函数的变长参数？

在 C89 中，头文件 stdarg.h 中定义了一个类型 va_list ，三个宏 va_start, va_arg, va_end 。

如何让宏也支持变长参数呢？

在 C89 中无法优雅地实现，C FAQ 10.26 中有一些不太好的方法。

在 C99 中能很好地支持宏的变长参数。
C99 introduces formal support for function-like macros with variable-length argument lists. The notation ... can appear at the end of the macro ``prototype'' (just as it does for varargs functions), and the pseudomacro __VA_ARGS__ in the macro definition is replaced by the variable arguments during invocation.

实例：带变长参数的宏

#define XXX(...) fun1(__VA_ARGS__)

参考：http://c-faq.com/cpp/varargs.html

A function pointer is a variable that stores the address of a function that can later be called through that function pointer.

参考：
http://www.cprogramming.com/tutorial/function-pointers.html
http://www.newty.de/fpt/fpt.html#chapter2

Any source line of the form:

#include "filename"   /* 先搜索当前文件所在目录，再搜索系统目录 */

or

#include <filename>   /* 仅搜索系统目录 */

is replaced by the contents of the file filename.

#define token replacement

Each token will be replaced by the replacement text.
Substitutions are made only for tokens, and do not take place within quoted strings.

Names may be undefined with #undef, usually to ensure that a routine is really a function, not a macro:

#undef getchar
int getchar(void) { ... }

The #if line evaluates a constant integer expression (which may not include sizeof, casts, or enum constants). If the expression is non-zero, subsequent lines until an #endif or #elif or #else are included.

The #ifdef and #ifndef lines are specialized forms that test whether a name is defined.

A #line directive sets the compiler's setting for the current file name and line number.

Directives #line alter the results of the __FILE__ and __LINE__ predefined macros from that point on.

It's also used by other tools that generate C source code, such as lex/flex and yacc/bison, so that error messages can refer to the input file rather than the (temporary) generated C code.

A line of the form:

#line number

sets the current line number.

A line of the form:

#line number "file-name"

sets both the line number and the file name.

参考：
https://gcc.gnu.org/onlinedocs/cpp/Line-Control.html
http://stackoverflow.com/questions/7109540/line-keyword-in-c

A preprocessing directive of the form:

#error error-message

causes the implementation to produce a diagnostic message that includes the specified sequence of preprocessing tokens.

参考：
https://gcc.gnu.org/onlinedocs/cpp/Pragmas.html#Pragmas
https://gcc.gnu.org/onlinedocs/gcc/Pragmas.html#Pragmas

C 中有一些预定义的宏，方便用户程序使用，如表 7 所示。

说明：什么是 hosted environment?
A hosted environment has the complete facilities of the standard C library available.

表 8 中三个宏在 C99 中增加，它们的定义由实现决定，编译器如果支持，就会设置。

参考：ISO&IEC-9899-1999(E) 6.10.8 Predefinded macro names

__func__ 是 C 语言中函数体内预定义的标识符，它会被自动设置为当前函数的名字。相当于在每个函数定义的第一行就有下面的声明一样。

static const char __func__[] = "function-name";

实例：调用下面函数时会输出函数名 myfunc

#include <stdio.h>
void myfunc(void)
{
    printf("%s\n", __func__);
    /* ... */
}

参考：ISO&IEC-9899-1999(E) 6.4.2.2 Predefinded identifiers

The printf functions provide formatted output conversion.

int fprintf(FILE *stream, const char *foramt, ...)

The format string contains two types of objects: ordinary characters, which are copied to the output stream, and conversion specification.
Each conversion specification begins with the character % and ends with a conversion specifier character (see table 9). Between the % and the conversion specifier there may be, in order:

• Zero or more flags (in any order).
  
• An optional minimum field width. The field width takes the form of an asterisk (*) or a decimal integer. 其中使用星号时的含义参考节 12.1.3
  
• An optional precision that gives the minimum number of digits to appear for the d, i, o, u, x, and X conversions, the number of digits to appear after the decimal-point character for a, A, e, E, f, and F conversions, the maximum number of significant digits for the g and G conversions, or the maximum number of bytes to be written for s conversions. The precision takes the form of a period (.) followed either by an asterisk (*) or by an optional decimal integer; if only the period is specified, the precision is taken as zero. 其中使用星号时的含义参考节 12.1.3
  
• An optional period, which separates the field width from the precison.
  
• An optional precision.
  
• An optional length modifier.
  

下面是 printf 中 %n 用法实例：

#include <stdio.h>
int main()
{
    int count1;
    int count2;

    printf("ABCDE%nFGHI%n\n", &count1, &count2);
    printf("First count is %d, second count is %d.\n", count1, count2);
    // 上行会输出 First count is 5, second count is 9.
    return 0;
}

The scanf functions deal with formatted input conversion.

int fscanf(FILE *stream, const char *format, ...)

fscanf reads from stream under control of format, and assigns converted values through subsequent arguments, each of which must be a pointer. It returns when format is exhausted. fscanf returns EOF if end of file or an error occurs before any conversion; otherwise it returns the number of input items converted and assigned.

注意：scanf 系列函数中的 format 和 printf 中有些类似，但也有很多不同。如 scanf 不能做精度控制等等。

参考：ISO&IEC-9899-1999(E) 7.19.6.2 The fscanf function

strncat 的原型为：

char *strncat(char *dest, const char *src, size_t n);

它能保证 dest 最后一个字符为'\0'。
但如果 src 等于或大于 n 时，它会复制 n+1（最后一个为'\0'）个字符到 dest。

特别说明：strncat 并不是为了提供一安全版本的 strcat（如果 dest 不够长，strncat 将不安全），而仅仅只是提供“连接字符串 src 中前 n 个字符到 dest 末尾”的功能。

char buf[4] = "ab";
char *src = "1234567890";
strncat(buf, src, 8);     /* 错误用法！不安全，因为buf太小！ */

下面用法是错误的，当 src 很长时，可能会非法写入 dest 之后的一个字节。
strncat(dest, src, sizeof(dest) - strlen(dest));

strncat 的常见用法（这种用法是安全的，但 src 很长时，可能只会复制 src 的部分内容到 dest 末尾）：

strncat(dest, src, sizeof(dest) - 1 - strlen(dest));

strncpy 的原型为：

char *strncpy(char *dest, const char *src, size_t n);

把字符串 src 的前 n 个字节复制到 dest 开始的地址空间中，并返回 dest。

特别注意，strncpy 不会自动添加\0，如：

#include<stdio.h>
#include<string.h>

int main() {

  char a[10] = "aaaaaaaaaa";
  strncpy(a, "01234567890abcd", 5);

  printf("%s\n", a);                /* 会输出 01234aaaaa */
  return 0;
}

strncpy 可能不正确的用法（如果 dest 在使用前已经初始化过，则没有问题）：
strncpy(dest, src, sizeof(dest) - 1);
它不能保证 dest 以 0 结束，除非调用函数前 dest 的最后一个字节为 0。

strncpy 的安全用法：

strncpy(dest, src, sizeof(dest));
dest[sizeof(dest)-1] = '\0';       // 防止安全隐患，请手工把最后一字节填充\0

strncpy 说明：
1.如果想要防止溢出，size 应该写为 sizeof(dest)或 sizeof(dest)-1，不可误用 sizeof(src)。
2.它有安全隐患，务必要把 dest 的最后一个字节手工设置为\0。strncpy 仅在 src 的长度小于 n 时，才会填充 n-strlen(str)个字节的\0。
3.性能问题。 当 dest 长度远大于 src 时，strncpy(dest, src, sizeof(dest));会对多余的每个字节填\0，会有性能损失。
4.返回值。strncpy 返回 dest，因而无法知道拷贝了多少个字节。

snprintf 也可用来复制字符串。
snprintf 的正确用法：

snprintf(dest, sizeof(dest), "%s", src);

snprintf 说明：
1.不可省略第三个参数"%s"，因为存在隐患： 省略第三个参数时，如果 src 中包含%，会引发 core。
2.性能问题。当 src 长度远大于 dest 时，由于 snprintf 要返回 src 的字节数，需要扫描 src，会有性能损失。
3.返回值。如果当前 buf 够用，返回实际写入的字符数；如果不够用，返回将要写入的字符数。

strncpy 和 snprintf 总结：
1.snprintf 使用比 strncpy 简洁。
2.snprintf 可以获取被拷贝的字节数。
3.二者都有性能问题。
4.strncpy 不安全！snprintf 安全（能保证在字符串结尾一定有'\0'）。

参考：
http://www.jb51.net/article/39994.htm

strspn stands for string span
strcspn stands for string complement span
strpbrk stands for string pointer break

参考：http://www.gnu.org/savannah-checkouts/gnu/libc/manual/html_node/Search-Functions.html

strtok 用于按指定的分隔符把某字符串分解为一组字符串。

在第一次调用时，strtok 必需给予参数 s 字符串，往后的调用则将参数 s 设置成 NULL。每次调用成功则返回指向被分割出片段的指针。

注：strtok 是一个线程不安全的函数，因为它使用了静态分配的空间来存储被分割的字符串位置。 strtok_r 函数是 strtok 函数的可重入版本。

memcpy 从内存地址 src 处复制 n 字节到地址 dest 处。

#include <string.h>
void *memcpy(void *dest, const void *src, size_t n);

                                 /* returns a pointer to dest. */

说明：如果 src 和 dest 内存有重叠（这时应该使用 memmove），memcpy 能否正常工作取决于具体的实现，不过很多 memcpy 实现都能正确处理内存重叠的情况。

去掉字符串前后空格：

// Note: This function returns a pointer to a substring of the original string.
// If the given string was allocated dynamically, the caller must not overwrite
// that pointer with the returned value, since the original pointer must be
// deallocated using the same allocator with which it was allocated.  The return
// value must NOT be deallocated using free() etc.
char *trimwhitespace(char *str)
{
  char *end;

  // Trim leading space
  while(isspace(*str))
     str++;

  if(*str == 0)  // All spaces?
    return str;

  // Trim trailing space
  end = str + strlen(str) - 1;
  while(end > str && isspace(*end))
    end--;

  // Write new null terminator
  *(end+1) = 0;

  return str;
}

参考：http://stackoverflow.com/questions/122616/how-do-i-trim-leading-trailing-whitespace-in-a-standard-way

See table 12, table 13, table 14, table 15, table 16, table 17.

For a summary of input and output functions, please refers to man stdio

See table 18.

See table 19.

See table 20.

goto 语句只能在一个函数的内部跳转，可称为 local jumps。用 setjmp, longjmp 可实现 non-local jumps。

The declarations in <setjmp.h> provide a way to avoid the normal function call and return sequence, typically to permit an immediate return from a deeply nested function call.

int setjmp(jmp_buf env)
    The macro setjmp saves state information in env for use by longjmp. The return is zero from a direct call of setjmp, and non-zero from a subsequent call of longjmp. A call to setjmp can only occur in certain contexts, basically the test of if, switch, and loops, and only in simple relational expressions.
    if (setjmp(env) == 0)
        /* get here on direct call */
    else
        /* get here by calling longjmp */

void longjmp(jmp_buf env, int val)
    longjmp restores the state saved by the most recent call to setjmp, using the information saved in env, and execution resumes as if the setjmp function had just executed and returned the non-zero value val. The function containing the setjmp must not have terminated. Accessible objects have the values they had at the time longjmp was called, except that non-volatile automatic variables in the function calling setjmp become undefined if they were changed after the setjmp call.

setjmp, longjmp 实例：

/* setjmp example: error handling */
#include <stdio.h>      /* printf, scanf */
#include <stdlib.h>     /* exit */
#include <setjmp.h>     /* jmp_buf, setjmp, longjmp */

int main()
{
  jmp_buf env;
  int val;

  val = setjmp (env);
  if (val) {
    fprintf (stderr, "Error %d happened\n", val);
    exit (val);
  }

  /* code here */

  longjmp (env, 101);   /* signaling an error when something wrong. 会跳到之前调用setjmp的位置处执行 */

  return 0;
}

上面程序会输出：

Error 101 happened

参考：http://www.cplusplus.com/reference/csetjmp/setjmp/

See table 20.

See table 22.

struct tm is defined in time.h

struct tm {
	int	tm_sec;		/* seconds after the minute [0-60] */
	int	tm_min;		/* minutes after the hour [0-59] */
	int	tm_hour;	/* hours since midnight [0-23] */
	int	tm_mday;	/* day of the month [1-31] */
	int	tm_mon;		/* months since January [0-11] */
	int	tm_year;	/* years since 1900 */
	int	tm_wday;	/* days since Sunday [0-6] */
	int	tm_yday;	/* days since January 1 [0-365] */
	int	tm_isdst;	/* Daylight Savings Time flag */
	long tm_gmtoff;	/* offset from CUT in seconds */
	char *tm_zone;	/* timezone abbreviation */
};

实例 1：计算程序中执行某段代码的 CPU 时间

#include <stdio.h>
#include <time.h>

int main() {
    clock_t begin = clock();
    // Do stuff
    clock_t end = clock();
    double elapsed = (double)(end - begin) * 1000.0 / CLOCKS_PER_SEC;
    printf("CPU Time elapsed in milliseconds: %f", elapsed);
}

参考：http://www.gnu.org/software/libc/manual/html_node/CPU-Time.html

实例 2：计算程序中执行某段代码的时间

#include <time.h>

int main() {
    time_t start, end;
    time(&start);
    // Do stuff
    time(&end);
    double duration = difftime(end, start);
    printf("Time elapsed in seconds: %f", elapsed);
}

void assert(int expression)
If expression is zero, the assert macro will print on stderr a message, such as

Assertion failed: expression, file filename, line nnn

If NDEBUG is defined at the time <assert.h> is included, the assert macro is ignored.

On any modern UNIX you'll get a thread-safe malloc by default. On Windows, use /MT, /MTd, /MD or /MDd flags to get thread-safe runtime library.

参考：
http://stackoverflow.com/questions/855763/is-malloc-thread-safe
http://www.360doc.com/content/12/0420/23/168576_205320609.shtml

不要用 calloc 来初始化 NULL 指针， C 语言的标准并没有规定 NULL 指针一定是 all bits zero(每字节都为 0)。 事实上，有些平台存在 nonzero NULL。

参考：
http://c-faq.com/null/machexamp.html
http://stackoverflow.com/questions/13251499/calloc-pointers-and-all-bits-zero