C标准学习笔记

储存有程序代码的文本被称为源文件(或预处理文件)，一个源文件和他使用#include包含的所有其他源文件和头文件被统一称作一个 预处理单元 ，预处理之后的单元叫做 翻译单元 。
程序的独立翻译单元之间可以使用以下方式进行通信：

1. 调用具有外部链接标识符的函数
2. 操作具有外部链接标识符的对象
3. 操作文件

各个翻译单元之间可以独立翻译，然后最后链接到一起。

TODO: 检查空字符 \0 和空格字符 是否有理解错误

翻译阶段的顺序如下：

1. 如果需要，物理源文件将会在行位添加一个新的换行符。???
2. 删除紧跟着换行符的反斜杠字符 \ ，将物理源行拼成逻辑源行。只有物理源行的最后一个 \ 才有资格被这样处理。任何非空的源文件应以换行符结尾，否则其前不应紧跟反斜杠字符 \
3. 源文件被分解为预处理token和空白字符序列(如注释)，源文件不得以不完整的预处理标记或注释结尾，每一个注释会被一个空格取代(所以反斜杠后面不能接注释)，换行字符会被保留。TODO:Whether each nonempty sequence of white-space characters other than new-line is retained or replaced by one space character is implementation-defined
4. 执行预处理指令，展开宏调用，并且执行_Pragama一元运算符表达式。如果在token连接中生成了与通用字符名语法匹配的字符序列，则其行为是未定义的，如6.10.3.3中的##运算符。使用#include预处理指令会递归的处理步骤1到4。
5. 每一个设置了字符和转义字符串的字符常量和字符串会被计算或拼接为正确的值，若没有对应的成员则将会被转移成空字符????
6. 连接相邻的字符串标记，如 "ab" "cd" -> "abcd"
7. 此时空白字符不再有效，每一个预处理token都讲被转化为一个token，生成的tokens将会被用于语法和语义分析，并作为翻译单元进行翻译
8. 解析所有的外部对象和函数引用，并链接成一个文件

1. TODO
3. 整数类型提升会保留符号位。正如上述讨论，是否将普通的 char 视为 signed char 是实现定义的。

句法规则
TODO 没看懂什么意思，编译原理相关

语义

1. 标识符是一系列非数字字符（包括下划线 _ 、小写和大写拉丁字母以及其他字符）和数字，用于指定C标准学习笔记 > 6 2 1 标识符的范围中所述的一个或多个实体。小写字母和大写字母是不同的。标识的最大长度没有具体限制。
2. 标识符中的每个通用字符名称应为在ISO/IEC 10646中的编码D.1.71中规定的范围中的一个字符。首字母字符不应是通用字符名称，该名称指定的字符的编码属于D.2中规定的范围之一。作为一种实现方式，可以允许不属于基本源字符集的多字节字符出现在标识符中；其实现定义了哪些字符及其与通用字符名的对应关系。
3. 当在翻译阶段7中将预处理token转换为token时，如果预处理token可以转换为关键字或标识符，则将其转换为关键字。

实现限制

注意本文所述均为整数常量的定义、而非整数变量的运算。

对于整形常量、可以用前缀定义其进制，后缀定义其类型。

整数常量主要有以下几种类型：

• 十进制(decimal)
• 八进制(octal)
• 十六进制(hexadecimal)

十进制常量整数类型直接定义即可

八进制常量整数类型定义时应带前缀0，例如：

int dec = 10;  //等于十进制的10
int oct = 010; //等于十进制的8
复制

十六进制常量整数类型定义时应带前缀0x，例如：

int hex = 0x10; //等于10进制的16
复制

整数常量类型的修饰后缀：

• unsigned后缀
• long后缀
• long-long后缀

unsigned后缀可以为：
\ u 或者 U

long后缀可以为：
\ l 或者 L

long-long后缀可以为：
\ ll 或者 LL

对于枚举类型的常量，其标识符的类型为 int

限制
sizeof 运算符不能用于函数类型(参数不可为函数名)或不完备的变量类型，或用括号包裹的变量类型，或含有位域的成员表达式。
_Alignof 运算符不能用于函数类型(参数不可为函数名)或不完备的变量类型。
如：

#include <stdio.h>

typedef struct {
	int a : 2;
	int b : 2;
} typea_t;

typedef struct {
	int a;
	int b;
} typeb_t;

