21天学通c语言总结(3)

第15天：有关指针的高级用法

指向指针的指针

int multi[3][4];
int (*ptr)[4];
int *p;
p = (int *)ptr;

上面multi是一个指针指向multi[0]，multi[0]也是一个指针指向multi[0][0]。
ptr是一个能指向包含4个int变量的数组的指针变量，数组指针。必须用圆括号否则声明的是指针数组，因为间接运算符的优先级低于[]。
(int *)是强制类型转换，暂时将ptr的数据类型从声明的类型转换为新的类型。

指针数组

char *mes[20];
将指针数组传递给函数：
void pfs(char *p[], int n);
void pfs(char **p, int n);
上面两个均可以传递指针数组，实际上传递的是指向指针的指针。
int指针数组，int *p[4]; p[0]+1;的内容并不是p[1]而是p[0]所表示的地址加上4个字节。

malloc()默认返回void类型的指针。前面加(char *)强制转换。

函数指针

type (*ptr_to_func)(paremeter_list);
*ptr_to_func加括号是因为 *的优先级小于()。如果不加则定义的是返回指针的函数。
被指向函数的返回类型和参数列表必须和指针声明的返回值和参数列表相同。
int square(int);
int (*ptr)(int);
ptr = square;

不带括号的函数名是一个指向函数的指针常量。

声明函数指针一定用圆括号；
不要将函数指针指向返回类型和参数列表不匹配的函数。

链表

链表中的数据被存储在结构中。

struct person{char name[20];
struct person *next;
};

组成链表的结构可称为链接、节点或元素。
最后一个节点的next指针为NULL，头指针(非结构)指向第一个节点。

节点加入开头

new = (struct person*)malloc(sizeof(struct person));
new->next = head;
head = new;        //如果先赋值头指针，链表丢失

节点添加至末尾

struct person *current;
current = head;
while (current-> != NULL)current = current->next;
new = (struct person)malloc(sizeof(struct person));
current->next = new;
new->next = NULL;

节点添加至中间

struct person *marker;   // desired location
...
new = (...)malloc(...);
new->next = marker->next;
marker->next = new;

删除节点

//删除第一个
struct person *p;
p = head->next;
free(head);
head = p;

//删除最后一个
s.. person *c1, *c2;
c1 = head;
c2 = head->next;
while (c2->next != NULL)
{c1 = c2;c2 = c1->next;
}
free(c2);
c1->next = null;
if (head = c1)head = null;

//删除中间节点
s.. person *c1, *c2;
c2 = c1->next;
c2 = c2->next;
free(c1->next);
c1->next = c2;

删除后节点仍然在内存中，但是不在链表中，实际程序应归还被删除节点占用的内存，仍然通过free()完成，见第20天。

总结

数组指针
指针数组(指向指针的指针)，更方便处理字符串。
函数指针。
链表。

第16天：使用磁盘文件

磁盘文件

文本流与文本模式文件关联
二进制流与二进制模式相关联

c文件路径名：
c:\\data\\list.txt;

打开文件

FILE *fopen(const char *filename, const char *mode);
读取前声明文件指针，FILE是stdio.h中定义的结构，调用fopen时创建FILE实例，成功则返回指向该实例的指针，失败返回NULL。
打开模式mode:

r：只读，不存在返回NULL
w：只写，不存在创建，存在则删除后创建
a：附加，不存在创建，存在追加到末尾
r+：读写，不存在创建，存在写在文件开头，覆盖原数据
w+：读写，不-------建，存在则覆盖
a+：读写，---------建，存在则追加到末尾

默认为文本模式，以二进制打开在模式后加上b，rb，wb，ab等。
使用fopen()时，一定要检查是否出错。

读写文件数据

三种方式

格式化输出，只能用于文本文件，主要供其他文件读取。
字符输出，主要用于文本文件。
直接输出(direct output)，将内存的内容直接保存到磁盘文件，只适用于二进制文件，供c程序使用。

读取时也是类似三种。
上面的规则并非不可逾越。

格式化输入/输出

格式化输出

int fprintf(FILE *fp, char *fmt, ...);
fprintf与printf区别只是前者可以指定流，如果指定stdout则没有区别。

格式化输入

int fscanf(FILE *fp, const char *fmt, ...);
与scanf的差别也仅是指定流。

字符输入/输出

字符输入

getc()，fgetc()。这两个函数相同，成功返回读取的字符，失败返回EOF(-1)。
int getc(FILE *fp);
返回int是因为，读取文件时必须读取文件尾标记，而有些系统标记为int，而不是char。

