1. .extern
   函数内声明变量 x 和 y 为外部变量

extern int x;
extern int y;

2. 占位符

   %c 输出单个字符
   %s 输出字符串
   %p 输出指针地址
   %d 直接输出整数
   %f 是输出浮点数
   %d    以十进制形式输出带符号整数(正数不知输出符号)    
   %o    以八进制形式道输出无符号整数(不输出前缀0)    
   %x,%X    以十六进制形式回输出无符号整数(不输出前缀Ox)    
   %u    以十进制形式输出无符号整数    
   %f    以小数形式输出单、双精度实数    
   %e%,E    以指数形式输出单、双精度实数    
   %g,%G    以%f或%e中较短的输出宽度输出单、双精度实数    
   %c    输出单个字符    
   %s    输出字符串    
   %p    输出指针地址    
   %lu    32位无答符号整数    
   %llu    64位无符号整数
   

3. printf

printf(" thingy 为 %d ， count 为 %d\n", thingy, count);

1. register 存储类
   register 存储类用于定义存储在寄存器中而不是 RAM 中的局部变量。这意味着变量的最大尺寸等于寄存器的大小（通常是一个词），且不能对它应用一元的 ‘&’ 运算符（因为它没有内存位置）。

{register int  miles;
}

寄存器只用于需要快速访问的变量，比如计数器。还应注意的是，定义 ‘register’ 并不意味着变量将被存储在寄存器中，它意味着变量可能存储在寄存器中，这取决于硬件和实现的限制。

2. ^异或运算：
   首先异或表示当两个数的二进e799bee5baa6e58685e5aeb931333433623761制表示，进行异或运算时，当前位的两个二进制表示不同则为1相同则为0.该方法被广泛推广用来统计一个数的1的位数！参与运算的两个值，如果两个相应bit位相同，则结果为0，否则为1。即：　　0^0=0， 　　1^0=1， 　　0^1=1， 　　1^{1=0按位异或的3个特点:(1)0}0=0,0^1=1 0异或任何数＝任何数(2)1^0=1,11=0 1异或任何数－任何数取反(3)任何数异或自己＝把自己置0按位异或的几个常见用途:(1)使某些特定的位翻转 例如对数10100001的第2位和第3位翻转，则可以将该数与00000110进行按位异或运算。　　　　　 10100001^00000110=10100111(2)实现两个值的交换，而不必使用临时变量。

3. sizeof()
   sizeof() 返回变量的大小。sizeof(a) 将返回 4，其中 a 是整数。
   & 返回变量的地址。&a; 将给出变量的实际地址。

4. 指向一个变量。*a; 将指向一个变量。
   ? : 条件表达式如果条件为真 ? 则值为 X : 否则值为 Y

5. 无限循环

 for( ; ; ){printf("该循环会永远执行下去！\n");}

6. 函数申明

return_type function_name( parameter list );
int max(int num1, int num2);
//在函数声明中，参数的名称并不重要，只有参数的类型是必需的，因此下面也是有效的声明：
int max(int, int);

7. 数组申明

//声明
double balance[10];
//初始化
double balance[5] = {1000.0, 2.0, 3.4, 7.0, 50.0};
double balance[] = {1000.0, 2.0, 3.4, 7.0, 50.0};
//赋值
balance[4] = 50.0;
//多维数组
int threedim[5][10][4];
int a[3][4] = {0,1,2,3,4,5,6,7,8,9,10,11};

8. 枚举

//先定义枚举类型，再定义枚举变量
enum DAY
{MON=1, TUE, WED, THU, FRI, SAT, SUN
};
enum DAY day;
//定义枚举类型的同时定义枚举变量
enum DAY
{MON=1, TUE, WED, THU, FRI, SAT, SUN
} day;
//省略枚举名称，直接定义枚举变量
enum
{MON=1, TUE, WED, THU, FRI, SAT, SUN
} day;

9. 指针