int main()
{
	typea_t typea;
	typeb_t typeb;
	
	printf("testa_t: %lld\r\n", sizeof(typea_t));  //4
	
	//printf("testa_t: %lld\r\n", sizeof((typea_t)));//参数不可为含括号的类型
	
	//printf("testa_t: %lld\r\n", sizeof(typea.a));  //参数不可为含位域的成员
	
	printf("testa_t: %lld\r\n", sizeof(typeb.a));  //4
	
	//printf("testa_t: %lld\r\n", sizeof(main));     //参数不可为函数名
	
	return 0;
}
复制

语义

1. sizeof 运算符生成其操作数的大小(以字节为单位)，操作数可以是表达式或类型的括号名称。大小由操作数的类型决定。结果是一个整数。如果操作数的类型是可变长度数组类型，则计算该操作数(此时不可再简单理解为宏，是运行时求值); 否则，不计算该操作数，结果为整数常量。

#include <stdlib.h>

size_t vla_test(int size)
{
	int array[size];
	return sizeof(array);
}

int main()
{
    printf("%lld", vla_test(89)); //356
    return 0;
}
复制

2. TODO...

概要

#include <stdio.h>
int fclose(FILE *stream);
复制

描述

1. 当 fclose 成功调用时，文件流会被flush并关闭，流中缓冲区的：
   1. 所有未写入到文件的数据将会被投送至宿主环境以写入到文件中。
   2. 所有未被程序接收但已被读出是数据会被丢弃。
2. 无论调用成功与否，文件和 stream 都将解除关联，由 setbuf 和 setvbuf 所设置的缓冲区也会和 stream 解除关联(如果是自动分配的缓冲区，则会自动的调用析构函数)。

返回值

1. 如果成功将返回 0 ，不成功将返回 EOF 。

概要

#include <stdio.h>
int fflush(FILE *stream);
复制

描述

1. 如果流指向一个输出流(例如 stdout )或更新流，其中最近的操作没有输入，则 fflush 函数将导致该流的任何未写数据被传送到主机环境，并写入文件；否则，行为是未定义的(例如操作只读流 fflush(stdin) )。
2. 如果 stream 的参数值为 NULL ，则 fflush 会刷新程序中定义的所有流。

返回值

1. 若 fflush 正常执行则会返回 0 ，否则则会设置错误标识符并返回 EOF 。

概要

#include <stdio.h>  
FILE *fopen(const char * restrict filename,
	const char * restrict mode);
复制

描述

1. fopen 函数打开名称(路径)为 filename 的文件，返回一个与该文件绑定的 FILE* 指针。
2. mode 参数应当是以下字符串之一，随后将以对应的模式打开文件。若非以下字符串则行为未定义。

简单来说，mode主要为以下关键字的组合：

概要

#include <stdio.h>
int fprintf(FILE * restrict stream,
	const char * restrict format, ...);
复制

描述

1. fprintf 函数会将字节流按照 format 所指字符串中所指定的输出格式输出到 stream 所指向的流中。
2. 如果给定的参数比 format 所需的参数少，则行为未定义。
3. 如果给定的参数比 format 所需的参数多，则多余的表达式也会被计算，然后被忽略。
4. fprintf 处理到 format 所指字符串的末尾字符 \0 后返回。
5. format 应为字符序列，普通的多字节流(除了 % 符)会原封不动的输出，每一个占位符都由 % 符引入，
   TODO 补全翻译

概要：

#include <stdio.h> 
int fgetc(FILE *stream);
复制

描述：

1. 如果输入 stream 没有设置 EOF 指示符，并且存在下一个字符，fgetc 函数将获得该字符作为 unsigned char 转换为 int (本质还是 char ，只是类型变了)，并推进该流的相关文件位置指示符(如果已定义)。

返回值：

1. 如果设置了 stream 的 EOF 指示符且 stream 处于 EOF 位置， fgetc 函数将返回 EOF 。否则 fgetc 函数将返回由 stream 指向的输入流中的下一个字符。如果发生读取错误，则设置流的错误指示符，并返回 EOF 。其中，读到的 EOF 是由于文件到达末尾还是读取时发生错误可以使用 feof 或 ferror 函数区分。

概要：

#include <stdio.h>  
char *fgets(char * restrict s, int n, 
	FILE * restrict stream);
复制

描述：