fgets()，char *fgets(char *str, int n, FILE *fp); str是指向缓冲区的指针，n(读n-1个，最后加空字符)是要读取的最大字符数，fp是FILE指针，由fopen返回的。
失败返回NULL。

字符输出

putc()，fputc()。int putc(int ch, FILE *fp); 将一个字符写入流，成功返回字符，失败返回EOF。

fputs()。char fputs(char *str, FILE *fp); 与puts的差别，可以指定流，不会在末尾加换行符。

直接输入/输出

fwrite()
int fwrite(void *buf, int size, int count, FILE *fp);
buf是指向内存区域的指针(任何类型)，size指定每项数据的长度(字节)，count数据项数。
成功返回count，失败返回小于count的数。
struct adress data[50];写入文件，可以：
fwrite(data, sizeof(adress), 50, fp);或fwrite(data, sizeof(data), 1, fp);二者等价。
fread()
int fread(void *buf, int size, int count, FILE *fp);
用法类似fwrite()。但使用fread时要小心，明确数据类型，否则中不会报错但结果错误。

文件缓冲技术：关闭和刷新文件

int fclose(FILE *fp); fp是与流相关联的FILE指针，成功返回0，失败-1，关闭时刷新文件的缓冲区(写入文件中)。
void fcloseall(void);刷新所有的流缓冲区(标准流之外)，返回关闭的流。(不是返回void么)。除非要关闭所有的流，否则不要用fcloseall()。

也可以不关闭流刷新缓冲区，int fflush(FILE *fp);，不想关闭文件同时想将文件缓冲区的内容写入时使用，成功返回0，失败返回EOF。int flushall(void);，需要刷新所有打开的流的缓冲区时使用，返回打开的流的数目。

顺序文件存取和随机文件存取

每个打开的文件都有一个相应的位置指示器。

ftell()和rewind()。

void rewind(FILE *fp);调用后指示器指向开头（字节0）。
long ftell(FILE *fp); 成功则返回当前位置离开头的字节数，错误返回-1L。

fseek()。

int fseek(FILE *fp, long offset, int origin);，调用后可以将位置指向任何位置，offset指定移动的距离，origin指定相对什么的位置。
origin可以是SEEK_SET表示0开始，SEEK_CUR表示1当前，SEEK_END表示2末尾。成功返回0，错误返回非0。
if ( fseek(fp, (offset * sizeof(int)), SEEK_SET) != 0 )

检测文件尾

文本文件：while((c = fgetc(fp)) != EOF)，因为ASCII码都不为-1，当读入-1时可以断定到末尾。
二进制文件及文本文件：int feof(FILE *fp);未到末尾返回0，否则返回非0。

文件管理函数

删除文件
int remove(const char *filename);，filename指向要删除的文件，删除成功返回0，不成功返回-1。
重命名文件
int rename(const char *oldname, const char *newname);，两个文件必须位于相同的磁盘驱动器，成功0，失败-1。
复制文件
c语言没有复制文件的库函数。但因为c使用流。因此自己编写很简单。
1.以二进制rb读，可以保证能够复制任何文件，而不是仅仅是文本文件。
2.二进制wb模式打开目标文件。
3.fgetc()读取一个字符，rb打开指示器在开头，无需显式的放置。
4.feof()表明到结尾(非0)，则关闭两个文件，返回0。
5.未到末尾，字符写入目标文件，回到3。

临时文件

char *tmpnam(char *s);，用来创建有效且不与任何已有文件冲突的名称。s指向的缓冲区必须足够大。
两种方式创建临时文件：
1:char buffer[10], *c; tmpnam(buffer); // 传递指针
2:c=tmpnam(NULL); //传递空指针
一定要删除临时文件。remove(buffer); remove(c);

第17天：操纵字符串

确定长度
size_t strlen(char *str);返回字符串长度，不包含空字符。
size_t表示unsigned的型。
复制字符串
char *strcpy(char *destination, const char *source);，必须分配空间。
char *strncpy(char *destination, const char *source, size_t n);，复制前n个字符。小于n加上空字符，多于n不加空字符。
char *strdup(char *source);不是ANSI标准函数，调用时自动调用malloc分配内存。
拼接字符串
char *strcat(char *str1, const char *str2);
char *strncat(char *str1, const char *str2, size_t n);
比较字符串
int strcmp(const char *str1, const char *str2);比较两字符串直到出现不相同字符，相等0，小于<0，大于>0.
int strcmp(const char *str1, const char *str2, size_t n);,一直比较直到不相等字符或比较了n个字符。
查找字符串
strchr()，strrchr()。查找字符第一次和最后一次出现的位置。
strcspn()，strspn()。前者在一个字符串中查找另一个字符串的字符第一次出现的位置，找不到返回strlen(str1)。后者指出从str1开头到什么位置之间所有的字符都包含在str2中。
strpbrk()，类似strcspn，不同是返回指针，找不到返回null。

