今天我们继续来学习C语言的入门知识点，第一课：C/C++编程笔记：C语言入门知识点（二），请收藏C语言最全笔记！
21. 输入 & 输出
当我们提到输入时，这意味着要向程序填充一些数据。输入可以是以文件的形式或从命令行中进行。C 语言提供了一系列内置的函数来读取给定的输入，并根据需要填充到程序中。
当我们提到输出时，这意味着要在屏幕上、打印机上或任意文件中显示一些数据。C 语言提供了一系列内置的函数来输出数据到计算机屏幕上和保存数据到文本文件或二进制文件中。
标准输出
C 语言把所有的设备都当作文件。所以设备（比如显示器）被处理的方式与文件相同。以下三个文件会在程序执行时自动打开，以便访问键盘和屏幕。
文件指针是访问文件的方式，本节将讲解如何从屏幕读取值以及如何把结果输出到屏幕上。
C 语言中的 I/O (输入/输出) 通常使用 printf() 和 scanf() 两个函数。
scanf() 函数用于从标准输入（键盘）读取并格式化， printf() 函数发送格式化输出到标准输出（屏幕）。
例子：
void main(){
float f;
printf("Enter a float number: ");
// %f 匹配浮点型数据
scanf("%f",&f);
printf("Value = %f", f);
}
输出：
Enter a float number:
12.3
Value = 12.300000
getchar()&putchar() 函数
int getchar(void)函数从屏幕读取下一个可用的字符，并把它返回为一个整数。这个函数在同一个时间内只会读取一个单一的字符。您可以在循环内使用这个方法，以便从屏幕上读取多个字符。
int putchar(int c)函数把字符输出到屏幕上，并返回相同的字符。这个函数在同一个时间内只会输出一个单一的字符。您可以在循环内使用这个方法，以便在屏幕上输出多个字符。
void main(){
int c;
printf( " Enter a value :");
//函数从屏幕读取下一个可用的字符，并把它返回为一个整数。这个函数在同一个时间内只会读取一个单一的字符。您可以在循环内使用这个方法，以便从屏幕上读取多个字符。
c = getchar( );
printf( " You entered: ");
//读取第一个字符
putchar( c );
}
输出：
Enter a value :abcdef
You entered: a
gets() & puts() 函数
char *gets(char *s)函数从stdin读取一行到s所指向的缓冲区，直到一个终止符或 EOF。
int puts(const char *s)函数把字符串 s 和一个尾随的换行符写入到stdout。
void main(){
char str[100];
printf( " Enter a value :");
//读取一行
gets( str );
printf( " You entered: ");
puts( str );
}
输出：
Enter a value :大家好，才是真的好！
You entered: 大家好，才是真的好！
22. 文件读写
上一节我们讲解了 C 语言处理的标准输入和输出设备。本章我们将介绍 C 程序员如何创建、打开、关闭文本文件或二进制文件。
一个文件，无论它是文本文件还是二进制文件，都是代表了一系列的字节。C 语言不仅提供了访问顶层的函数，也提供了底层（OS）调用来处理存储设备上的文件。本章将讲解文件管理的重要调用。
打开文件
您可以使用fopen( )函数来创建一个新的文件或者打开一个已有的文件，这个调用会初始化类型FILE的一个对象，类型FILE包含了所有用来控制流的必要的信息。下面是这个函数调用的原型：
FILE *fopen( const char * filename, const char * mode );
在这里，filename 是字符串，用来命名文件，访问模式 mode 的值可以是下列值中的一个：
如果处理的是二进制文件，则需要使用下面的访问模式来取代上面的访问模式：
"rb", "wb", "ab", "rb+", "r+b", "wb+", "w+b", "ab+", "a+b"
关闭文件
为了关闭文件，请使用 fclose( ) 函数。函数的原型如下：
int fclose( FILE *fp );
如果成功关闭文件，fclose( )函数返回零，如果关闭文件时发生错误，函数返回EOF。这个函数实际上，会清空缓冲区中的数据，关闭文件，并释放用于该文件的所有内存。EOF 是一个定义在头文件stdio.h中的常量。
C 标准库提供了各种函数来按字符或者以固定长度字符串的形式读写文件。
写入文件
下面是把字符串写入到流中的最简单的函数：
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, ...)函数来写把一个字符串写入到文件中。尝试下面的实例：
void main(){
//定义一个空指针文件
FILE *fp = NULL;
//打开文件，打开一个文本文件，允许读写文件。
// 如果文件不存在，则会创建一个新文件。
// 读取会从文件的开头开始，写入则只能是追加模式。
fp = fopen("/Users/devyk/Data/ClionProjects/NDK_Sample/README.md","a+");
fprintf(fp, " fprintf 我是添加进来的1 ");
fprintf(fp, "fprintf 我是添加进来的2 ");
fputs("fputs 我是添加进来的1 ", fp);
fputs("fputs 我是添加进来的2 ", fp);
fclose(fp);
}
读取文件
下面是从文件读取单个字符的最简单的函数：
int fgetc( FILE * fp );
fgetc() 函数从 fp 所指向的输入文件中读取一个字符。返回值是读取的字符，如果发生错误则返回 EOF。下面的函数允许您从流中读取一个字符串：
char *fgets( char *buf, int n, FILE *fp );
函数fgets()从 fp 所指向的输入流中读取 n - 1 个字符。它会把读取的字符串复制到缓冲区buf，并在最后追加一个null字符来终止字符串。
如果这个函数在读取最后一个字符之前就遇到一个换行符 ' ' 或文件的末尾 EOF，则只会返回读取到的字符，包括换行符。您也可以使用int fscanf(FILE *fp, const char *format, ...)函数来从文件中读取字符串，但是在遇到第一个空格和换行符时，它会停止读取。
void main(){
FILE *fp = NULL;
//读取文件
char buff[255];
fp = fopen("/Users/devyk/Data/ClionProjects/NDK_Sample/README.md","r");
fscanf(fp,"%s",buff);
printf("1: %s ", buff);
fgets(buff, 255, (FILE*)fp);
printf("2: %s ", buff);
fgets(buff, 255, (FILE*)fp);
printf("3: %s ", buff );
fclose(fp);
}
23. 预处理器
C 预处理器不是编译器的组成部分，但是它是编译过程中一个单独的步骤。简言之，C 预处理器只不过是一个文本替换工具而已，它们会指示编译器在实际编译之前完成所需的预处理。我们将把 C 预处理器（C Preprocessor）简写为 CPP。
所有的预处理器命令都是以井号（#）开头。它必须是第一个非空字符，为了增强可读性，预处理器指令应从第一列开始。下面列出了所有重要的预处理器指令：
例子:
分析下面的实例来理解不同的指令。
#define MAX_ARRAY_LENGTH 20
（1）这个指令告诉 CPP 把所有的 MAX_ARRAY_LENGTH 替换为 20。使用 #define 定义常量来增强可读性。
#include <stdio.h>
#include "utils.h"
（2）这些指令告诉 CPP 从系统库中获取 stdio.h，并添加文本到当前的源文件中。下一行告诉 CPP 从本地目录中获取 utils.h，并添加内容到当前的源文件中。
#undef FILE_SIZE
#define FILE_SIZE 42
（3）这个指令告诉 CPP 取消已定义的 FILE_SIZE，并定义它为 42。
#ifndef MESSAGE
#define MESSAGE "You wish!"
#endif
这个指令告诉 CPP 只有当 MESSAGE 未定义时，才定义 MESSAGE。
#ifdef DEBUG
/* Your debugging statements here */
#endif
这个指令告诉 CPP 如果定义了 DEBUG，则执行处理语句。在编译时，如果您向 gcc 编译器传递了-DDEBUG开关量，这个指令就非常有用。它定义了 DEBUG，您可以在编译期间随时开启或关闭调试。
预定义宏
ANSI C 定义了许多宏。在编程中您可以使用这些宏，但是不能直接修改这些预定义的宏。
预处理器运算符
C 预处理器提供了下列的运算符来帮助您创建宏：
宏延续运算符()
一个宏通常写在一个单行上。但是如果宏太长，一个单行容纳不下，则使用宏延续运算符（）。例如：
#define message_for(a, b)
printf(#a " and " #b ": We love you! ")
字符串常量化运算符(#)
在宏定义中，当需要把一个宏的参数转换为字符串常量时，则使用字符串常量化运算符（#）。在宏中使用的该运算符有一个特定的参数或参数列表。例如：
#include <stdio.h>
#define message_for(a, b)
printf(#a " and " #b ": We love you! ")
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);
这个实例演示了 token##n 会连接到 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 ", MESSAGE);
return 0;
}
当上面的代码被编译和执行时，它会产生下列结果：
Here is the message: You wish!
参数化的宏
CPP 一个强大的功能是可以使用参数化的宏来模拟函数。例如，下面的代码是计算一个数的平方：
int square(int x) {
return x * x;
}
我们可以使用宏重写上面的代码，如下：
#define square(x) ((x) * (x))
在使用带有参数的宏之前，必须使用 #define 指令定义。参数列表是括在圆括号内，且必须紧跟在宏名称的后边。宏名称和左圆括号之间不允许有空格。例如：
#include <stdio.h>
#define MAX(x,y) ((x) > (y) ? (x) : (y))
int main(void)
{
printf("Max between 20 and 10 is %d ", MAX(10, 20));
return 0;
}
当上面的代码被编译和执行时，它会产生下列结果：
Max between 20 and 10 is 20
24. 头文件
头文件是扩展名为.h的文件，包含了 C 函数声明和宏定义，被多个源文件中引用共享。有两种类型的头文件：程序员编写的头文件和编译器自带的头文件。
在程序中要使用头文件，需要使用 C 预处理指令#include来引用它。前面我们已经看过stdio.h头文件，它是编译器自带的头文件。
引用头文件相当于复制头文件的内容，但是我们不会直接在源文件中复制头文件的内容，因为这么做很容易出错，特别在程序是由多个源文件组成的时候。
A simple practice in C 或 C++ 程序中，建议把所有的常量、宏、系统全局变量和函数原型写在头文件中，在需要的时候随时引用这些头文件。
引用头文件的语法
使用预处理指令#include可以引用用户和系统头文件。它的形式有以下两种：
#include <file>
这种形式用于引用系统头文件。它在系统目录的标准列表中搜索名为 file 的文件。在编译源代码时，您可以通过 -I 选项把目录前置在该列表前。
#include "file"
这种形式用于引用用户头文件。它在包含当前文件的目录中搜索名为 file 的文件。在编译源代码时，您可以通过 -I 选项把目录前置在该列表前。
引用头文件的操作
#include指令会指示 C 预处理器浏览指定的文件作为输入。预处理器的输出包含了已经生成的输出，被引用文件生成的输出以及#include指令之后的文本输出。例如，如果您有一个头文件 char_manger.h，如下：
char *test(void);
和一个使用了头文件的主程序 char_manager.c,如下:
#include "char_manger.h"
int x;
int main (void)
{
puts (test ());
}
编辑器会看到如下的代码信息：
char *test (void);
int x;
int main (void)
{
puts (test ());
}
只引用一次头文件
如果一个头文件被引用两次，编译器会处理两次头文件的内容，这将产生错误。为了防止这种情况，标准的做法是把文件的整个内容放在条件编译语句中，如下：
#ifndef HEADER_FILE
#define HEADER_FILE
the entire header file file
#endif
这种结构就是通常所说的包装器#ifndef。当再次引用头文件时，条件为假，因为 HEADER_FILE 已定义。此时，预处理器会跳过文件的整个内容，编译器会忽略它。
有条件引用
有时需要从多个不同的头文件中选择一个引用到程序中。例如，需要指定在不同的操作系统上使用的配置参数。您可以通过一系列条件来实现这点，如下：
#if SYSTEM_1
# include "system_1.h"
#elif SYSTEM_2
# include "system_2.h"
#elif SYSTEM_3
...
#endif
但是如果头文件比较多的时候，这么做是很不妥当的，预处理器使用宏来定义头文件的名称。这就是所谓的有条件引用。它不是用头文件的名称作为 #include 的直接参数，您只需要使用宏名称代替即可：
#define SYSTEM_H "system_1.h"
...
#include SYSTEM_H
25. 强制类型转换
强制类型转换是把变量从一种类型转换为另一种数据类型。例如，如果您想存储一个 long 类型的值到一个简单的整型中，您需要把 long 类型强制转换为 int 类型。您可以使用强制类型转换运算符来把值显式地从一种类型转换为另一种类型，如下所示：
(type_name) expression
请看下面的实例，使用强制类型转换运算符把一个整数变量除以另一个整数变量，得到一个浮点数：
void main(){
void main(){
int sum = 20,count = 3;
double value,value2;
value = (double)sum / count;
value2 = sum / count;
printf("Value 强转 : %f Value2 wei强转 : %f ", value ,value2);
}
}
输出：
Value 强转 : 6.666667 Value2 wei强转 : 6.000000
整数提升
整数提升是指把小于 int 或 unsigned int 的整数类型转换为 int 或 unsigned int 的过程。请看下面的实例，在 int 中添加一个字符：
void main(){
//整数提升
int i= 17;
char c = 'c'; //在 ascii 中的值表示 99
int sum2;
sum2 = i + c;
printf("Value of sum : %d ", sum2 );
}
输出：
Value of sum : 116
在这里，sum 的值为 116，因为编译器进行了整数提升，在执行实际加法运算时，把 'c' 的值转换为对应的 ascii 值。
26. 错误处理
C 语言不提供对错误处理的直接支持，但是作为一种系统编程语言，它以返回值的形式允许您访问底层数据。在发生错误时，大多数的 C 或 UNIX 函数调用返回 1 或 NULL，同时会设置一个错误代码errno，该错误代码是全局变量，表示在函数调用期间发生了错误。您可以在 errno.h 头文件中找到各种各样的错误代码。
所以，C 程序员可以通过检查返回值，然后根据返回值决定采取哪种适当的动作。开发人员应该在程序初始化时，把 errno 设置为 0，这是一种良好的编程习惯。0 值表示程序中没有错误。
errno、perror() 和 strerror()
C 语言提供了perror()和strerror()函数来显示与errno相关的文本消息。
（1）perror()函数显示您传给它的字符串，后跟一个冒号、一个空格和当前 errno 值的文本表示形式。
（2）strerror()函数，返回一个指针，指针指向当前 errno 值的文本表示形式。
让我们来模拟一种错误情况，尝试打开一个不存在的文件。您可以使用多种方式来输出错误消息，在这里我们使用函数来演示用法。另外有一点需要注意，您应该使用stderr文件流来输出所有的错误。
例子：
void main(){
int dividend = 20;
int divsor = 0;
int quotient;
if (divsor == 0){
fprintf(stderr,"除数为 0 退出运行。。。 ");
exit(EXIT_FAILURE);
}
quotient = dividend / divsor;
fprintf(stderr,"quotient 变量的值为 : %d ", quotient);
exit(EXIT_SUCCESS);
}
输出：除数为 0 退出运行。。。
27. 递归
递归指的是在函数的定义中使用函数自身的方法。
语法格式如下：
void recursion()
{
statements;
... ... ...
recursion(); /* 函数调用自身 */
... ... ...
}
int main()
{
recursion();
}
数的阶乘
double factorial(unsigned int i){
if (i <= 1){
return 1;
}
return i * factorial(i - 1);
}
void main(){
int i = 15;
printf("%d 的阶乘 %ld ",i ,factorial(i));
}
输出：15 的阶乘 140732727129776
斐波拉契数列
//斐波拉契数列
int fibonaci(int i){
if (i == 0){
return 0;
}
if (i == 1){
return 1;
}
return fibonaci(i - 1) + fibonaci( i -2);
}
void main(){
for (int j = 0; j < 10; j++) {
printf("%d ", fibonaci(j));
}
}
输出：
0
1
1
2
3
5
8
13
21
34
28. 可变参数
有时，您可能会碰到这样的情况，您希望函数带有可变数量的参数，而不是预定义数量的参数。C 语言为这种情况提供了一个解决方案，它允许您定义一个函数，能根据具体的需求接受可变数量的参数。下面的实例演示了这种函数的定义。
int func(int, ... )
{
.
.
.
}
int main()
{
func(2, 2, 3);
func(3, 2, 3, 4);
}
请注意，函数func()最后一个参数写成省略号，即三个点号（...），省略号之前的那个参数是int，代表了要传递的可变参数的总数。为了使用这个功能，您需要使用stdarg.h头文件，该文件提供了实现可变参数功能的函数和宏。具体步骤如下：
（1）定义一个函数，最后一个参数为省略号，省略号前面可以设置自定义参数。
（2）在函数定义中创建一个va_list类型变量，该类型是在 stdarg.h 头文件中定义的。
（3）使用int参数和va_start宏来初始化va_list变量为一个参数列表。宏 va_start 是在 stdarg.h 头文件中定义的。
（4）使用va_arg宏和va_list变量来访问参数列表中的每个项。
（5）使用宏va_end来清理赋予va_list变量的内存。
现在让我们按照上面的步骤，来编写一个带有可变数量参数的函数，并返回它们的平均值：
double average(int num,...){
va_list vaList;
double sum = 0.0;
int i ;
//为 num 个参数初始化 valist
va_start(vaList,num);
//访问所有赋给 vaList 的参数
for (int j = 0; j < num; j++) {
sum += va_arg(vaList, int);
}
//清理为valist 保留的内存
va_end(vaList);
return sum/num;
}
void main(){
printf("Average of 2, 3, 4, 5 = %f ", average(4, 2,3,4,5));
printf("Average of 5, 10, 15 = %f ", average(3, 5,10,15));
}
输出：
Average of 2, 3, 4, 5 = 3.500000
Average of 5, 10, 15 = 10.000000
29. 内存管理
本章将讲解 C 中的动态内存管理。C 语言为内存的分配和管理提供了几个函数。这些函数可以在 <stdlib.h> 头文件中找到。
**注意: ** void * 类型表示未确定类型的指针。C、C++ 规定 void * 类型可以通过类型转换强制转换为任何其它类型的指针。
动态分配内存
编程时，如果您预先知道数组的大小，那么定义数组时就比较容易。例如，一个存储人名的数组，它最多容纳 100 个字符，所以您可以定义数组，如下所示：
char name[100];
但是，如果您预先不知道需要存储的文本长度，例如您向存储有关一个主题的详细描述。在这里，我们需要定义一个指针，该指针指向未定义所需内存大小的字符，后续再根据需求来分配内存，如下所示：
void main() {
char name[100];
char *description;
//将字符串 copy 到 name 中
strcpy(name, "迎娶白富美！");
//开始动态分配内存
description = (char *) malloc(200 * sizeof(char));
if (description == NULL) {
fprintf(stderr, "Error - unable to allocate required memory ");
} else {
strcpy(description, "开始添加数据到 description 中");
}
printf("Name = %s ", name );
printf("Description: %s sizeOf 大小 ：%d ", description , sizeof(description));
// 使用 free() 函数释放内存
free(description);
}
输出：
Name = 迎娶白富美！
Description: 开始添加数据到 description 中 sizeOf 大小 ：8
30. 命令行参数
执行程序时，可以从命令行传值给 C 程序。这些值被称为命令行参数，它们对程序很重要，特别是当您想从外部控制程序，而不是在代码内对这些值进行硬编码时，就显得尤为重要了。
命令行参数是使用 main() 函数参数来处理的，其中，argc是指传入参数的个数，argv[]是一个指针数组，指向传递给程序的每个参数。下面是一个简单的实例，检查命令行是否有提供参数，并根据参数执行相应的动作：
void main(int argc , char *argv[]){
if (argc ==1){
printf("argv[%d] == %d",0,*argv[0]);
}
else if (argc ==2){
printf("argv[%d] == %d",1,*argv[1]);
} else{
printf("匹配失败...");
}
}
输出：argv[0] == 47
总结
到了这里，我们连续三天的C语言入门知识点分享，到这里就结束了，你们收获了多少呢？笔者也知道你们如果初学的话肯定一时间也记不住什么，所以还是要记得收藏哈！这个很重要的。
不知道大家在看完 C 基础内容之后在对比下 Java 语法，是不是大部分都差不多，之前有的人说学了 C 在学其它语言都是小菜一碟，现在看来好像是这么回事。个人觉得其实只要会编程语言中的任何一门在学其它语言都会比较容易上手。
自学C/C++编程难度很大，不妨和一些志同道合的小伙伴一起学习成长！
C语言C++编程学习交流圈子，【点击进入】微信公众号：C语言编程学习基地
有一些源码和资料分享，欢迎转行也学习编程的伙伴，和大家一起交流成长会比自己琢磨更快哦！