1. fgets 函数从流中读取至多 n - 1 个字符并存入 s 所指字符串中。在新行(可能是 \n )字符之后或文件结束之后不会读取任何其他字符(其中新行字符会被保留)。并会在字符串末尾立即添加一个 \0 字符(哪怕结尾是换行符)。

返回值：

1. 如果读取成功， fgets 函数将返回 s 。如果遇到 EOF 并且数组中没有读入任何字符，则数组的内容保持不变并返回空指针。如果在操作期间发生读取错误，则数组内容是不确定的，并返回空指针。

概要：

#include <stdio.h>  
int getc(FILE *stream);
复制

描述：

1. getc 函数等价于 fgetc ，是 fgetc 的通过宏的实现。但是如果它被当做宏来调用时，它可能不止一次操作 stream ，因此参数绝不应该是带有副操作的表达式。

副操作例如：

#include <stdio.h>
#define MACRO_SQRT(x) x*x 

int func_sqrt(int x) 
{
	return x*x;
} 

int main() {
	int x = 10,y = 10;
	int xx,yy;
	xx = func_sqrt(++x);
	printf("xx = %d, x = %d\n",xx,x);  //xx = 121, x = 11
	yy = MACRO_SQRT(++y);
	printf("yy = %d, y = %d\n",yy,y);  //yy = (++y)*(++y) => UB, y = 12; ++y就是副操作。
	return 0;
}
复制

而 getc 和 fgetc 之间的关系就类似于上方程序中 MACRO_SQRT 和 func_sqrt 的关系，当出现类似于如下操作就可能出现问题：

FILE streams[] = { ... };
int index = 0;
while(index < n)
	getc(&streams[index++]); //不要这样做，因为执行一次getc可能会触发多次index++
复制

返回值：

1. getc 函数返回由流指向的输入流中的下一个字符。如果流处于文件结束位置，则设置流的文件结束指示符，并且 getc 返回 EOF。如果发生读取错误，则设置流的错误指示符，并且 getc 返回 EOF 。

概要：

#include <stdio.h>  
int getchar(void);
复制

描述：

1. getchar() 函数等价于 getc(stdin) 。

返回值：

1. getchar 函数返回 stdin 指向的输入流中的下一个字符。如果流处于文件结束位置，则设置流的文件结束指示符，并且 getchar 返回 EOF 。如果发生读取错误，则设置流的错误指示符，并且 getchar 返回 EOF 。

概要

#include <stdio.h>  
int putc(int c, FILE *stream);
复制

描述

1. 与getc函数(C标准学习笔记 > 7 21 7 5 getc函数)相似，putc 函数等价于 fputc ，是 fputc 的通过宏的实现。因此参数绝不应该是带有副操作的表达式(副操作见getc章节)。

返回值

1. putc 函数返回写入的字符。如果发生写入错误，则设置流的错误指示符，随后返回 EOF 。

概要

#include <stdio.h>  
int putchar(int c);
复制

描述

1. putchar 函数等价于 putc 函数的第二个参数为 stdout 的情况。

返回值

1. 与 putc 函数的第二个参数为 stdout 的情况相同。

概要

#include <stdio.h>
int puts(const char *s);
复制

描述

1. puts 函数将 s 指向的字符串写入 stdout 指向的流，并将一个新行字符附加到输出，且不写入终止空字符 \0 。

返回值

1. 如果发生写错误，puts 函数返回 EOF ；否则返回非负值。

笔记注：

1. 一般的 txt 文件中也不用 \0 分割句子，一般 txt 文件是指可直接阅读的文件，而 \0 通常不可阅读。

概要

#include <string.h>  
void *memcpy(void * restrict s1,  
	const void * restrict s2, 
	size_t n);
复制

描述

1. memcpy 函数将 s2 指向的内存的 n 个字符复制到 s1 指向的内存中。如果复制发生在重叠的对象之间，则行为是未定义的。

返回值

1. memcpy 函数将返回 s1 指针。

概要

#include <string.h>  
void *memmove(void *s1, const void *s2, size_t n);
复制

描述

1. memmove 函数将 s2 指向的内存的 n 个字符复制到 s1 指向的内存中。复制的过程就像是将 s2 指向的对象中的 n 个字符首先复制到一个 n 个字符的临时数组中，这个临时数组不会与 s1 和 s2 指向的内存重叠，然后将临时数组中的 n 个字符复制到 s1 指向的内存中。

返回值

1. memmove 函数将返回 s1 指针。

