<p align="center"><font size="7"><b>编程概述实验报告</b></font></p>
<p align="center"><font size="3">汇报人：代双遥</font></p>
<p align="center"><font size="3">学号：075</font></p>
<p align="center"><font size="3">班级：03班</font></p>
<p align="center"><font size="3">时间：2024/11/24</font></p>
控制结构
一、顺序结构
定义：从上到下依次执行代码。
c
printf("You see me firstly.\n");
printf("You see me secondly.\n");二、选择结构
定义：选择性的执行代码。
关键字：if、switch
我的理解：
- if、else、else if之间的相互配合使用。
- 只会根据顺序结构执行满足其中的一个条件下的代码块。
- 条件的判断存在一定顺序，而不是随意判断。例如：
c
int age = 18;
if (age <= 12) {
printf("You're a pupil.\n");
} else if (age <= 15) {
printf("You're a middle school student.\n");
} else if (age <= 18) {
printf("You're a high-school student.\n");
} else {
printf("You're a college student.\n");
}switch用于快速匹配固定数值的情况。
执行速度快于if类。
搭配enum枚举类型使逻辑更加清晰。
cint day = 1; enum DAYS { MONDAY=1, TUESDAY, WENSDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY }; switch (day) { case MONDAY: printf("Today is Monday!\n"); break; case TUESDAY: printf("Today is Tuesday!\n"); break; // 3...7 // default: // 未匹配上 break; }
补充：case后面的第一行代码不能声明变量，如果要声明，必须用“{}”包裹起来，否则程序报错。
c
case 1:
{
int x = 10;
break;
}三、循环结构
定义：重复执行一定次数的代码
关键字：for、while、do while
我的理解：
- for (初始化变量; 终止条件; 更改变量) {};
- 初始化变量可以不唯一，之间用“,”隔开可以声明多个作用域内的临时变量。
- 终止条件可以用“&&”、“||”等逻辑判断符号配合使用。
- 变量更改的大小自定义。
- 嵌套使用、可以为空。
c
for (int i = 1, j = 1; i <= 10 && j <= 100; ++i, j*=10) {
printf("i: %d \t j: %d \n", i, j);
}
// output:
// i: 1 j: 1
// i: 2 j: 10
// i: 3 j: 100- while (true) {};
- 重复执行代码直到预期结果，一次重复之后必须得接近预期结果。
- while的循环形式有多种。根据情况合理选择。
c
// 结束条件单一
int i = 1;
while (i <= 10) {
++i;
}c
// 情况多样
int i = 1;
while (1) {
if (i++ <= 10) break;
}c
// 情况多样
int i = 1;
int cnt = 0;
while (i) {
if (cnt++ == 10) continue;
if (cnt++ == 10) i = 0;
if (cnt % 5 == 0) i = 0;
}- do {} while (true);
- 至少重复一次，与while差不多，基本没实际用过。
四、goto语句
定义：跳转到指定代码行。
关键字：goto
我的理解：
- 尽量不用，容易造成逻辑混乱，易错。
- 标签不跨作用域。
- 当嵌套很多的情况下，用于快速跳出嵌套。
c
int cnt = 0;
for (int i = 0; i < 100; ++i) {
for (int j = 0; j < 100; ++j) {
for (int k = 0; k < 100; ++k) {
if (2 == j) goto end;
++cnt;
}
}
}
end:
printf("cnt: %d\n", cnt);
// output:
// cnt: 200数组
字符串也是一个数组“hello world”
声明数组
c
// 数组类型 int char float int* char* ... 同理
int arr_1[3]; // 仅声明一个数组，-->没有值<--
int arr_2[3] = {0}; // 声明并初始化为0的数组
int arr_3[3] = {1}; // 声明并初始化一个-->首元素为1<--，其他元素为0的数组
int arr_4[] = {1, 2, 3}; // 根据成员数量-->自动设置数组大小<--数组长度
c
int arr[10] = {0};
int arrLen = sizeof(arr) / sizeof(arr[0]); // 数组的总内存大小除以一个元素的内存大小就是元素的个数多维数组
c
// 常用的是二维数组
int arr[5][10] = {0};
// arr[5][10] = {
// {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
// {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
// {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
// {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
// {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
//}数组实质
- 数组名表示的是数组的首元素的地址。
- 对数组进行加减运算，就是移动指向数组元素的指针
c
int arr[] = { 1, 2, 3, 4 };
printf("%d ", *arr);
printf("%d ", *arr+1);
printf("%d ", *arr+2);
printf("%d ", *arr+3);
// output:
// 1 2 3 4补充：VS不支持变量声明数组长度
c
const int ROW = 5;
const int COL = 10;
int arr[ROW][COL]; // 用变量声明函数时不同同时初始化
for (int r = 0; r < ROW; ++r) {
for (int c = 0; c < COL; ++c) {
arr[r][c] = 0;
}
}
// 这么写VS会报错，其他IDE不一定函数
定义：函数就是执行一组代码的一个整体。具有确定性。
我的理解：
函数的使用是为了减少重复的代码
在参数相同的前提下，函数执行后的结果相同。（确定性）
函数的功能应当单一。
- c
int check(int n) { if (n % 2 == 0) { printf("n is an even number!\n"); return 1; } else { printf("n is an odd number!\n"); return 0; } } // 函数内部应尽量避免出现“printf”此类有副作用的语句，使函数的作用被专一化，不具有普遍性，难以复用。 函数不能过于长，冗杂。（函数的内部实现代码数量应尽量不超过50行）
函数内的变量作用域，传递参数的细节。（注意函数内部的临时变量）（不能返回函数内部的临时变量）
指针
我对指针的理解：
指针存在的目的：优化。
理由如下：
已知：每个数据都有自己的地址，以及储存的值，数据存在作用域，指针大小固定且很小。
因此，当数据在函数之间传递时，函数会将实参的值复制粘贴给一个形参，这个形参也有自己的地址，对形参操作不会影响到实参，相当于是在做无用功了。因此，如果有了指针的存在的话，传递指针，也就相当于以一种特殊的方式将实参与形参建立起了联系，让我们可以对实参进行操作，达到目的。？那又为什么数据会有作用域的区别呢？因为储存在不同内存位置的数据，机器读取操作的速度不同，程序执行的效率不用，因此会对数据进行类型判定，在哪个位置储存，因此产生了作用域。
所以，指针的存在可以减小空间占用，阻止减小运行速率。
指针用“*”作为标识符，理解为“解析地址“，通过地址找到数据的意思。地址用“&”作为标识符，获取数据的地址的意思。即”*“后面跟的应该是一个地址，这样合起来才是一个有效的数据。
举例：
c
int a = 1;
int* b = &a;
printf("%d\n", a);
printf("%d\n", *b);
*b = 2;
printf("%d\n", a);
printf("%d\n", *b);
// output:
// 1
// 1
// 2
// 2c
int *b = &a;
// 可以理解为: b = &a a的地址给了b，b的值储存的是a的地址，然后用*来表示b是一个指针
*b = 2 // *就是在对b进行解析，因为b是一个地址，*b就是根据b储存的地址找到对应的数据，也就是找到了a
// 此时*b = 2，就是 a = 2，因此a的值被更改了注意：
数组名，“字符串”，结构体是一个指向首元素地址的指针&arr[0]，类似于上文中的*b，首元素就是a。
当指针被释放之后会成为一个野指针，指向未知内容的指针，存在风险，比如：fclose(pf)之后的pf指针就是一个野指针，free(pf)之后的pf也是一个野指针，应该用pf=NULL，防止使用野指针带来的危害。
使用情景：
函数传参，操作数组，动态分配内存，数据结构链接等等。
结构体
定义：一个存放多个多类型数据的集合。
特性：
由结构体组成的链表不限制长度，内存没有爆的情况下无限链接，灵活性更高，而数组固定了最长长度，可能越界，灵活性低。
链表插入元素时更加方便，而数组插入元素时需要移动后面的所有有效元素，消耗更多时间。
链表储存的数据类型多样，数组数据内容单一。对一个整体的特征描述时链表更方便，数组得多维或者多个。
链表测试：
c
// 以下代码为 struct 链表相关操作
#include <stdio.h>
#include <stdlib.h>
// 打包数据
typedef struct Student {
int age; // 4bites
char name[50]; // 50bites
// 不要先声明 name ，因为 name 的占用内存大于 age
// 储存 struct 类型的数据时，上一个数据会尝试等长后面的数据的内存大小
// 即后面的数据申请的内存不会小于前面数据申请的内存大小
// 也就是原本4bites的int类型的数据申请的内存大小为50bites,多余内存空间将被搁置浪费
// char name[50]; // 50bites
// int age; // 50bites
} Student;
// 定义节点
typedef struct Node {
int index;
Student stu;
struct Node* pre;
struct Node* next;
} Node;c
// 添加节点
Node* add_node(Node* nodes, Student stu)
{
Node* node = (Node*)malloc(sizeof(Node));
if (NULL == node) {
printf("Malloc failed!\n");
return nodes;
}
node->stu = stu;
// 防止 node 为野指针
node->pre = NULL;
node->next = NULL;
// nodes 为空，添加首节点
if (NULL == nodes) {
node->index = 0;
return node;
}
// nodes 不为空
Node* temp_node = nodes;
while (NULL != temp_node->next) temp_node = temp_node->next;
node->index = temp_node->index + 1;
temp_node->next = node;
node->pre = temp_node;
return nodes;
}// 删除节点
void free_nodes(Node* nodes)
{
Node* temp_node;
while (NULL != nodes) {
temp_node = nodes;
nodes = nodes->next;
free(temp_node);
}
}c
// 打印节点
void print_node(Node* nodes)
{
Node* temp_node = nodes;
while (NULL != temp_node->next) {
printf("Index: %d, Name: %s, Age: %d\n", temp_node->index, temp_node->stu.name, temp_node->stu.age);
temp_node = temp_node->next;
}
}c
int main()
{
Node* nodes = NULL;
Student s1 = { 18, "Kualk" };
Student s2 = { 16, "Steve" };
Student s3 = { 19, "Best" };
Student s4 = { 20, "Jack" };
nodes = add_node(nodes, s1);
nodes = add_node(nodes, s2);
nodes = add_node(nodes, s3);
nodes = add_node(nodes, s4);
print_node(nodes);
free_nodes(nodes);
return 0;
}知识体系
入门编程学习步骤:
- 简单认识计算机、程序编程等等构建知识网络。
- 照猫画虎地过一遍编程语言语法。
- 练习实践小项目开发。
- 总结不足的能力以及知识盲区。
- 专项训练不足的板块。
知识点：
- 计算机底层运行逻辑
- 数据储存原理
- 抽象思维、编程思想
- 熟悉的编程语言运用
- 简单算法实现
总结：听说、体验、尝试、总结、强化
- 收听讨论编程相关内容，刷帖子，看文档，看教学，看书籍
- 抄代码培养编程感觉
- 独立尝试，分析需求，设计思路，实现功能
- 收集报错，掌握Debug的技巧，记录不会的知识，查资料问AI自行尝试解决
- 复习文档资料，再次独立尝试实现功能，强化运用，记忆
自主学习
参考学习文档《菜鸟教程》
- typedef
- enum
- vector
- C++面向对象
- 等等
- C++语法结构
- 了解C++面向对象
参考电子书《高质量C/C++编程指南》
- 文件结构管理。“.h”头文件用来声明，”.c“文件用来实现功能。
- main函数里面用多个函数构建框架
c
int menu(void);
void func_option(int option);
int main()
{
while (1)
{
int option = menu();
func_option(option);
}
return 0;
}
int menu(void)
{
... // body
}
void func_option(int option)
{
... // body
}- 变量规则
- 固定值用全部大写字母
- 普通变量全部小写
- 对象名称首字母大写
- 命名风格统一不混用驼峰下划线
- 尽量不用extern全局变量
- 增强代码的可读性 >> 减少代码的行数
- 只写必要的注释
- 如果仅仅是一个自变量增1的话，++i 要比 i++ 执行速度快
- 经常做意外判断NULL
- 条件判断的时候NULL先行
c
if (NULL == p) { printf("p is NULL!\n"); }
if (p == NULL) printf("p is NULL!\n");
else printf("p is not NULL!\n");
// 偶尔会误写为 p = NULL 导致条件判断始终为true 程序逻辑出错
// 如果误写为 NULL = p 则程序会报错提示不影响- 利用 return 特性避免大量嵌套善用
c
int func(int n)
{
if (n > 10) {
return 0;
} else {
return 1;
}
// return 之后 else 的话， 可以省略一个嵌套
// if (n > 10) {
// return 0;
// }
// return 1;
}有逻辑的代码紧密排列无逻辑的代码换行分开
代码规范
c// 提倡风格： if (condition) { ... // body } for (init; condition; undate) { ... // body } // 不提倡的风格： if (condition) body; if (condition) { ... // body }......
项目实践开发《 学生管理系统》
运行结果截图：
[图片缺失：image-20241125033347625]
[图片缺失：image-20241125033436444]
[图片缺失：image-20241125033513212]
[图片缺失：image-20241125033524699]
源代码：
删除节点功能失败。
|--StudentManager
|--main.c
|--functions.c
|--data.h
|--functions.h
|--data.txt
c
// main.c
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include "data.h"
#include "functions.h"
// init data
int option = -1;
int status = 1;
Data data = { 0, NULL };
int main()
{
func_read_data(&data);
// main body
while (status)
{
option = menu();
functions(option, &data, &status);
system("pause");
system("cls");
}
system("exit");
return 0;
}c
// functions.c
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <malloc.h>
#include <string.h>
#include <stdlib.h>
#include "data.h"
#include "functions.h"
int menu(void)
{
// Print menu info
printf("*--------*--------*--------*\n");
printf("|----Senior-System-v1.0----|\n");
printf("|--------------------------|\n");
printf("|-------1.Show data--------|\n");
printf("|-------2.Adda data--------|\n");
printf("|-------3.Delt data--------|\n");
printf("|-------4.Find data--------|\n");
printf("|-------5.Clos syst--------|\n");
printf("|--------------------------|\n");
printf("|----Senior-System-v1.0----|\n");
printf("*--------*--------*--------*\n");
// Get option
int select = -1;
printf("\nInput: ");
int is_int = scanf(" %d", &select);
// Is input a int
if (is_int == 0)
{
printf("Input is not a int. Try again!\n");
int space = getc(stdin);
return -1;
}
return select;
}
void functions(int order_code, Data* data, int* status)
{
char target[10];
switch (order_code)
{
case show_data:
func_show_data(data);
break;
case adda_data:
func_adda_data(data);
func_save_data(data);
break;
case delt_data:
{
printf("Input a target name to delete: ");
scanf(" %s", &target);
int index = func_find_data(data, target, "name");
if (index == -1)
{
printf("\nNo target! Delete cmd failed!\n\n");
break;
}
func_delt_data(data, index);
break;
}
case find_data:
{
printf("Input a target name: ");
scanf(" %s", &target);
int index = func_find_data(data, target, "name");
printf("Return index: %d\n", index);
if (index == -1)
{
printf("\nNone student info of %s!\n\n", target);
break;
}
printf("\nFind the student named %s:\n", target);
print_info(data, index);
printf("\n");
break;
}
case clos_syst:
func_clos_syst(status);
break;
default:
printf("None optioin!\n!!!Error: collapsed!!!\n");
break;
}
}
void func_read_data(Data* data)
{
FILE* pf = fopen("data.txt", "r");
// Dubbug
if (pf == NULL)
{
perror("fopen");
return;
}
// Read content
char lines[100];
while (fgets(lines, 100, pf) != NULL)
{
//printf("%s", lines);
// Init node
Student stu = { 0 };
Node* node = malloc(sizeof(Node));
// Split data
char* item = strtok(lines, ",");
int cnt = 1;
while (item != NULL)
{
switch (cnt++)
{
case AGE:
stu.age = atoi(item);
break;
case BORNDAY:
stu.bornday = atoi(item);
break;
case CHINESE:
stu.chinese = (float)atof(item);
break;
case MATH:
stu.math = (float)atof(item);
break;
case ENGLISH:
stu.english = (float)atof(item);
break;
case SEX:
strcpy(stu.sex, item);
break;
case NAME:
strcpy(stu.name, item);
break;
case STUDENT_ID:
stu.student_id = atol(item);
break;
default:
break;
}
item = strtok(NULL, ",");
}
// Update data
node->stu = stu;
node->index = data->size;
node->next = data->first;
data->first = node;
++data->size;
}
// Close file
fclose(pf);
pf = NULL;
}
void func_show_data(Data* data)
{
Node* curNode = data->first;
printf("Student Info\n");
while (curNode->next != NULL)
{
printf("%d) ", curNode->index);
printf("Name: %s\t", curNode->stu.name);
printf("Age: %d\t", curNode->stu.age);
printf("Sex: %s\t", curNode->stu.sex);
printf("Bornday: %d ", curNode->stu.bornday);
printf("ID: %llu ", curNode->stu.student_id);
printf("CN: %.1f\t", curNode->stu.chinese);
printf("MT: %.1f\t", curNode->stu.math);
printf("EN: %.1f\n", curNode->stu.english);
curNode = curNode->next;
}
printf("%d) ", curNode->index);
printf("Name: %s\t", curNode->stu.name);
printf("Age: %d\t", curNode->stu.age);
printf("Sex: %s\t", curNode->stu.sex);
printf("Bornday: %d ", curNode->stu.bornday);
printf("ID: %llu ", curNode->stu.student_id);
printf("CN: %.1f\t", curNode->stu.chinese);
printf("MT: %.1f\t", curNode->stu.math);
printf("EN: %.1f\n", curNode->stu.english);
}
void func_adda_data(Data* data)
{
Node* node = malloc(sizeof(Node));
Student stu = { 0, 10000000, 0, 0, 0, "unkown", "name", 2024000001 };
// Get data
printf("Input student name(%%s[50]): ");
scanf(" %s", &stu.name);
printf("Input student age(%%d): ");
scanf(" %d", &stu.age);
printf("Input student sex(%%s[10]): ");
scanf(" %s", &stu.sex);
printf("Input student bornday(%%8d): ");
scanf(" %8d", &stu.bornday);
printf("Input student student_id(%%llu): ");
scanf(" %llu", &stu.student_id);
printf("Input student Chinese grades(%%f.1): ");
scanf(" %f.1", &stu.chinese);
printf("Input student Math grades(%%f.1): ");
scanf(" %f.1", &stu.math);
printf("Input student English grades(%%f.1): ");
scanf(" %f.1", &stu.english);
// Updata data
node->index = data->size;
node->stu = stu;
node->next = data->first;
data->first = node;
++data->size;
}
void func_delt_data(Data* data, int index)
{
// Remove node..EK
Node* curNode = data->first;
data->first = curNode;
while (NULL != curNode->next)
{
printf("Now index: %d\n", curNode->index);
if (index == curNode->index)
{
curNode = curNode->next->next;
continue;
}
curNode = curNode->next;
}
printf("Now index: %d\n", curNode->index);
if (NULL != curNode)
{
if (index == curNode->index)
{
free(curNode);
}
}
// Resave data
printf("\nDelete data succesfully!\nInput '1' to undo.\n\n");
int is_continue = 0;
scanf(" %d", &is_continue);
if (is_continue == 0)
{
// save data
func_save_data(data);
}
if (is_continue == 1)
{
printf("Delete data undo!\n");
}
}
int func_find_data(Data* data, char* target, char* what_data)
{
Node* curNode = data->first;
while (NULL != curNode->next)
{
//printf("Try...%d...%s...t-%s\n", curNode->index, curNode->stu.name, target);
// Now only support find data by name
if (strcmp(target, curNode->stu.name) == 0)
{
return curNode->index;
}
curNode = curNode->next;
}
if (NULL != curNode)
{
if (strcmp(target, curNode->stu.name) == 0)
{
return curNode->index;
}
}
return -1;
}
void func_clos_syst(int* status)
{
printf("Thanks to use SeniorOS!\n");
*status = 0;
}
void func_save_data(Data* data)
{
Node* node = data->first;
FILE* pf = fopen("data.txt", "w+");
if (pf == NULL)
{
perror("fopen");
}
else
{
while (node->next != NULL)
{
Student stu = node->stu;
char line[100];
sprintf(line, "%d,%d,%.1f,%.1f,%.1f,%s,%s,%llu\n", stu.age,
stu.bornday, stu.chinese, stu.math, stu.english,
stu.sex, stu.name, stu.student_id);
fputs(line, pf);
node = node->next;
}
Student stu = node->stu;
char line[100];
sprintf(line, "%d,%d,%.1f,%.1f,%.1f,%s,%s,%llu\n", stu.age,
stu.bornday, stu.chinese, stu.math, stu.english,
stu.sex, stu.name, stu.student_id);
fputs(line, pf);
fclose(pf);
pf = NULL;
}
}
void print_info(Data* data, int index)
{
Node* curNode = data->first;
while (NULL != curNode->next)
{
if (curNode->index == index)
{
printf("%d) ", curNode->index);
printf("Name: %s\t", curNode->stu.name);
printf("Age: %d\t", curNode->stu.age);
printf("Sex: %s\t", curNode->stu.sex);
printf("Bornday: %d ", curNode->stu.bornday);
printf("ID: %llu ", curNode->stu.student_id);
printf("CN: %.1f\t", curNode->stu.chinese);
printf("MT: %.1f\t", curNode->stu.math);
printf("EN: %.1f\n", curNode->stu.english);
return;
}
curNode = curNode->next;
}
if (curNode->index == index)
{
printf("%d) ", curNode->index);
printf("Name: %s\t", curNode->stu.name);
printf("Age: %d\t", curNode->stu.age);
printf("Sex: %s\t", curNode->stu.sex);
printf("Bornday: %d ", curNode->stu.bornday);
printf("ID: %llu ", curNode->stu.student_id);
printf("CN: %.1f\t", curNode->stu.chinese);
printf("MT: %.1f\t", curNode->stu.math);
printf("EN: %.1f\n", curNode->stu.english);
}
}c
// data.h
#pragma once
enum CMD_CODE
{
show_data = 1, // show data
adda_data, // add data
delt_data, // delete data
find_data, // find data
clos_syst, // close system
};
enum STU_INFO
{
AGE = 1, BORNDAY, CHINESE, MATH, ENGLISH, SEX, NAME, STUDENT_ID
};
typedef struct Student
{
int age;
int bornday;
float chinese;
float math;
float english;
char sex[10];
char name[50];
unsigned long long student_id;
} Student;
typedef struct Node
{
int index; // index of node
Student stu; // student info
struct Node* next; // next node
} Node;
typedef struct Data
{
int size;
Node* first;
} Data;c
// functions.h
#pragma once
#include "data.h"
// Print menu info and get option
int menu(void);
// Execute anctions
void functions(int order_code, Data* data, int* status);
// Cmd read data
void func_read_data(Data* data);
// Cmd show data
void func_show_data(Data* data);
// Cmd adda data
void func_adda_data(struct Data *data);
// Cmd clos data
void func_clos_syst(int* status);
// Cmd save data
void func_save_data(Data* data);
// Cmd find data
int func_find_data(Data* data, char* target, char* what_data);
// Print student info by index
void print_info(Data* data, int index);
// Cmd delt data
void func_delt_data(Data* data, int index);Plain
// data.txtplain
99,20001201,98.0,32.0,35.0,female,Test2,222024075
45,19991001,0.0,0.0,0.0,Female,CODE,2001000008
18,20051205,99.9,99.9,99.9,male,Kualk,2024000001
17,20031101,90.0,82.0,91.0,male,Sandy,2024000002
12,20080216,75.0,19.0,46.5,male,Lucy,2024000003
14,20000527,83.5,80.5,83.5,male,Baby,2024000004
20,20041004,91.0,73.0,99.0,male,Judy,2024000005
26,20050925,73.5,64.0,76.5,male,Loby,2024000006
29,20010706,82.0,53.5,56.0,male,Tody,2024000007
45,10000000,0.0,0.0,0.0,iiii,TEST,2024000001
78,19561017,23.5,11.4,56.2,Female,CINty,1333016549
76,454343,43.0,43.0,54.0,fdsifo,KKKK,354354发展趋势
人工智能和机器学习的发展
C/C++在高性能计算和大规模数据处理方面具有优势，仍然是许多人工智能和机器学习库的底层实现语言之一。
跨平台和移动开发的需求
C语言具有简洁而清晰的语法、高效的执行速度和强大的底层控制能力，因此成为了开发操作系统、编写嵌入式、编译器和其他系统软件的首选语言。
更高级的编程语言和框架的出现
随着移动设备的普及和跨平台开发的需求增加，对其他编程语言和框架的需求也在增加。C/C++作为底层语言，适合需求。
科学编程领域
在为汽车，照相机，DVD等其他现代化设备中逐渐普及的微处理器编程。
进入长期以来一直属于 FORTRAN 的科学编程领域。
软件产业
C 在软件产业中始终是一种重要的技能。
计算机科学前沿热点
信息是计算机的源，知识是信息的模型，人工智能是知识挖掘的动力，三者协调发展是非常必要的。
信息处理技术：
信息源理论和信息的获取；信息的传输、存储、检索、转化和处理；信号的测量、分析、处理及显示；模式信息处理，研究对文字、声音、图像等信息的处理、分类和识别，研制机器图像和语音识别系统。
知识科学
与数学、逻辑学、语言学、认知科学、心理学、哲学等关系相当大。目前知识科学主要的研究领域表现在：知识模型研究，常识性知识研究；非规范知识研究，知识处理的数学理论；知识获取理论和技术；知识科学和软件科学；基于知识的计算机艺术。
智能处理技术
人工智能(Artificial Intelligence，AI)、人工神经网络(Artificial Neural Network，ANN)、遗传算法、逻辑学的高速发展构成了计算机科学发展新趋势。
更多标准包的使用
暂时没需求
C语言的认识
历史：
C89, C95, C99, C11, C17指的是在对应年份的编译器的更新，参考[相关文档](C 的历史_C语言中文网)可以查看更新内容
早期 C：
1969 :基于 BCPL 创建 B ，以作为 Unix 的系统程序语言替代 PDP-7 汇编器
1971 ：于将 B 移植到 PDP-11 时创建 NB （新“ B ”）
1972 ：语言更名为 C
1973 ：以 C 重写
1978 ： The C Programming Language ，第1版
标准 C：
1983 ： ANSI 建立 X3J11 委员会
1988 ： The C Programming Language ，第2版
1989 ：
**C89**，ANSI C 标准出版- 代码化的既存实践
- 新特性 ：volatile 、 enum 、有符号整数 、 void 、本地环境
- 来自 C++ ： const 、函数原型
1990 ： C90 ，ANSI C 标准被接纳为 ISO/IEC 9899-1990
......
特点：面向过程，高效性，可移植性，强大的功能和灵活性，面向编程人员
面向过程
高效性:可以细调程序以获得最大速度或最大内存使用率。
可移植性:在一个系统上编写的C程序经过很少改动或不经修改就可以其他系统上运行。通常只须改变伴随主程序的一个头文件中的几项内容即可修改程序。
强大的功能和灵活性:强大而灵活的 UNIX操作系统的大部分便是用C编写的。其他语言（如 FORTRAN，Perl，Python，Pascal，LISP，Logo和BASIC）的许多编译器和解释器也都用C编写的。
面向编程人员:C语言允许你访问硬件，并可以操纵内存中的特定位。它具有丰富的运算符供选择，让你能够简洁地表达自己的意图。
补充
在函数传参的过程中，数组类型的数据一般不需要用指针，int，char，struct等类型需要用指针。
因为数组本质就是指针，可以直接修改值，而其他类型的大多数据直接传参的时候会复制一个相同值的形参，不会对实参有影响，所以需要修改实参的值的时候需要用指针。