最有用的strstr()。char *strstr(const char *str1, const char *str2);，查找一个字符串在另一个字符串中第一次出现的位置。返回位置指针。可以通过指针减法获得离str1开头的距离。

字符串转换
char *strlwr(char *str); char *strupr(char *str);
分别为将大写转换为小写，和小写->大写。
不是ANSI标准。
其他字符串函数
char *strrev(char *str); 逆序
char *strset(char *str, int ch); 空字符外全改为ch.
char *strnset(char *str, int ch, size_t n); 前n个改为ch.
字符串转数字
atoi，atol，atof
字符检测函数
isxxxx() ctype.h中定义的宏

ANSI对大小写转换的支持：toupper()，tolower()。一次处理一个字符，利用返回值。ch = toupper(ch);而不是toupper(ch);

总结

这些库函数，返回指针的失败后返回NULL，返回int的失败返回EOF(-1)，成功返回0。

做练习时写了一个查找文本中某字符串出现次数及出现在第几行的程序，感觉挺有趣。。

第18天：有关函数的高级主题

将指针传递给函数

传递方式有两种：按值传递和按引用传递。
前者不能修改参数值，通过返回值也只能修改一个参数。
后者可以修改多个参数的值。定义时需要用*解除引用。

void类型的指针

指向任何对象，解除引用之前需要强制类型转换。
无法算数运算。

可变数目函数

头文件stdarg.h
宏：va_list定义存取各参数的指针arg_ptr。
va_start()：初始化参数列表，将指针和最后一个固定参数传递给他。
va_arg()：依次取回各个参数，并将指针指向下一个参数，接受arg_ptr和下一个参数的类型。
va_end()：清理。
至少要有一个固定参数。

返回指针的函数

不要和函数指针弄混。

第19天：函数库

数学函数

头文件math.h
三角函数sin(), cos(), tan(), asin(), acos(), atan(), atan2();
指数对数exp(), log(), log10();
双曲cosh(), sinh(), tanh();
求根sqrt()取整ceil(), floor();x的y次方pow(x, y);返回x/y的余数fmod(x, y);
所有数学函数返回值为double类型。

时间函数

头文件time.h
两种表示时间的方式：
第一是记录从1970年1月1日午夜开始过去的秒数，负数表示之前的某时刻。
第二是将其划分为年月日等，使用结构tm。

处理时间

时间函数的time_t和clock_t均为longlong型。

time_t time(time_t, *timeptr);返回自1970年的秒数。

两种调用形式：now = time(0); 或 time(&now);
struct tm *localtime(time_t *ptr); time_t mktime(struct tm *ntime);
前者将time_t转换成tm结构，后者将tm结构转换成time_t。
clock_t clock(void);返回程序从开始执行起过去的时间。
显示时间char *asctime(struct tm *ptr);、 char *ctime(time_t *ptr);以及size_t strftime(char *s, size_t max, char *fmt, struct tm *ptr);
第一个接受tm结构作为参数，第二个结构time_t变量作为参数，都返回如下格式：
Thu Jun 13 10:22:23 1991
第三个可以用格式化字符串的方式对时间的格式进行格式化，常见的：
%a,%A缩写星期及完整星期。%b,%B缩写月份及完整月份
%D相当于%m/%d/%y。%F相当于%Y-%m-%d
// 上面试了下不对。。
H, M, S24小时制的时分秒。%T相当于%H:%M:%S
%U0-53表示的星期。%x日期如30-Jun-91。%X时间如10:41:50。
strftime(buf1, 80, "the data is %D, week %U of year %Y.", ptr);
put(buf1);

处理错误

void assert(int expression);
如果expression为错，则assert强行终止程序。
可以定义#define NDEBUG使assert处于关闭状态。
errno.h头文件
需要配合void perror(const char *msg);使用。

    if ((fp = fopen(filename, "r")) == NULL){perror("you goofed!");printf("error = %d.\n", errno);exit(1);}

查找和排序

void qsort(void *base, size_t num, size_t size, int (* cmp)(const void *element1, const void *element2));

void besearch(const void *key, void *base, size_t num, size_t width, int (* cmp)(const void *element1, const void *element2));