笔记注：

1. 在Windows的C运行库中(msvcrt)， memcpy 实质上就是 memmove ，虽然微软在MSDN中依旧是按照C语言标准进行描述。
2. 在OpenBSD系统中，如果 memcpy 的内存区域重叠会导致崩溃。
3. 效率上， memcpy 比 memmove 仅少了一个分支。
4. Linus对这两个函数的评价(由于Adobe错误使用了 memcpy 从而导致在一次 glibc 升级后触发了一些bug)

概要

#include <string.h>  
char *strcpy(char * restrict s1,  
	const char * restrict s2);
复制

描述
strcpy 函数将 s2 指向的字符串(包括终止空字符)复制到 s1 指向的数组中。如果复制发生在重叠的对象之间，则行为是未定义的。

返回值
strcpy 函数将返回 s1 指针。

笔记注：

1. strcpy 函数操作的字符串要以 \0 结尾。
2. 库函数并不会检查目标的内存边界，因此可能会导致溢出。

概要

#include <string.h>  
char *strncpy(char * restrict s1, 
	const char * restrict s2, 
	size_t n);
复制

描述

1. strncpy 函数将不超过 n 个字符(空字符后面的字符不复制)从 s2 指向的数组复制到 s1 指向的数组。如果复制发生在重叠的对象之间，则行为是未定义的。
2. 如果 s2 指向的数组是一个比 n 个字符短的字符串，则空字符将附加到 s1 指向的数组中的副本，直到所有字符中的 n 个字符都写入(即后尾全为 \0 )。

返回值
strncpy 函数将返回 s1 指针。

笔记注：

1. 库函数并不会检查目标的内存边界，因此可能会导致溢出。

概要

#include <string.h>  
char *strcat(char * restrict s1, 
	const char * restrict s2);
复制

描述

1. strcat 函数将 s2 指向的字符串的副本(包括终止空字符)附加到 s1 指向的字符串的末尾。 s2 的初始字符覆盖 s1 末尾的 null 字符。如果复制发生在重叠的对象之间，则行为是未定义的。

返回值
strcat 函数将返回 s1 指针。

注：

1. 库函数并不会检查目标的内存边界，因此可能会导致溢出。

概要

#include <string.h>  
char *strncat(char * restrict s1, 
	const char * restrict s2, 
	size_t n);
复制

描述

1. strncat 函数从 s2 指向的数组到 s1 指向的字符串的末尾追加不超过 n 个字符(空字符和跟随它的字符不被追加)。 s2 的初始字符覆盖 s1 末尾的 null 字符。结果总是附加一个终止空字符(因此，最终可以出现在 s1 指向的数组中的字符数的最大值是 strlen (s1) + n + 1 )。如果复制发生在重叠的对象之间，则行为是未定义的。

返回值
strcat 函数将返回 s1 指针。

笔记注：

1. 库函数并不会检查目标的内存边界，因此可能会导致溢出。

摘要

#include <string.h>  
int memcmp(const void *s1, const void *s2, size_t n);
复制

描述

1. memcmp 函数将 s1 指向的对象的前 n 个字符与 s2 指向的对象的前 n 个字符进行比较。

返回值

1. memcmp 函数可能会返回大于、等于、或小于0的值，该函数将从 s1 和 s2 的第一个字节进行对比，直到遇见第一个不相等的字节，并返回 s1 的字节 减去 s2 的字节的值。若完全指向内容在前 n 字节完全相等，则返回0。

标准注

1. 需要注意结构体中为了内存对齐而导致的 holes 。
2. 分配空间短于 n 的内存和 s1 和 s2 重合的内存可能会出现问题。

摘要

#include <string.h>  
int strcoll(const char *s1, const char *s2);
复制

描述

1. strcoll 函数会将 s1 指向的字符串与 s2 指向的字符串先根据语言环境(LC_COLLATE变量)进行重新解释，然后再进行比较。主要用于unicode环境。

返回值

1. 同 strcmp 。

笔记注：

1. strcoll 和 strcmp 的区别可见讨论https://stackoverflow.com/questions/14087062/。
2. 执行速度自然不如 strncmp 。

摘要

#include <string.h>
void *memchr(const void *s, int c, size_t n);
复制

描述

1. memchr 函数从 s 指向的内存的前 n 个字符(每个字符都被解释为 unsigned char ，实际上也就是前 n Byte)中定位第一个值 c 的内存地址( c 也会被解释为 unsigned char )。
2. 此函数类似于从指定长度的字符串中找到第一个指定字符。