/////////////////////指针声明//////////////
int    *ip;    /* 一个整型的指针 */
double *dp;    /* 一个 double 型的指针 */
float  *fp;    /* 一个浮点型的指针 */
char   *ch;     /* 一个字符型的指针 */
//////////////使用/////////////////////
#include <stdio.h> 
int main ()
{int  var = 20;   /* 实际变量的声明 */int  *ip;        /* 指针变量的声明 */ip = &var;  /* 在指针变量中存储 var 的地址 */printf("Address of var variable: %p\n", &var  );/* 在指针变量中存储的地址 */printf("Address stored in ip variable: %p\n", ip );/* 使用指针访问值 */printf("Value of *ip variable: %d\n", *ip );return 0;
}
/////////////////////传指针给函数/////////////////////
#include <stdio.h>
#include <time.h>
void getSeconds(unsigned long *par);
int main ()
{unsigned long sec;getSeconds( &sec );/* 输出实际值 */printf("Number of seconds: %ld\n", sec );return 0;
}
void getSeconds(unsigned long *par)
{/* 获取当前的秒数 */*par = time( NULL );return;
}
/////////////////////从函数返回指针/////////////////////
#include <stdio.h>
#include <time.h>
#include <stdlib.h> 
/* 要生成和返回随机数的函数 */
int * getRandom( )
{static int  r[10];int i; /* 设置种子 */srand( (unsigned)time( NULL ) );for ( i = 0; i < 10; ++i){r[i] = rand();printf("%d\n", r[i] );} return r;
} 
/* 要调用上面定义函数的主函数 */
int main ()
{/* 一个指向整数的指针 */int *p;int i;p = getRandom();for ( i = 0; i < 10; i++ ){printf("*(p + [%d]) : %d\n", i, *(p + i) );}return 0;
}
/////////////////////函数指针/////////////////////
#include <stdio.h> 
int max(int x, int y)
{return x > y ? x : y;
} 
int main(void)
{/* p 是函数指针 */int (* p)(int, int) = & max; // &可以省略int a, b, c, d;printf("请输入三个数字:");scanf("%d %d %d", & a, & b, & c); /* 与直接调用函数等价，d = max(max(a, b), c) */d = p(p(a, b), c);  printf("最大的数字是: %d\n", d); return 0;
}
/////////////////////回调函数/////////////////////
#include <stdlib.h>  
#include <stdio.h> 
// 回调函数
void populate_array(int *array, size_t arraySize, int (*getNextValue)(void))
{for (size_t i=0; i<arraySize; i++)array[i] = getNextValue();
} 
// 获取随机值
int getNextRandomValue(void)
{return rand();
} 
int main(void)
{int myarray[10];populate_array(myarray, 10, getNextRandomValue);for(int i = 0; i < 10; i++) {printf("%d ", myarray[i]);}printf("\n");return 0;
}

10. 结构

/////////////////////结构指针/////////////////////
struct Books *struct_pointer;
//现在，您可以在上述定义的指针变量中存储结构变量的地址。为了查找结构变量的地址，请把 & 运算符放在结构名称的前面，如下所示：
struct_pointer = &Book1;
//为了使用指向该结构的指针访问结构的成员，您必须使用 -> 运算符，如下所示：
struct_pointer->title;

11. 共用体

#include <stdio.h>
#include <string.h> 
union Data
{int i;float f;char  str[20];
}; 
int main( )
{union Data data;         data.i = 10;printf( "data.i : %d\n", data.i);   data.f = 220.5;printf( "data.f : %f\n", data.f);   strcpy( data.str, "C Programming");printf( "data.str : %s\n", data.str); return 0;
}

12. 位域

main(){struct bs{unsigned a:1;unsigned b:3;unsigned c:4;} bit,*pbit;bit.a=1;    /* 给位域赋值（应注意赋值不能超过该位域的允许范围） */bit.b=7;    /* 给位域赋值（应注意赋值不能超过该位域的允许范围） */bit.c=15;    /* 给位域赋值（应注意赋值不能超过该位域的允许范围） */printf("%d,%d,%d\n",bit.a,bit.b,bit.c);    /* 以整型量格式输出三个域的内容 */pbit=&bit;    /* 把位域变量 bit 的地址送给指针变量 pbit */pbit->a=0;    /* 用指针方式给位域 a 重新赋值，赋为 0 */pbit->b&=3;    /* 使用了复合的位运算符 "&="，相当于：pbit->b=pbit->b&3，位域 b 中原有值为 7，与 3 作按位与运算的结果为 3（111&011=011，十进制值为 3） */pbit->c|=1;    /* 使用了复合位运算符"|="，相当于：pbit->c=pbit->c|1，其结果为 15 */printf("%d,%d,%d\n",pbit->a,pbit->b,pbit->c);    /* 用指针方式输出了这三个域的值 */
}
//无名位域
struct k{int a:1;int  :2;    /* 该 2 位不能使用 */int b:3;int c:2;
};

13. typedef
    typedef 仅限于为类型定义符号名称，#define 不仅可以为类型定义别名，也能为数值定义别名，比如您可以定义 1 为 ONE。
    typedef 是由编译器执行解释的，#define 语句是由预编译器进行处理的。

14. C 输入 & 输出
    标准输入stdin键盘
    标准输出stdout屏幕
    标准错误stderr您的屏幕
    getchar() & putchar() 函数
    gets() & puts() 函数
    scanf() 和 printf() 函数

15. C 文件读写

