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)[] —— 打括号就是说，先看括号里面的。故可以这样理解：
举例, 二维数组char a[][], char (*p)[];p = a。
首先确定，char (*p)[]只是将p定义为一个指针（其作用是指向某个数组整体，而不是这个数组中的某个元素）;10就是指定了指向的数组的长度
p = a就让p指向了a[]这个数组;于是p++，就让p指向了下一个数组a[];
所以若p = a，那么*p就是获得a[]这个数组。
既然char (*p)[]是指向数组的指针，那么通用的使用就是:把数组的地址给p，即char (*p)[];char s[]="abcd";p=&s;
而二维数组a[][]的数组名a的含义是：a == &a[];

指针数组（数组元素是数组）：char *p[] —— 没有括号，所以可以这样看：这是一个数组，其元素类型是char *p。这里是一个放了10个指针的数组。所以p[]=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();
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() %  + );        //生成1-100的随机数：rand() % 100是0-99

指数函数：

pow(x, y)        //表示x的y次方 —— math.h

数组：

初始化：

int count[] = {};    //长度为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[][] = { "first", "second", "Third" };
char (*p)[] = s;
printf("%d %d\n", sizeof(s) / , sizeof(p));    //3、4：因为p要找"\0"，即'\0' —— {"...", "...", "...", "\0"}
//用指针数组
char *p[] = {"How", "are", "you"};
printf("%d\n", sizeof(p) / sizeof(char *));

函数：

函数返回值：

printf("%d\n", func(-));        //main函数

int func(int i)
{
    if (i == )
    {
        return i;
    }
    else
    {
        printf("h\n");        //这种情况，会返回printf输出的字符个数（包括转义符）：此时return 2
    }
}

数组作为函数参数，形参数组与实参数组实际上是同一个数组，即传址调用；数组作为实参，只需要写数组名（无论是几维数组）。

变量的生命周期与作用域：

#include <stdio.h>

void Incre();

int main()
{
    Incre();
    Incre();
    return ;
}

void Incre()
{
    static int x = ;        //静态：第二次就输出上次，保存的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 ;
}

输入输出字符串：

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 = ;
//fgets限制输入的长度
fgets(p2, n, stdin);    //最多只能接收n - 1个字符
puts(p2);

getchar函数：

用处1：

#include <stdio.h>
#include <math.h>

int main()
{
    int n = ;
    char c = 'c';
    int result = scanf("%d", &n);
    if(result != )        //输入与scanf指定的类型不符，则不能接收到。未能成功接收的字符会暂时放在缓冲区
    {
        c = getchar();        //此时getchar就是将缓冲区的字符一次取走一个，并返回
    }
    printf("%d %c\n", n, c);
    return ;
}

用处2：

#include <stdio.h>
#include <math.h>

int main()
{
    char c = 'c';
    //getchar直接从stdin读取一个字符，putchar从stdout输出
    c = getchar();
    putchar(c);
    return ;
}

字符串处理函数：

//需要#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 ;
}

联合union：

编译器处理union时，一个union所有成员共用同一段内存空间（同一时刻，只有一个成员使用内存空间，存放成员值），因此内存空间的大小=最长的成员大小。具体使用如下：

#include <stdio.h>
int main()
{
    union
    {
        int i[];
        int k;
        int c;
    } t, *s = &t;
    //给哪个成员赋值，内存空间就被这个成员使用
    s->i[] = ;
    s->i[] = ;
    printf("%d\n", s->c);

    s->k=;
    printf("%d\n", s->c);

    s->c = ;
    printf("%d\n", s->c);
    printf("%d\n", s->i[]);//始终为20
    return ;
}

使用联合的一些注意事项：

1、联合不能作为函数参数传递。2、不能整体初始化或者整体赋值，只能对其成员一个一个赋值。3、不能作为函数返回值。

结构体：

#include <stdio.h>

typedef struct student
{
    int number;
    char name[];
    char sex;
} S;//此时S是别名
struct
{
    int year;
    int month;
    int day;
} birth;//此时birth是结构体变量

int main()
{
    S s;
    s.number = ;
    birth.year = ;
    printf("%d %d\n", birth.year, s.number);
    return ;
}

文件操作：

<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)的不同决定：新建或打开文件
、文本文件：
mode的值：r(打开已有文件，只读)、w(打开文件，只写、覆盖写入，即打开后删除原有内容，重新写入。若文件不存在，则新建)、a(打开文件，只写、追加写入。若文件不存在，则新建)
可读写：r+(打开已有文件，覆盖写入)、w+(新建文件)、a+(打开文件。若文件不存在，则新建。写：追加写入)
、二进制文件mode：形如ab、ab+
=>每次读写都会从文件游标开始读（第一次读，游标在文件开头），游标属于fp指向的 FILE 变量：因此，对于同一个FILE变量，fgetc的调用也会影响到fgets的读取位置

清空缓冲区数据，并关闭文件：

函数原型：int fclose(FILE *fp);
成功关闭，释放掉文件占用的内存，return ;发生错误，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

读取文件：

//与写入同理：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[];
char *buf = str;
printf("%s\n", fgets(buf, , fp));//如果还未读取n个char，就遇到了\n或者EOF，则直接结束本次读取（包含\n）

直接读取一个单词（从游标开始，到遇到的第一个空格为止，认为是一个单词；游标是读到了这个空格的，因此调用下面的函数后，游标指向这个空格之后）：

char buff[];
//与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;