返回值

1. 如果找到匹配的指定字符 c ，则将返回 c 第一次出现的地址，若没有找到指定字符，则返回 NULL 。

笔记注：

1. 关于为什么 memchr 会将 int c 解释为 unsigned char ，而 strchr 会将 int c 解释为 char 的讨论可见如下内容：
   
   2.48 为什么在C语言中，一定要用unsigned char表示byte而非signed char或char

   在C语言中并没有提供 byte 类型，因此C语言使用 unsigned char 来表示 byte 。选择采用 unsigned char 而不采用 signed char 的考虑主要有以下几点：

   1. 必要性问题，虽然由于C语言负数补码规则的存在， byte 被 signed char 解释为负数并不影响 byte 原本的二进制值，但是 byte 本身也没有负数特性，没有使用符号的必要。
   2. 类型提升问题，若用 signed char 解释值为 0xff 的 byte 时，其 signed char 对应的值为 -1 。而当需要将 signed char 提升为 int32_t 类型时，对应的 int32_t 的值也应当为 -1 。但是此时的二进制从 0xff 提升为了 0xffffffff ，擅自多了24位 1 。
      而关于 signed char 和 char 问题，C语言并未规定 char 一定是 signed char ，也可以是 unsigned char ，具体使用哪个取决于编译器实现。规范见C标准学习笔记 > 6 3 1 1 布尔、字符和整数。

   而在C语言所提供的 string.h 库中，许多字符串操作(例如 strchr 等 str* 函数)和byte二进制操作(例如 memchr 等 mem* 函数)通常使用 int 来接收参数，是因为：

   1. int 的整数部分可以接收 unsigned char 所表示的 byte 而不触发负数补码机制，再次转换为 unsigned char 不会改变二进制值。
   2. 部分返回值为 char 的操作(如 fgetc )需要返回 EOF 来表示错误或其他情况，而 EOF 为 int 类型的 -1 (至少为16位的 1 )，不会影响 char 类型的 -1 ( 0xff ，扩展ASCII表中为字符 ÿ )的表示。
      此外，unsigned类型可以使用 printf("%x") 正常打印，而signed不行。

摘要

#include <string.h>
char *strchr(const char *s, int c);
复制

描述

1. strchr 函数将从 s 所指字符串中找出第一个字符 c 出现的位置。字符串 s 遇到 \0 自动截止，字符 c 会被转换为 char 。

返回值

1. 如果在字符串中找到指定字符 c ，则返回该字符第一次出现的地址，若没有找到指定字符，则返回 NULL 。

摘要

#include <string.h>
size_t strcspn(const char *s1, const char *s2);
复制

描述

1. strcspn 函数将计算从字符串 s1 的第一个字符开始，最大连续不包含字符串 s2 中任意字符的数量(此时 s2 被看做一个字符集合而非字符串)。
2. 可以把该函数理解为从 s1 中查找字符集 s2 中的字符，返回值为第一次出现字符集中字符的字符号-1。可见下方笔记示例。

返回值

1. strcspn 函数将返回从 s1 头部开始最大的不包含字符集合 s2 中任意字符的数量。

笔记示例：

int func()
{
	const char str1[] = "ABCDEF4960910";
	const char str2[] = "013";           // 字符集合 { '0', '1', '3' }
	int len = strcspn(str1, str2);       // 从str1的开头开始统计有多少不在集合中的字符
	printf("len = %d\r\n", len);         // len = 9，"ABCDEF496"长度为9
	
	// 另一种理解
	if(len == strlen(str1))
	{
		printf("No characters found in the character set str2 in str1\r\n");
	} else {
		printf("The first character in the character set str2 in str1 is %c, locate at %d\r\n", str[len], len + 1);
	}
	return 0;
}
复制

摘要

#include <string.h>
char *strstr(const char *s1, const char *s2);
复制

描述

1. strstr 函数会从 s1 所指字符串中寻找 s2 字符串所指子串第一次出现的位置。上述字符串均以 \0 为截断。

返回值

1. strstr 函数将返回 s1 中第一次出现子串 s2 位置的指针，如果 s1 中没有子串 s2 ，则返回 NULL 。
2. 如果 s2 为零长度字符串(即 { '\0' } )，则返回值为 s1 。