前者升序排序，后者以二分法查找键值(要求数组升序)。
key指向要查找的数据项，base指向数组第一个元素，num是数组元素数，width(size)是每个元素的长度，cmp是一个指向比较函数的指针。比较函数满足：大于返回大于0，等于返回0，小于返回小于0。

第20天：管理内存

类型转换

自动转换

计算表达式时类型提升
char<short<int<long<long long<float<double<long double
赋值时转换
int i; float f; f = i;时i被提示为float。

显示转换

强制转换算数表达式
int i1 = 100, i2 = 40;
f1 = (float)i1 / i2;
计算时先把i1强制转换，i2会自动提升。
装换指针
对void解除引用时必须将其转换为相应的类型。

分配内存空间

void *malloc(size_t num);
void *calloc(size_t num, size_t size);
上面两个类似，calloc分配时会自动把内存内容设置为0。前者num指字节数，后者num为对象数，size为对象的大小(字节)。
void *realloc(void *ptr, size_t size);
改变分配内存的大小，ptr为原来内存的指针，size为新的大小。
ptr为NULL，则类似于malloc()。size为0，则释放内存，返回NULL。
free()释放内存
void free(void *ptr);

操纵内存块

void *memset(void *dest, int c, size_t count);
将指定的字节设置成特定的值。
dest指向要初始化的内存，c被视为char(0-255有效)，count指定字节数。
例如：memset(message + 2, '#', 10);
memcpy, void *memmove(void dest, void *src, size_t count);
复制数据。
前者处理重叠部分时会出错，因此可以完全使用后者。例如：
memmove(temp + 6, temp + 4, 10);

位的用法

移位运算
y = x << 1;
y = x >> 1;
分别为左移右移，存在溢出现象。
按位逻辑运算符
双目运算符。
&, |, ^分别为：按位与，或，异或。
求补(~):按位取反
结构中的位字段

struct emp_data
{unsigned dental        : 1;unsigned college    : 1;unsigned health     : 2;...
};

节省内存空间，c中最小的数据类型为char，1字节，存储只需1-7位的数据时浪费内存。
位字段必须放在结构定义的最前面。赋值时采用符号变量TRUE、FALSE等最好，超过范围时结果不可预测。

将输入转换为二进制时，可以按位运算或者不断除以2求余。

第21天：编译器的高级用法

多文件编译

之前知乎抄的vscode配置
https://www.cnblogs.com/esllovesn/p/10012653.html这个是简化版也是更方便版的，建议直接看这个。
https://www.zhihu.com/question/30315894这个是知乎原文，比较复杂。

进行少量的多文件编译，C语言直接用gcc 源文件1.c 源文件2.c 头文件1.h这样就好，C++用g++。默认生成a.exe，加-o可指定输出文件名，其余选项百度gcc使用教程。如果需要多次编译可以写一个批处理。

进行大量的多文件编译，请学习如何写makefile或使用cmake。然后把tasks的命令改成调用make等。如果你想使用别人的库，比如ffmpeg，可能需要在命令中指定-I、-l（小写的L）、-L。具体参数阅读那个库的文档。还可能需要把路径添加到c_cpp_properties.json和compile_flags.txt里来配置Intellisense。这些情况下可以考虑单独建一个工作区，不要和单文件编译的共用。其实不新建工程(Project)、只是单文件就能调试，是不利于以后使用和理解大型IDE的。不过初学也不用掌握那么多，不要觉得建工程很麻烦、不建工程就能编译很强就是了。总之这些和VSC无关，用其它IDE或是手动编译也会遇到差不多的问题，也有点复杂。

入门水平，不太懂后面的意思，使用第一种少量多文件编译的方法。

.c文件–>预处理–>.i文件–>编译–>.s文件–>汇编–>.o文件–>链接–>.exe文件

gcc -E (E大写)预处理(preprocessing)。不会检查语法错误。win10需要使用重新定向生成.i文件gcc -E test.c > test.i或者指定文件名gcc -E test.c -o test.i，否则只会输出到stdout。

gcc -S(S大写)编译(compiling)。将.i文件编译成.s文件，即使不指定文件名也会生成与.i文件同名的.s文件，即gcc -S test.i -o test.s与gcc -S test.i相同。并且检查语法错误是在编译过程进行的。

gcc -c(c小写)汇编(assembling)，将.s文件转换成机器能执行的机器代码.o文件，同样即使不指定文件名也会生成与.s文件同名的.o文件，gcc -c test.s -o test.o与gcc -c test.s相同。