//打开文件
FILE *fopen( const char * filename, const char * mode );
//在这里，filename 是字符串，用来命名文件，访问模式 mode 的值可以是下列值中的一个：
//模式描述
//r打开一个已有的文本文件，允许读取文件。
//w打开一个文本文件，允许写入文件。如果文件不存在，则会创建一个新文件。在这里，您的程序会从文件的开头写入内容。如果文件存在，则该会被截断为/零长度，重新写入。
//a打开一个文本文件，以追加模式写入文件。如果文件不存在，则会创建一个新文件。在这里，您的程序会在已有的文件内容中追加内容。
//r+打开一个文本文件，允许读写文件。
//w+打开一个文本文件，允许读写文件。如果文件已存在，则文件会被截断为零长度，如果文件不存在，则会创建一个新文件。
//a+打开一个文本文件，允许读写文件。如果文件不存在，则会创建一个新文件。读取会从文件的开头开始，写入则只能是追加模式。
//如果处理的是二进制文件，则需使用下面的访问模式来取代上面的访问模式：
//"rb", "wb", "ab", "rb+", "r+b", "wb+", "w+b", "ab+", "a+b"
//关闭文件
int fclose( FILE *fp );
//写入文件
int fputc( int c, FILE *fp );
//函数 fputc() 把参数 c 的字符值写入到 fp 所指向的输出流中。如果写入成功，它会返回写入的字符，如果发生错误，则会返回 EOF。您可以使用下面的函数来把一个以 null 结尾的字符串写入到流中： 
int fputs( const char *s, FILE *fp );
//函数 fputs() 把字符串 s 写入到 fp 所指向的输出流中。如果写入成功，它会返回一个非负值，如果发生错误，则会返回 EOF。您也可以使用 int fprintf(FILE *fp,const char *format, ...) 函数来写把一个字符串写入到文件中。尝试下面的实例：
//实例
#include <stdio.h> 
int main()
{FILE *fp = NULL; fp = fopen("/tmp/test.txt", "w+");fprintf(fp, "This is testing for fprintf...\n");fputs("This is testing for fputs...\n", fp);fclose(fp);
}
//读取文件
//下面是从文件读取单个字符的最简单的函数：
int fgetc( FILE * fp );
//fgetc() 函数从 fp 所指向的输入文件中读取一个字符。返回值是读取的字符，如果发生错误则返回 EOF。下面的函数允许您从流中读取一个字符串：
char *fgets( char *buf, int n, FILE *fp );
//函数 fgets() 从 fp 所指向的输入流中读取 n - 1 个字符。它会把读取的字符串复制到缓冲区 buf，并在最后追加一个 null 字符来终止字符串。
//如果这个函数在读取最后一个字符之前就遇到一个换行符 '\n' 或文件的末尾 EOF，则只会返回读取到的字符，包括换行符。您也可以使用 int fscanf(FILE *fp, const char *format, ...) 函数来从文件中读取字符串，但是在遇到第一个空格和换行符时，它会停止读取。
//实例
#include <stdio.h> 
int main()
{FILE *fp = NULL;char buff[255]; fp = fopen("/tmp/test.txt", "r");fscanf(fp, "%s", buff);printf("1: %s\n", buff ); fgets(buff, 255, (FILE*)fp);printf("2: %s\n", buff );   fgets(buff, 255, (FILE*)fp);printf("3: %s\n", buff );fclose(fp); 
}
//二进制 I/O 函数
//下面两个函数用于二进制输入和输出：
size_t fread(void *ptr, size_t size_of_elements, size_t number_of_elements, FILE *a_file);              
size_t fwrite(const void *ptr, size_t size_of_elements, size_t number_of_elements, FILE *a_file);
//这两个函数都是用于存储块的读写 - 通常是数组或结构体。

16. C 预处理器
    #define定义宏
    #include包含一个源代码文件
    #undef取消已定义的宏
    #ifdef如果宏已经定义，则返回真
    #ifndef如果宏没有定义，则返回真
    #if如果给定条件为真，则编译下面代码
    #else#if 的替代方案
    #elif如果前面的 #if 给定条件不为真，当前条件为真，则编译下面代码
    #endif结束一个 #if……#else 条件编译块
    #error当遇到标准错误时，输出错误消息
    #pragma使用标准化方法，向编译器发布特殊的命令到编译器中

