C语言 深入学习
浮点数：
x = Mx*2^Ex为一个规格化浮点数，Mx为x的尾数，Ex为x的阶码。
1e-6：表示1 * 10 ^ (-6)。
编译时执行：
sizeof是运算符（而非函数），在编译时执行，不会导致额外的运行时间开销。
三元运算符：是右结合运算。
数据类型：
char:占1个字节 short:占2个字节 int:占4个字节 float:占4个字节 double:占8个字节 一个变量本身定义为常量const时，必须初始化 常量指针：不能通过常量指针修改其指向的值（只是从p的角度来看）。 const int *p; int const *p; 指针常量：指针其本身就是常量（故定义时须初始化），而且也不能通过这个指针修改其指向： int * const p = &a; 数组指针（指向一维数组的指针 / 行指针）：char (*p)[10] —— 打括号就是说，先看括号里面的。故可以这样理解： 举例, 二维数组char a[10][10], char (*p)[10];p = a。 首先确定，char (*p)[10]只是将p定义为一个指针（其作用是指向某个数组整体，而不是这个数组中的某个元素）;10就是指定了指向的数组的长度 p = a就让p指向了a[0]这个数组;于是p++，就让p指向了下一个数组a[1]; 所以若p = a，那么*p就是获得a[0]这个数组。 既然char (*p)[10]是指向数组的指针，那么通用的使用就是:把数组的地址给p，即char (*p)[10];char s[]="abcd";p=&s; 而二维数组a[][]的数组名a的含义是：a == &a[0]; 指针数组（数组元素是数组）：char *p[10] —— 没有括号，所以可以这样看：这是一个数组，其元素类型是char *p。这里是一个放了10个指针的数组。所以p[0]=arrary;是指向数组首元素，而不是整个数组
标准输入输出格式：
当数据的实际位宽大于printf中的指定位宽时，将按照数据的实际位宽输出数据。
//输出 printf("%ld\n", test); /* 以长整型格式输出 */ printf("%f\n", test); //输出单双精度浮点数 printf("%4.2f\n", test); //输出数据共占4位（包括小数点），有2位小数；其他数据类型也是如此(自然有些是没有小数的) printf("%u", n); //n是unsigned int printf("%s\n", str); //输出一个字符串 printf("%p\n, p); //输出地址 //输入 /*scanf：返回值为成功接收到的、输入的变量值个数。 如scanf("%d%d%d"，i，j，k，a，b)则只能返回3（因为只能接收三个）*/ char *str = (char *)malloc(N * sizeof(char)); scanf("%s", str); //输入一个字符串 scanf("%lf", &test); //输入双精度浮点数 scanf("%d,%d", &a, &b); //输入必须与指定的格式相同。比如这里有","，那么在Console中输入也需要","
随机数：
//#include <stdlib.h>：rand、srand //#include <time.h>：time srand(0); printf("%d\n", rand()); //rand对应于srand，只要srand的种子不变，rand的随机值也不会变；rand的范围是0 - int srand(time(NULL)); //srand(unsigned) printf("%d\n", rand()); //time函数返回当前时间（秒）；参数param如果不为BULL，则time会将时间赋给param。故这样一来随机数就会一直改变（真正实现随机） printf("%d\n", rand() % 100 + 1); //生成1-100的随机数：rand() % 100是0-99
指数函数：
pow(x, y) //表示x的y次方 —— math.h
数组：
初始化：
int count[10] = {0}; //长度为10的数组，全都初始化为0;定义数组时，数组长度只能是常量，不能是变量或含变量的表达式
二维数组：
多维数组在内存中实际上都是一维存储的。例如二维数组，我们只是在逻辑上可以理解为二维的矩阵，但实际上二维数组是一维数组，每个元素还是一维数组，所以整个二维数组都是"一条线"
1、因此int a[3][3]={1...9};int (*p)[3] = a;此时不仅可以*(*p+2),还可以*(*p+8)=*(*(p+2)+2)，只要不越二维数组的界(这里是9);
简单点就是：int a[3][3] = {1...9};int *p = &a[0][0];此时可以从头指到尾：头是*p，尾是*(p+8);
2、所以二维数组a有m行n列，则在a[i][j]之前的元素个数为i * n + j —— 因为a[i][j]是第i + 1行,第j + 1列，而前i行都是在a[i][j]之前的
求数组大小：
char s[][20] = { "first", "second", "Third" }; char (*p)[20] = s; printf("%d %d\n", sizeof(s) / 20, sizeof(p)); //3、4：因为p要找"\0"，即'\0' —— {"...", "...", "...", "\0"} //用指针数组 char *p[] = {"How", "are", "you"}; printf("%d\n", sizeof(p) / sizeof(char *));
函数：
函数返回值：
printf("%d\n", func(-1)); //main函数 int func(int i) { if (i == 0) { return i; } else { printf("h\n"); //这种情况，会返回printf输出的字符个数（包括转义符）：此时return 2 } }
数组作为函数参数，形参数组与实参数组实际上是同一个数组，即传址调用；数组作为实参，只需要写数组名（无论是几维数组）。
变量的生命周期与作用域：
#include <stdio.h> void Incre(); int main() { Incre(); Incre(); return 0; } void Incre() { static int x = 1; //静态：第二次就输出上次，保存的x的值；此外这还是一个局部var，因此作用域还是Incre printf("%d\n", ++x); }
字符串：
字符常量与字符串常量的区别：
- 字符串常量：1、字符串里面包含的字符是连续存储的。2、每个字符串都有结束标记（"\0"），这是一个特殊的字符，即ASCII码为0的字符。3、C语言用字符数组（没有字符串变量）来动态存储字符串，例如char s[10] = {'a', 'b', '\0'}是一个字符串，而char s[10] = {'a', 'b'}不是。或者写为char s[] = "abc"（在初始化的情况下可以省略数组大小）。存储多个字符串（用二维数组）：char s[][10] = {"星期一", "星期二"}（第一个大小可省略，由字符串的个数，即二维数组中包含数组的个数决定）。
- 字符常量：char s = 'a'。
用指针来访问字符串：
#include <stdio.h> int main() { char *p = NULL; char s[] = "abc"; p = s; //反过来就不行了，因为数组名相当于是一个指针常量 printf("%c\n", *p); //现在只是指向字符串的第一个字符 //printf("%s\n", *p); //这样是不行的，应该是printf("%s\n", p);输出的是这个指针指向字符串的某个字符以及后面剩下的字符，所以p在此时可以用s替代 return 0; }
输入输出字符串：
char s[] = "adjshd"; char s1[] = "casn";char *p = s; char *p1 = s1; gets(p); //可以输入空格 puts(p); scanf("%s", p1); printf("%s\n", p1);
但是gets是存在安全隐患的（它没有限制输入的大小，即输入可能超出字符数组的大小，此时就可能把输入存到了指定的字符数组之外的地方）：
char s2[] = "sdfjhasjd"; char *p2 = s2; char n = 3; //fgets限制输入的长度 fgets(p2, n, stdin); //最多只能接收n - 1个字符 puts(p2);
getchar函数：
用处1：
#include <stdio.h> #include <math.h> int main() { int n = 0; char c = 'c'; int result = scanf("%d", &n); if(result != 1) //输入与scanf指定的类型不符，则不能接收到。未能成功接收的字符会暂时放在缓冲区 { c = getchar(); //此时getchar就是将缓冲区的字符一次取走一个，并返回 } printf("%d %c\n", n, c); return 0; }
用处2：
#include <stdio.h> #include <math.h> int main() { char c = 'c'; //getchar直接从stdin读取一个字符，putchar从stdout输出 c = getchar(); putchar(c); return 0; }
字符串处理函数：
//需要#include <string.h> -- 字符串处理函数strcmp、strlen、strcpy、strcat strcmp(s1, s2); //两个字符串自左向右，逐个字符相比(比较ASCII码)，直到出现不同字符或'\0'为止，此时若：s1==s2;return 0;s1 > s2;return 1;否则return -1. strlen(s1); //返回字符串s1的长度，例如：char s1[10] = "abcde";printf("返回字符串的长度：%d，返回数组的长度%d\n", strlen(s), sizeof(s)); char source[] = "hello kit";char destination[] = "world"; puts(strcpy(destination, source));puts(destination);//source->destinations char source[] = "hello kit";char destination[] = "world"; puts(strcat(destination, source));puts(destination);//即destination + source
函数库：
字符处理函数#include <ctype.h>： 函数的参数皆为int,返回也为int int isdigit(int c); //判断是否为数字字符，例如：如果是'3',return 1;是'a',return 0; int toupper(int c); 实用函数#include <stdlib.h> double atoi(const char *s);
double atof(const char *s); //例如： //printf("%6.2f\n", atof("1e2"));输出：100.00——还要算上小数点 //printf("%6.2f\n", atof("y3")); 输出： 0.00;就算是e3也不会当成是科学计数，而是和y3一样
枚举类型：
#include <stdio.h> int main() { //定义枚举类型，集合{}中的元素，是枚举元素 —— 供枚举变量进行选择 //枚举元素的值：如果没有指定具体值，编译器会把第一个元素处理成0，后面元素以此+1:因此枚举元素是常量 //当然也可以自定义枚举元素的值：例如指定Tuesday = 100,那么Wednesday也遵循+1的原则，因此Wednesday = 101 enum Date { Monday, Tuesday, Wednesday }; //定义枚举变量 //1、直接在定义类型时，顺便把变量定义了 //enum Date { Monday, Tuesday, Wednesday } date; //2、或者只定义变量 //enum { Monday, Tuesday, Wednesday } date; //枚举变量选择具体的枚举值 enum Date date = Tuesday; date = Wednesday; printf("%d\n", date); return 0; }
联合union：
编译器处理union时，一个union所有成员共用同一段内存空间（同一时刻，只有一个成员使用内存空间，存放成员值），因此内存空间的大小=最长的成员大小。具体使用如下：
#include <stdio.h> int main() { union { int i[2]; int k; int c; } t, *s = &t; //给哪个成员赋值，内存空间就被这个成员使用 s->i[0] = 10; s->i[1] = 20; printf("%d\n", s->c); s->k=30; printf("%d\n", s->c); s->c = 1000; printf("%d\n", s->c); printf("%d\n", s->i[1]);//始终为20 return 0; }
使用联合的一些注意事项：
1、联合不能作为函数参数传递。2、不能整体初始化或者整体赋值，只能对其成员一个一个赋值。3、不能作为函数返回值。
结构体：
#include <stdio.h> typedef struct student { int number; char name[20]; char sex; } S;//此时S是别名 struct { int year; int month; int day; } birth;//此时birth是结构体变量 int main() { S s; s.number = 1000; birth.year = 250; printf("%d %d\n", birth.year, s.number); return 0; }
文件操作：
<stdio.h>中的一些变量类型、宏定义：
- 文件结束符：#define EOF (-1)
- 存储文件流信息的类型：typedef struct _iobuf FILE;
- 类型的大小，即sizeof运算符的结果：typedef unsigned int size_t;
打开已存在文件、或新建一个文件：
函数原型：FILE *fopen(const char *filename, const char *mode);//用FILE的指针变量操纵文件 根据打开模式(mode)的不同决定：新建或打开文件 1、文本文件： mode的值：r(打开已有文件，只读)、w(打开文件，只写、覆盖写入，即打开后删除原有内容，重新写入。若文件不存在，则新建)、a(打开文件，只写、追加写入。若文件不存在，则新建) 可读写：r+(打开已有文件，覆盖写入)、w+(新建文件)、a+(打开文件。若文件不存在，则新建。写：追加写入) 2、二进制文件mode：形如ab、ab+
=>每次读写都会从文件游标开始读（第一次读，游标在文件开头），游标属于fp指向的 FILE 变量：因此，对于同一个FILE变量，fgetc的调用也会影响到fgets的读取位置
清空缓冲区数据，并关闭文件：
函数原型：int fclose(FILE *fp); 成功关闭，释放掉文件占用的内存，return 0;发生错误，return EOF(常量，在stdio.h中定义);
写入文件：
写入一个字符：int fputc(int c, FILE *fp); 如果成功，return 刚写入的c;如果失败，return EOF; 写入一个字符串：int fputs(const char *s, FILE *fp); 如果成功，return 一个非负值;失败，return EOF;
格式化写入文件：
//与fputs同理，函数原型：int fprintf(FILE *fp, const char *formatSting, ...); //像printf一样，接受可变长参数，如： fprintf(fp, "%d != %d\n", 1, 2);//即写入1 != 2
读取文件：
//与写入同理：int fgetc(FILE *fp) printf("%c\n", fgetc(fp)); fgetc(fp);//每调用一次，读取文件的游标，就会向后移动一个char printf("%c\n", fgetc(fp)); //读取字符串：char *fgets(char *buf, int n, FILE *fp); //读取n - 1个字符。并将读取到的字符串，复制到字符串变量buf中，最后以\0结束 —— buf的长度应不少于n //返回的字符串与buf的值相等 char str[7]; char *buf = str; printf("%s\n", fgets(buf, 7, fp));//如果还未读取n个char，就遇到了\n或者EOF，则直接结束本次读取（包含\n）
直接读取一个单词（从游标开始，到遇到的第一个空格为止，认为是一个单词；游标是读到了这个空格的，因此调用下面的函数后，游标指向这个空格之后）：
char buff[255]; //与fprintf不同：%s作为sourceString(不加修饰)，buff作为destString fscanf(fp, "%s", buff); fscanf(fp, "%s", buff); printf("%s\n", buff);//读到第二个单词
检测当前游标是否指向文件结尾（EOF）：
int feof(FILE *fp);//文件结束，return 1;否则return 0;