gcc x.o或gcc x.o -o x.exe链接(linking)将机器码.o文件连接成可执行文件.exe。

模块化编程

通用指导原则：

辅助模块(secondary module)应包含通用的函数，常见的做法是，对每一类函数，创建一个辅助模块。例如：键盘函数放在keyboard.c中，屏幕显示函数放在screen.c中等。
主模块应包含main()和其他程序特有的函数。
每个辅助模块都有一个头文件，名称应与相应的模块名相同，扩展名为.h。应包含(1).辅助模块中的函数的原型。(2).定义模块使用的宏和符号常量的#define编译指令。(3).模块使用的结构和外部变量的定义。
为防止头文件被包含多次，可以使用预处理器来实现有条件的编译。

外部变量

外部变量在其所属的整个源代码文件中可见，但在其他模块中不会自动可见。需要使用关键字extern来声明。
主模块中float interest_rate;辅助模块extern float interest_rate;

.o文件

如果源代码文件已被编译为.o文件，则应仅当修改该文件时才重新编译，否则应尽量使用.o文件，gcc database.c keyboard.c

生成工具

应该就是上面的makefile和cmake。可以检查源代码和目标文件的时间和日期邮戳，并根据定义的依存性，指示编译器只重新编译那些依赖于被修改的文件的文件。避免了不必要的编译，最大化效率。

适合于大型工程。

预处理器

gcc -E进行预处理，根据源代码的指令(预处理器编译指令)对源代码进行修改。

#define

替换宏
#define text1 text2
预编译器把源代码文件中所有的text1替换为text2。如果text1位于双引号中，则不替换。不会修改源代码文件。
函数宏
函数宏的优点：对参数类型不敏感，可以将任何数值类型的变量传递给接受数值参数的函数宏。
#define HALFOF(value) ((value) / 2)
#define LARGER(x, y) ((x) > (y) ? (x) : (y))

宏定义时，宏名后必须紧跟左圆括号，不能有空白。并且替换字符串中每个参数都要有圆括号括起。例如：
#define SQUARE(x) (x) * (x)而不是#define SQUARE (x) x*x

替换字符串中，如果宏参数前面有#字符串化运算符，展开宏时，该参数将被转换成被引号括起来的字符串。例如：
#define OUT(x) printf(#x)
OUT(Hello);被展开为printf("Hello");
#运算符在转换时会考虑特殊字符，需要转义时加\。
OUT("HELLO");---->printf("\"HELLO\"");

##拼接运算符，#define CHOP(x) func ## x，将两个字符串拼接，不会加引号，也不对转义字符做处理，主要用于修改源代码。salad = CHOP(3) (q, w);—>func3 (q, w);使用##决定了调用哪个函数。
宏和函数
宏速度快，函数代码长度短。
查看宏展开
gcc -E *.c -o *.i

#include

不可以包含一组，但可以嵌套，被包含的文件可以#include，ANSI最多15层。
尖括号括起#incldue <stdio.h>在标准目录查找。双引号括起#include "myfile.h"在源代码文件中查找。也可以在双引号中指定路径。

#if、#elif、#else和#endif

有条件控制编译，无需用花括号，似乎用处很大，例如：

#if ENGLAND == 1
# include "england.h"
#elif FRANCE == 1
# include "france.h"
#elif ITALY == 1
#include "italy.h"
#else
#include "usa.h"
#endif

还可以帮助调试：
#if DEBUG == 1
debugging code here
#endif

defined()，检查是否被定义。用来避免包含多次头文件。

#if defined(prog_h)
/* already included */
#else
#define prog_h
/* header file information goes here */
#endif

undef()，撤销定义。

预定义的宏

__DATE__、__TIME__、__LINE__、__FILE__
预处理时，__DATE__、__TIME__为编译时的日期和时间。__LINE__被替换为行号，__FILE__替换为文件名，后两个最适合于调试程序或处理错误。
printf(" Program %s: (%d) Error opening file ", __FILE__, __LINE__);

使用命令行参数

main(int argc, char *argv[]) // char **argv也行
{/*...*/
}

argc表示有多少个命令行参数，argv的长度为argc，argv[0]指向包括路径信息的文件名，argv[1]指向程序名后的第一个参数。也可以用其他名，传统这两个。
e:>program smith "little pony"
参数含有空格，则双引号括起。

一定要检验用户输入的命令行参数

总结

模块化编程
预处理编译指令，#define #include #if #elif #else #endif #undef
函数宏
命令行参数。main(int argc, char **argv[])