//预定义宏
//ANSI C 定义了许多宏。在编程中您可以使用这些宏，但是不能直接修改这些预定义的宏。
//宏描述
//__DATE__当前日期，一个以 "MMM DD YYYY" 格式表示的字符常量。
//__TIME__当前时间，一个以 "HH:MM:SS" 格式表示的字符常量。
//__FILE__这会包含当前文件名，一个字符串常量。
//__LINE__这会包含当前行号，一个十进制常量。
//__STDC__当编译器以 ANSI 标准编译时，则定义为 1。
#include <stdio.h>
main()
{printf("File :%s\n", __FILE__ );printf("Date :%s\n", __DATE__ );printf("Time :%s\n", __TIME__ );printf("Line :%d\n", __LINE__ );printf("ANSI :%d\n", __STDC__ );
}
//预处理器运算符
//*宏延续运算符（\）
//一个宏通常写在一个单行上。但是如果宏太长，一个单行容纳不下，则使用宏延续运算符（\）。例如：
#define  message_for(a, b)  \printf(#a " and " #b ": We love you!\n")
//*字符串常量化运算符（#）
//在宏定义中，当需要把一个宏的参数转换为字符串常量时，则使用字符串常量化运算符（#）。在宏中使用的该运算符有一个特定的参数或参数列表。例如：
#include <stdio.h>
#define  message_for(a, b)  \printf(#a " and " #b ": We love you!\n")
int main(void)
{message_for(Carole, Debra);return 0;
}
//当上面的代码被编译和执行时，它会产生下列结果：
Carole and Debra: We love you!
//*标记粘贴运算符（##）
//宏定义内的标记粘贴运算符（##）会合并两个参数。它允许在宏定义中两个独立的标记被合并为一个标记。例如：
#include <stdio.h>
#define tokenpaster(n) printf ("token" #n " = %d", token##n)
int main(void)
{int token34 = 40;tokenpaster(34);return 0;
}
//当上面的代码被编译和执行时，它会产生下列结果：
token34 = 40
//这是怎么发生的，因为这个实例会从编译器产生下列的实际输出：
printf ("token34 = %d", token34);
//*defined() 运算符
//预处理器 defined 运算符是用在常量表达式中的，用来确定一个标识符是否已经使用 #define 定义过。如果指定的标识符已定义，则值为真（非零）。如果指定的标识符未定义，则值为假（零）。下面的实例演示了 defined() 运算符的用法：
#include <stdio.h>
#if !defined (MESSAGE)#define MESSAGE "You wish!"
#endif
int main(void)
{printf("Here is the message: %s\n", MESSAGE);  return 0;
}
//当上面的代码被编译和执行时，它会产生下列结果：
Here is the message: You wish!

17. C 头文件

//引用头文件的语法
//使用预处理指令 #include 可以引用用户和系统头文件。它的形式有以下两种：
#include <file>
//这种形式用于引用系统头文件。它在系统目录的标准列表中搜索名为 file 的文件。在编译源代码时，您可以通过 -I 选项把目录前置在该列表前。
#include "file"
//这种形式用于引用用户头文件。它在包含当前文件的目录中搜索名为 file 的文件。在编译源代码时，您可以通过 -I 选项把目录前置在该列表前。

18. 可变参数
    需要使用 stdarg.h 头文件~

//定义一个函数，最后一个参数为省略号，省略号前面可以设置自定义参数。
//在函数定义中创建一个 va_list 类型变量，该类型是在 stdarg.h 头文件中定义的。
//使用 int 参数和 va_start 宏来初始化 va_list 变量为一个参数列表。宏 va_start 是在 stdarg.h 头文件中定义的。
//使用 va_arg 宏和 va_list 变量来访问参数列表中的每个项。
//使用宏 va_end 来清理赋予 va_list 变量的内存。
//现在让我们按照上面的步骤，来编写一个带有可变数量参数的函数，并返回它们的平均值：
//实例
#include <stdio.h>
#include <stdarg.h> 
double average(int num,...)
{ va_list valist;double sum = 0.0;int i; /* 为 num 个参数初始化 valist */va_start(valist, num); /* 访问所有赋给 valist 的参数 */for (i = 0; i < num; i++){sum += va_arg(valist, int);}/* 清理为 valist 保留的内存 */va_end(valist); return sum/num;
} 
int main()
{printf("Average of 2, 3, 4, 5 = %f\n", average(4, 2,3,4,5));printf("Average of 5, 10, 15 = %f\n", average(3, 5,10,15));
}
//当上面的代码被编译和执行时，它会产生下列结果。应该指出的是，函数  average() 被调用两次，每次第一个参数都是表示被传的可变参数的总数。省略号被用来传递可变数量的参数。
Average of 2, 3, 4, 5 = 3.500000
Average of 5, 10, 15 = 10.000000~

19. C 内存管理
    C 语言为内存的分配和管理提供了几个函数。这些函数可以在 <stdlib.h> 头文件中找到。
    序号函数和描述

void *calloc(int num, int size);

在内存中动态地分配 num 个长度为 size 的连续空间，并将每一个字节都初始化为 0。所以它的结果是分配了 num*size 个字节长度的内存空间，并且每个字节的值都是0。

void free(void *address); 

该函数释放 address 所指向的内存块,释放的是动态分配的内存空间。

void *malloc(int num); 

在堆区分配一块指定大小的内存空间，用来存放数据。这块内存空间在函数执行完成后不会被初始化，它们的值是未知的。

void *realloc(void *address, int newsize); 

该函数重新分配内存，把内存扩展到 newsize。