yomiko2004 发表于 2023-10-3 19:50:00

如何在十分钟之内学完C语言？

如何在十分钟之内学完C语言？

哎哟 发表于 2023-10-3 19:50:41

要想在十分钟就学完并且学会C语言，也不是不可以，不过是针对于C语言的一般知识点完成语法入门。如果你在进行考试时，若发现不会可以用这几个规律对题目进行琢磨，说不定就写出来了。
在C语言中或者很多编程语言在设计时都会遵从一定标准或者说规律，我们接下来先看看其中规律再进行C语言的学习吧。
在此之前，针对很多还是零编程基础的同学可能需要先整体的了解C语言的基础知识，这里专门整理了一套系统化学习资料分享给大家，包含有详细的知识点教程视频和源码笔记，帮助零基础同学也能快速地掌握C语言相关知识！

http://picx.zhimg.com/v2-bb0e709df6f261e8c6181ad6ca953a2e_r.jpg?source=1940ef5c

http://picx.zhimg.com/v2-4621140804d09b9c49ae356277ee4637_r.jpg?source=1940ef5c
你看得懂这个规律你就已经一般语法入门了：

在C语言进行一般的语法编写时其实都是遵从了严谨的逻辑，而这些逻辑会在不同的知识点及概念中进行复用，我们就用这些规律对C语言进行学习。以下是总结出的一般语法规律如果你很理解下面的话，那么你已经掌握了大部分的C语言一般语法了：

[*]双引号引起来的内容为字符串
[*]函数就是某一个功能，用什么功能用什么函数
[*]第一次遇见一个有值的内容或容器需对其进行类型的说明
[*]类型说明放在开头
[*]有逻辑判断时将条件添加到圆括号中
[*]一般数学运算方式跟日常生活中的数学运算类型
[*]一条语句叫做语句，多条语句叫做代码块，不同范围或者层级下的代码块使用花括号进行标记，在数组中用于标记数组内容
[*]逗号用来分隔
[*]等于号将右边内容赋值给左边变量
[*]复杂、简单的表达式就类同于一个数学公式
[*]一个表达式中若需要输出内容，那么肯定先将这个表达式计算后才最后输出
[*]所有有功能性的标点符号必须是英文标点
[*]参数就是给予函数进行运算所必备的传入数据，传入数据一般将内容填写在函数的括号内
[*]变量就是存储一个值的容器
[*]数组就是存储多个值的容器
[*]代码是自上而下的，例如变量需要先创建才可以使用
[*]占位符顾名思义就是为一个值占据一个位置，也就是帮忙排队真正使用到对应的值的时候将会换成正主
[*]结构性代码需紧密贴合，中间不能出现其他的代码
[*]关键字就是表示接下来说明要该关键字进行对应的事件
注：本篇查看对象最好是已经学了C语言一两节课的同学，因为在此篇中将不会讲解代码在哪编写以及用什么软件进行编写等问题。开始计时正式开始学习：

其实以上那几个点就已经包含了很多C语言语法的内容，我们接下来就举例并且适当的进行教学完成C语言一般语法的入门。
如果在阅读中有任何看不懂的地方大家都可以进入下方的学习交流群中请教有经验的技术大佬，大佬有很多，都会热情帮你解答，还有很多志同道合的学习者都在群里分享交流学习心得，学习氛围相当不错，想学好C语言的同学们都可以加入一起学习！
01 输出显示
根据以上规律中的第二点，想要输出内容那么就需要使用一个可以输出的函数，那么这个输出内容的函数在C语言中是 printf()；我们的内容若想输出显示 HelloWorld 那么 HelloWorld 是一串字符串，那么根据以上规律的第一点我们写成 “HelloWorld”，那么在这里 “HelloWorld” 跟 printf() 怎么样结合在一起呢？
此时我们再看第十三点规律“参数就是给予函数进行运算所必备的传入数据，传入数据一般将内容填写在函数的括号内”，得知，直接将内容填入 printf() 的圆括号中即可：
printf("HelloWorld");利用以上总结的规律提升学习效率简直易如反掌。
02 变量
变量根据规律中的第十四点我们得知，变量为一个容器，并且可以存值；但是此时我们还需要查看第三点“第一次遇见一个有值的内容或容器需对其进行类型的说明”；我们在创建一个变量时，这个变量是对值进行存储的容器，那么则需要对这个变量进行类型的说明，根据第四点我们得知类型的说明一般放在开头。
我们在此举例几个类型说明符：int（整数类型）、char（字符类型）、float（浮点数类型）。这几个类型说明符在第一次创建的时候给予说明，即是创建了这几个类型的变量，创建一个变量的一般格式如下：
int 变量名称=变量值根据以上的格式我们将变量名称改为 abc 则是创建了一个名为 abc 的整数类型的变量，那么里面存储的值肯定为整数；等于号可以从第九点规律中得知这就是将右边的变量值存储到左边的变量中，那么代码就可以写成：
int abc=10;03 变量输出
变量输出意思则是将变量进行显示，显示我们使用可以用作显示的函数 printf()，假设此时我们有一个变量 abc 所存储的值是10，那么显示代码是直接写成这样吗：
printf(abc);这是不对的，那是这样吗？
printf("abc");这样也是错的，这样直接显示了 abc 这个字符串，那么我们该怎么做呢？这个时候看规律的17点，我们需要使用占位符。
不同类型使用的占位符不同，每个类型对应一种，或者你可以理解为占位符就是这些变量的男朋友，逛街累了就需要他们去排队，排完队了正式买东西女主才过来挑。在这里 abc 是 int 整数类型，整数类型的占位符为 %d，那直接输出 %d 就行：
printf("%d")那这样对不对？当然不对了，他女朋友哪去了呢？所以在这里我们需要指定一下他的女朋友；我们看规律的第八点，用逗号进行间隔。我们也不需要隔多远，在双引号外用逗号隔开就行，双引号内就像排队的队列，双引号外就是等待的“女朋友”们。
printf("%d",abc)为什么我刚刚说是“女朋友”们？那是因为不能让女生累这所以就一堆男性朋友都去排队去了。假如现在有3个变量，分别是 abc、a1、a3，他们都是整数类型，如何输出呢？那你就看下面的代码了：
printf("%d --- %d --- %d",abc,a1,a3)以上代码中的 — 会照原样输出显示，因为这些都是自己去为自己去排队的，那么在 printf 中的这三个 %d 是怎么对应的呢？第一个 %d 就是对应 abc，第二个就是对应 a1 然后依次类推，最后结果如下：

http://pic1.zhimg.com/50/v2-477a5418a7087cb72012e543105e4eb0_720w.jpg?source=1940ef5c
这一小点完整的代码如下：
int abc=0;
int a1=10;
int a3=20;
printf("%d --- %d --- %d",abc,a1,a3);04 逻辑判断
逻辑判断就是一个情形下条件是否成立从而执行不同的流程。例如明天天气好就去打球，天气不好就在家打游戏，天气好和天气不好就是条件，那么用 C 语言的逻辑判断语句如何表示呢？看下面这个一般的语法标准：
if(条件){
        错了干什么这里打代码
}else{
        对了干什么这里打代码
}以上这个格式其中 if 就是表示接下来要进行逻辑判断，从第五点得知，逻辑判断条件就是放在圆括号之中的，再接着从第七点中得知，花括号内编写的则是代码块，我们可以在其中编写多条代码。
我们可以根据以上的格式编写如下代码：
int a=3;
if(a==3){
        printf("a 是 3 ");
}else{
        printf("a 不是 3 ");
}那以上的代码我们就应该很清楚了，if 是逻辑判断，那么圆括号内的就是表示条件花括号内的就是表示条件是否正确从而执行的不同代码。在 C 语言中使用两个等于号表示判断等于号左边内容值是否与右边内容值相等。

http://pic1.zhimg.com/50/v2-a0cf844bf01ef26ed1e66b6a1091262a_720w.jpg?source=1940ef5c
我们也可以去掉 else 部分，这样如果条件 a==3 判断错误将不会执行别的内容，由此得知 else{} 就表示条件错误后需要执行的部分，而花括号内的代码则是条件错误后具体需要执行的内容。
在此我们还可以判断多个条件：
int a=5;
if(a==3){
        printf("a 是 3 ");
}else if(a==4){
        printf("a 是 4 ");
}else if(a==5){
        printf("a 是 5 ");
}else{
        printf("a 不是 3 ");
}以上出现了一个 else if，这又是什么呢？其实就是判断这个变量 a 如果不等于 3 就继续下一个条件判断，判断成功就只执行其中一个流程内的代码，随后跳出整个 if 结构。

http://pica.zhimg.com/50/v2-5f5266e6d9a4c0220c841754ca29f532_720w.jpg?source=1940ef5c
在此注意，根据规律十八点说明，结构之间必须紧密贴合不能够在在中间打其他的代码哟，例如下面这个就是错的：
int a=5;
if(a==3){
        printf("a 是 3 ");
}else if(a==4){
        printf("a 是 4 ");
}
int b=0;
else if(a==5){`在这里插入代码片`
        printf("a 是 5 ");
}else{
        printf("a 不是 3 ");
}05 循环
在 C 语言中我们有 while 循环、for 循环等，在此用这两个举例。while 和 for 都是关键字，根据规律十九点我们可以得知，while 就是表示开始循环，那么在此处我可以告诉你，最简单的循环是由一个关键字、一个条件和对应代码块组成的。
条件根据规律第五点知道是需要放在圆括号内，随后再看规律第七点，花括号内表示需要执行的代码块，那么查看以下示例：
int a=0;
while(a<10){
        printf("我在循环...");
        a++;
}那么就可以很清楚的知道 while 就是表示要开始循环，圆括号内的条件是 a<10，这是这个循环执行的时候需要判断的条件，若这个条件错了那么则不再进行循环，最后再看花括号内的代码，输出显示 “我在循环…” 这个字符串；
在这里需要说一下 a++，a++表示 a 这个变量自己自增加1，意思就是 a 最开始是0，自增1后那就是1了，随后每次循环都执行一次，知道 a<10 这个条件不对则不再进行循环。

http://pic1.zhimg.com/v2-3c23fea6dac64676357fc92c296419bb_r.jpg?source=1940ef5c
那还有一个 for 循环呢？for 循环也很简单，不过跟 while 循环会有一定的差别。
int a;
for(a=0;a<10;a++){
        printf("我在循环...");
}以上代码中，for 表示循环，但是在圆括号后中不止有条件。圆括号中的 a=0 表示第一次循环执行一次 a=0，也就是把 0 存储到 a 变量中，a<10 肯定是条件了，随后 a ++ 则是表示每次循环 a 就会加1。
以上结果跟 for 循环的结果都一致。

http://picx.zhimg.com/v2-3c23fea6dac64676357fc92c296419bb_r.jpg?source=1940ef5c
06 数组
我们可以从第十五点规律中得知，数组就是存储多个值的容器，那么创建一个容器肯定要说明类型，然后给予一个数组名，最后给予一个内容，我们可以根据第七条规律得知，数组的内容是使用花括号标记的，那具体如何写呢？我们可以查看一下格式：
类型 数组名[]={值1,值2}从以上格式中我们可以得知，开头就是类型，随后就是数组名，在数组名右侧是有一个方括号，表示这个是数组，随后等于号右边用花括号将其值进行了引入，并且不同值之间使用了逗号进行分隔。那我们现在看一个C语言的数组代码：
int a[]={9,6,3,2,5,8,7,4,1,0};以上代码中创建了一个整型数组 a，里面存储了 9,6,3,2,5,8,7,4,1,0 ，他们之间使用了逗号进行分隔。
那我现在想显示这个数组内容怎么办？很简单，使用 printf() 函数呗，由于我们这个数组值的类型是整型，肯定使用 %d 作为占位符，那么这样写肯定是没错的：
printf("%d ");那接下来怎么写呢？我们如果这个时候想显示第一个元素也就是 9，那怎么显示？这时通过一个叫做下标的知识点就可以完成了。例如 a就表示9，a就表示6，a就表示3，从0开始依次递增：
int a[]={9,6,3,2,5,8,7,4,1,0};
printf("%d ",a);
http://pic1.zhimg.com/50/v2-d5ee0989069b7b5790251625b20cad9f_720w.jpg?source=1940ef5c
不知道对于基础较差的同学这样讲解能不能跟上进度，其实这都是C语言入门很基础很简单的东西，把这部分基础打牢在后面学习中遇到的的困难都会很容易突破，大家可以领取下方的学习教程资料，跟随教程讲解学习基础知识会相对轻松很多！

http://pic1.zhimg.com/v2-ee87d0eb9c2e52cb191c20bdeba4f64f_r.jpg?source=1940ef5c

http://pica.zhimg.com/v2-a6d26c6756e13e0bd1602343cb9b249a_r.jpg?source=1940ef5c
07 自定义函数
自定义函数跟变量声明一样，类型说明符要放开头，可以查看第四点规律。自定义函数的格式如下：
类型说明符 函数名(){
        函数体代码
}函数是一个功能，那么自定义函数就是自己去写一个功能，在此我编写一个自定义函数，该自定义函数的功能就是返回一个值：
int r1(int a,int b){
        return a+b;
}以上函数 int 表示返回值是整数类型，r1 是这个函数的名称，圆括号内是参数；int a和 int b 表示接收两个类型的函数，但是接收后需要有一个标记去引用，在这里就是对这两个函数进行命名为 a 和 b，他们之间使用逗号进行间隔，规律符合第八点规律；
随后在花括号中编写这个函数的函数代码，符合第七点规律；在花括号内 return 表示将 a+b 的结果进行返回，你若传入两个数字一个是 11 一个是 2 那么将会返回3，如下完整代码示例：
#include<stdio.h>

int r1(int a,int b){
        return a+b;
}

int main(){
        int a;
        a=r1(11,2);
        printf("%d ",a);
}
http://picx.zhimg.com/50/v2-254f0be4046f1c6e4fb0bcc1461acc4d_720w.jpg?source=1940ef5c
在函数中 return a+b 其中 a+b 就是表达式，将会先计算，最后再返回，符合第十一点规律。在使用函数时使用函数名进行调用，传入的值使用逗号进行间隔，最终将会返回出来赋值给 a 变量；其实 a=r1(11,2); 这一行代码也符合规律第十一点，将会先进行函数的内容最后才会返回出来。
08 结构体
结构体其实就是一种复合的数据类型，使用一个结构体，你可以为结构体内的元素进行赋值从而定义一种类型的不同属性。结构体也非常符合之前函数、变量创建的方式，我们先看一个代码：
struct human{
    int age;
    char sex;
    char name;
} ;
struct human xiaoming; 以上代码 struct 就是结构体的一个关键字，human 就是这个机构体名，花括号内就是结构体的复合元素，在这里有整型变量 age、字符类型 sex以及字符类型 name，在花括号结尾再添加分号表示结束即可。
那么此时 human 就是表示一个结构体或者说是你自己创建的一种数据类型；之前我们说过直接使用数据类型修饰一个变量就可以了，不过在结构体中你还需要表示这个是个结构体变量，所以在开头加一个 struct 进行标记写成 struct human xiaoming; 。
那如何使用呢？我们看以下的示例：
#include<stdio.h>

void main(){
        struct human{
          int age;
          char sex;
          char name;
        } ;
        struct human xiaoming;
        xiaoming.age=10;
        xiaoming.sex='T';
        xiaoming.name='M';
        printf(" age 为：%d\n",xiaoming.age);
        printf(" sex 为：%c\n",xiaoming.sex);
        printf(" name 为：%c\n",xiaoming.name);
}以上代码中 %c 则表示为字符类型数据进行占位，xiaoming.age 表示 xiaoming 这个使用这个结构体变量之中的 age 属性并且赋值为 10；xiaoming.sex=‘T’; 则表示给 sex 属性赋值为 T，在 C 语言中字符数据是使用单引号进行表示的。

http://picx.zhimg.com/50/v2-23907078e433f0af43ceb8e9660f3cab_720w.jpg?source=1940ef5c
如果想进行较为完整且简单的学习可以参照以下的完整入门教程，内容清晰详细，之后四点讲解通俗易懂，零基础也能轻松掌握，还有大量实战项目练习资料和电子书籍都能免费领取，为同学们节省不少学习成本，需要的同学不要犹豫，抓紧时间领取学习！

http://picx.zhimg.com/v2-dcc4062301f956e01b921cb92a5858e0_r.jpg?source=1940ef5c

http://pica.zhimg.com/v2-84be9dd016b4ce2b9208ffac1bbc6772_r.jpg?source=1940ef5c

http://picx.zhimg.com/v2-bfd705fc76918ae78479da9df72b7ca8_r.jpg?source=1940ef5c

diyaxu88 发表于 2023-10-3 19:50:53

？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？
之前回答了三天学完Java，今天又来了10分钟学完C语言？
10分钟估计环境都没搭好，顶多把hello world学会。
如果刚学编程，真是想系统学完C语言，至少拿出一个月左右时间吧。
这里给大家一份系统学习C语言的路线，学习一定要系统，不要想着几天就把C语言学会了：
C 语言超详细系统学习路线（2023）
http://picx.zhimg.com/v2-3b491dd65342c0b214ebf09ebccd571e_r.jpg?source=1940ef5c
如果你不想看冗余的文字，直接看我画的这个思维导图即可：

http://picx.zhimg.com/v2-b1a1c2f97ef688221f1183ed7fc42f7f_r.jpg?source=1940ef5c
首先，分享一份大学期间自己整理的电子书库，绝不是在网上那种打包下载的，而是自己需要学到某个方向知识的时候，去网上挨个找的，最后汇总而成。
汇集了编程语言(Java、C++、C、Python等等)、操作系统、计算机网络、系统架构、设计模式、程序员数学、测试、中间件 、前端开发、后台开发、网络编程、Linux使用及内核、数据库、Redis....等主流的编程学习书籍。
我整理的这些书大家可以在这里获取，对于学习计算机的同学帮助非常大，且十分系统：

http://pica.zhimg.com/50/v2-d7a9537446e8aafeb0c5feb8cce72fc5_720w.jpg?source=1940ef5c
整理的这些书大家可以在这里获取，对于学习计算机的同学帮助非常大，且十分系统：
书单：
计算机必看经典书单(含下载方式)第一阶段：初学少看书，多看视频

这真的是血泪教训，我大一会傻乎乎的去把课本看一遍，然后做课本后面编程练习题。
学得那叫一个艰难呀，大家都知道，课本为了保留其严谨性和全面性，往往都具有一个特点，那就是「不说人话」。

对于 C 语言，初学者有一个难点需要克服，就是容易遇到各种编译、链接错误，而且不知道怎么解决：


http://picx.zhimg.com/v2-fcbb4bbffa9c786ec965439b78341481_r.jpg?source=1940ef5c

比如这种很初级的报错，但是初学者往往看到就慌了。
遇到这种情况，我的建议是仔细读报错的提示，解决方法往往就在这些 note 中，如果实在解决不了，就复制 note 去 Google 上搜。

这个阶段你需要三份资料：

[*]一是补 CS 基础概念，也就是计算机导论
[*]二是一本 C 语言的好书。
[*]三是一个优质的 C 语言视频
对于每一点，我都只推荐一份我觉得最合适的，避免你陷入选择困难症：

[*]计算机导论

CS 50，这是哈佛的一门计算机入门神课，忘了是在大一下还是大二看的了，当时觉得如获至宝。 链接如下：
https://cs50.harvard.edu/college/2021/spring
让我现在还记忆尤新的一个点，是这个老师讲到 binary search 的时候，直接举了查字典这个过程，然后现场手撕字典。。。


http://picx.zhimg.com/v2-0af846fecff90281fff78da0b2b1dc62_r.jpg?source=1940ef5c

另外，这门课是用 C 语言作为教学语言的，非常难得。
因为现在国外很多 CS 名校的导论课都会采用类似 Python、Schema 这样的语言。
但其实你会发现，在 CS 50，不会讲多少 C 语言的语法，C 语言只是作为一种传递编程思想、引领你入门计算机的媒介。
而不是在教 C 语言。

[*]C 语言视频
不多说了，推荐一个我以前在地铁都在刷的，浙大翁凯老师教授的，直接去中国大学 MOOC 搜索即可，这是链接：
https://www.icourse163.org/course/ZJU-199001
说到这，我不得不多说两句翁凯老师了，我看了好几门他的课，最直观的感受是：
讲解透彻、声音好听，而且特别注重细节，贴一张浙大匿名教室系统关于翁凯老师的评价吧：


http://pica.zhimg.com/v2-de532dbab76d6ced38c87c6df6e4ba7f_r.jpg?source=1940ef5c

一句话，翁凯老师是真的想把计算机内部原理、编程语言以深入浅出的方式教给大家。

[*]C语言书
《C程序设计语言》，一本被称作 C 语言圣经的书。
在短小的篇幅中，涵盖了 <stdio.h>、<string.h> 中的大部分例子，习题也都是经典，从 hello world 开始，到二分查找、二叉树、快排、哈希表等，甚至还用递归下降写了词法分析，帮你理解复杂的声明。
不过要看懂里面的每一个例子，也是有一定难度的，需要有一点点基础，但是不妨碍作为入门书，可以多看几遍。
对了，一直说学编程要多写，但是很多初学者也不知道写什么。
在这里，我给出一些学完 C 语言基本语法后，可以练手的例子：

[*]链表
就用 C 语言把链表翻来覆去的写，从最基本的链表插入、删除、单向、双向、环装链表。
到链表反转、合并、分割等。
别看基础，但是很多同学到大四了，可能都写不对，这里考察是否足够细心、逻辑是否缜密。
会不会操作着就把链给断了。

[*]写点小东西
比如图书管理系统、俄罗斯方块、贪吃蛇之类。

这种代码量大多在 500 - 1000，会综合运用函数、文件操作、动态内存、指针这些关键的东西。

第二阶段：搞懂内存，看书、写代码



http://picx.zhimg.com/v2-28848cf7b227e4856dbb642062c502ff_r.jpg?source=1940ef5c

这个阶段，是需要掌握一些计算机系统知识才能学好的，比如虚拟地址就和操作系统相关了，而函数调用栈这些又和汇编相关。
又比如很多学了很久的同学，还不太清楚变量的声明和定义区别，extern 又有什么作用，这些实际上就需要理解内存分区的东西。

C 语言的核心就在于指针、内存，能不能学好、用好 C 语言，更多在于是否拥有扎实的计算机结构、存储、运算原理方面的知识。
所以强烈建议在学习 C 语言的同时去了解一下补码、数的二进制表示、内存、汇编等知识，尤其是内存和汇编，这两个对于深刻理解指针和熟练运用有很大的帮助。
我就不仔细介绍了，要介绍的书都在这张思维导图里了。


[*]深入学习指针
《C和指针》、《深入理解C指针》，真的是涉及指针方方面面的好书，墙裂推荐。

[*]编译、链接
这俩兄弟懂了其实也不能帮你提高写代码的水平，主要是对于一些编译、链接过程的报错，更加的明确，不至于懵。
比如链接过程中常见的错误是符号未找到（undefined reference）和符号重定义（redefinition）
当你熟悉链接过程，符号查找过程之后，解决对应的报错也会得心应手。


[*]汇编
C 语言之下就是汇编，会汇编，你就能直接把 C 语言衣服扒掉，看看背后的实现，比如大家都在讨论数组和指针有什么区别？
你去写个程序，然后 gcc -S 一下，看下汇编代码，你就会发现没啥区别。。。
汇编不需要会写，会看懂部分记得，大可不必去刻意的记住各种指令、寻址方式。
最后给大家推荐一下我开发的计算机系统学习网站，有Java、C++、Python、操作系统、网络等学习路线，计算机必读书籍PDF、C++、Java、计算机基础面试题等：
计算机学习路线大全（2023版）
那么C语言包含哪些知识呢？
作者：CSDN学院 链接：https://www.zhihu.com/question/390940749/answer/1286075997 来源：知乎
C语言应用十分广泛，下面为大家带来C语言基础知识梳理总结，我们先来看一张图



http://picx.zhimg.com/v2-ed696a2ba110c3434b99fb8863d39bea_r.jpg?source=1940ef5c
算法结构：
一、顺序结构、选择结构、循环结构；
二、循环结构又分为while型、until型、for循环结构；程序流程图；

结构化程序设计方法：
（1）自顶向下；（2）逐步细化；（3）模块化设计；（4）结构化编码。
数据类型：
常量：常量包括字面常量、直接常量和符号常量；
变量：C语言规定标志符只能由字母、数字和下划线三种字符组成，且第一个字符必须是字母或者下划线；必须压迫先定义后使用；每一个变量被定义以确定类型后，在编译时就能为其分配相应的存储单元；
整数类型：整数常量有十进制、八进制和十六进制；“%d”
整形变量：数据在内存中存放形式是以二进制形式存放；有int型、short int型和long int型，无符号整型变量的范围是-32768—32767，有符号型为0~65535.通常把long定义为32位，把short定义为16位，int可以是32位也可以为16位，这都主要取决于机器字长。
实型常量的表示方法：（1）十进制，0.0；（2）指数形式，123e3
实型变量：实数型数据在内存中的存放形式，一般在内存中占4个字节，分成整数部分和小数部分存放。实型变量分为float型、double型long double型。实型数据会存在舍入误差。
实型常量的类型：C编译系统将实型常量作为双精度来处理。
字符型数组：（一）字符常量：转义字符（\n——换行，\t——tab,\r——回车，\f——换页，\b——退格，\ddd——1到3位8进制的数代表的字符）

C的运算符有以下几种：
1、算术运算符（+ - * /%）结合方向自左向右
2、关系运算符（> < == >= <= !=）
3、逻辑运算符(! && ||)
4、位运算符(<< >> ~ | ^ &)
5、赋值运算符(=及符号扩展赋值运算符)
6、条件运算符(? : )
7、逗号运算符( , )
8、指针运算符（* &）
9、求字节运算符（sizeof）
10、强制类型转换运算符((类型))
11、分量运算符( . ->)
12、下标运算符([])
13、其他

控制语句：
完成一定的控制功能。
1、if()~else~
2、for()~
3、while()~
4、do~while()
5、continue
6、break
7、switch
8、goto
9、return

字符数据的输入输出：
1、putchar（）输入字符变量
2、getchar（）只能接受一个字符

格式输入输出：
1、printf（%d—整型，%c—字符型，%ld，%md，%o，%u，%s，%-m.nf，%e，%g）
2、scanf（格式控制，地址列表）

数组
一维数组的定义：类型说明符 数组名【常量表达式】；先定义后引用；一维数组初始化时可以只对一部分元素初始化，在对全部数组元素初始化的时候可以部规定长度；但是若被定义的数组长度与提供的初始值不一样时，则数组长度不能省略。
二维数组的定义：类型说明符 数组名【常量表达式】【常量表达式】C语言中存放二维数组是先存放第一行的元素，紧接着是第二行，其实也是以一维的方式存放。如果初始化时能指定所有元素的初始值，第一维大小可以省略，但是第二维不能省略。
字符数组：定义和初始化跟数组差不多，只是需要加单引号。字符和字符串结束标志，C语言规定，以‘\0’代表。

字符串处理函数：
1、puts()将一个字符串输出到终端
2、gets（）从终端输入一个字符串到字符数组，并且得到一个函数值。
3、strcat（）链接两个字符数组中的字符串。
4、strcpy（）字符串复制函数。
5、strcmp（）比较字符串作用。
6、strlen（）测试字符串长度的函数不包括“\0”
7、strlwr（）将字符串中的大写字母转换为小写字母。
8、strupr（）将字符串中的小写字母转换为大写字母。

函数
（1）一个源程序由多个函数组成。
（2）C程序的执行从main（）函数开始；
（3）所有函数都是平行的；
（4）函数分类；可以分为标准和自定义，还可以分为有参函数和无参函数。

函数定义的一般形式：
（1）类型标志符函数名（）
　　{
声明部分
语句
　　}
（2）类型标志符函数名（形式参数列表）
　　{
声明部分
语句
　　}
关于形参和实参的说明：
(1) 在定义函数中指定的形参，在未出现函数调用时，他们并不占用内存中的存储单元，只有发生调用时，才会分配内存。
(2) 实参可以是常量、变量或者表达式；有时传递的时地址；
(3) 在被定义中，形参必须指定类型；
(4) 实参与形参的类型应相同或赋值兼容；
(5) C语言规定，实参变量对形参变量的数据传递是“值传递”，即单向传递，只有实参传递给形参，而不能由形参传递给实参。

函数的返回值：
希望通过函数调用使主调函数得到一个确定的值。
（1）函数的返回值是通过函数中的return语句获取的。
（2）函数值的类型；
（3）如果函数值的类型和return语句中表达式的值不一样，则以函数类型为准。
（4）如果调用函数中没有return语句，并不带回一个确定的用户需要的值，函数不是不带回值，而只是不带回有用的值，带回一个不确定的值。
（5）如不需要带回任何值，用void。

函数的调用：
调用方式1、函数语句；2、函数表达式；3、函数参数。
被调用的函数的声明：
一个函数调用另一个函数所具备的条件:
1、首先被调用的函数必须是已经存在的函数；
2、如果使用库函数，一般应该在本文件开头用#include命令将调用有关库函数时在所需要用到的信息“包含”到本文件中。.h文件是头文件所用的后缀。
3、如果使用用户自己定义的函数，而且该函数与使用它的函数在同一个文件中，一般还应该在主调函数中对被调用的函数做声明。
4、如果被调用的函数定义出现在主调函数之前可以不必声明。
5、如果已在所有函数定义之前，在函数的外部已做了函数声明，则在各个主调函数中不必多所调用的函数在做声明。

局部变量和全局变量：
（一）局部变量在一个函数内部定义的变量是内部变量，它只是在本函数范围内的有效，主函数也不能使用其它函数中定义的变量；
不同函数中可以使用相同的名字的变量，他们代表不同的对象，互不干扰；
形式参数也是局部变量；
在一个函数内部，可以在复合语句中定义变量，这些变量只在本复合语句中有效，这种复合句也可以称为“分程序”或“程序块”；
（二）全局变量，在函数之外定义的变量称为外部变量，全局变量可以增加函数间数据联系的渠道，一般不再必要时不要使用，他在程序的全部执行过程中占用存储单元，是函数的通用性，使用全局变量会使程序的清晰性降低。
还要注意若果同一源文件中，外部变量和局部变量同名，则在局部变量作用范围内，外部变量被“屏蔽”，不起任何作用。

变量的存储类别：


[*]（变量值存储时间）动态存储方式，在程序运行期间进行分动态的分配存储空间的方式，静态存储方式是指在程序运行期间分配固定的存储空间的方式；
[*]存储空间分为程序区、静态存储区和动态存储区；
[*]全局变量全部放在静态存储区中，程序开始时分配空间，完毕时释放；
动态存储区中存放以下数据：
1、函数形式参数；
2、自动变量；
3、函数调用时的现场保护和返回地址；在C语言中每个变量和函数都有两个属性，是数据类型和数据存储类型，存储类别是数据在内存中存储的方式。

存储方式分为静态和动态存储类，具体包含有四种：自动的（auto），静态的（static），寄存器的（register），外部的（extern），如果不加以声明，就自认为是auto型就会自动分配存储空间属于动态存储方式。
Static声明局部变量是在函数调用结束后不消失而保留原值，即占用存储单元不释放，在下一次调用该函数时，该变量已有值，就是上次函数调用结束时的值。其中需要说明的是在定义局部变量不赋初值的话，则静态局部变量编译时自动赋值为0或者空字符，虽然静态局部变量在函数调用结束后仍然存在，但是其他函数不能引用它的。
静态局部变量主要用在当初始化后，变量只是被引用而不改变其值。Register变量是C语言中允许将局部变量的值放在CPU中的寄存器中需要时直接从寄存器中取出来参加运算，不必再到内存中提取，但是计算机系统中寄存器数量有限，不能任意定义任意多的存储器，局部静态变量不能定义为寄存器变量。
Extern声明外部变量，用以扩展外部变量的作用域。在一个文件中，如果定义之前的函数想引用该外部变量，则应该在引用之前用关键字extern对该变量做外部变量声明。在多文件中，也可以采用extern声明的办法进行外部变量声明。
有时希望某些局部变量只限于被本文件引用，而不能被其他文件引用，这时就可以采用在定义外部变量时外加一个static，这在程序模块化设计中加强了通用性。Static来声明一个变量的作用有二个，一个是在声明对局部变量时。则为该变量分配的空间在整个程序执行期间始终存在；
一个是在对全局变量声明中，该变量的作用域仅限于本文件模块操作。注意：这些方法同样适用于函数的声明

未完待续。。
最后给大家分享一下计算机系统学习网站，学习路线大全，包含各个方向的学习路线和资源推荐，以及学习方法，强烈推荐收藏：
计算机系统学习网-编程指北

[*]如何自学篇

[*]计算机专业如何系统自学？
[*]如何高效阅读计算机类书籍？
[*]如何快速学习掌握一门编程语言？

[*]计算机基础篇

[*]操作系统超详细系统学习路线
[*]操作系统系统书籍分类推荐
[*]计算机网络超详细系统学习路线
[*]如何系统学习网络编程
[*]编译原理系统学习路线

[*]C++方向学习路线

[*]C++ 语言超详细系统学习路线
[*]Linux C++ 后台开发系统学习路线

[*]Java方法学习路线

[*]Java 后台超详细系统学习路线

[*]C语言方向学习路线

[*]C 语言超详细系统学习路线

[*]后台中间件(MySQL、Redis、MQ等)

[*]Redis 超详细系统学习路线

[*]Python方向学习路线

[*]Python超详细一条龙版学习路线
[*]Python Web 开发系统学习路线

defect 发表于 2023-10-3 19:51:33

没有10年植物人经历，压根问不出这么牛逼的问题。。。。
花9分钟睡着，1分钟做梦应该能梦到自己学会C语言了～
好了，不逗乐了，既然题主问了如何学C语言，还是系统的解答下吧：
作者：天涯明月笙；原链接：https://zhuanlan.zhihu.com/p/40076560；来源：知乎c语言入门

C语言一经出现就以其功能丰富、表达能力强、灵活方便、应用面广等特点迅速在全世界普及和推广。C语言不但执行效率高而且可移植性好，可以用来开发应用软件、驱动、操作系统等。C语言也是其它众多高级语言的鼻祖语言，所以说学习C语言是进入编程世界的必修课。
hello,world
#include<stdio.h>
int main()
{
/*在双引号中间输入Hello World*/
printf("Hello World"); return 0;
}
注：在最新的C标准中，main函数前的类型为int而不是void
c语言的具体结构

简单来说，一个C程序就是由若干头文件和函数组成。



http://pic1.zhimg.com/50/v2-662ff624091c9a741622ed878ee59003_720w.jpg?source=1940ef5c


[*]#include <stdio.h>就是一条预处理命令, 它的作用是通知C语言编译系统在对C程序进行正式编译之前需做一些预处理工作。
[*]函数就是实现代码逻辑的一个小的单元。
必不可少之主函数
一个C程序有且只有一个主函数，即main函数。



http://pic1.zhimg.com/50/v2-de7d982817f29e849733ad285a4ee60c_720w.jpg?source=1940ef5c


[*]C程序就是执行主函数里的代码，也可以说这个主函数就是C语言中的唯一入口。
[*]而main前面的int就是主函数的类型.
[*]printf()是格式输出函数，这里就记住它的功能就是在屏幕上输出指定的信息
[*]return是函数的返回值，根据函数类型的不同，返回的值也是不同的。
[*]\n是转义字符中的换行符。(注意：C程序一定是从主函数开始执行的)
顺便给题主和大家送一本BAT大佬的算法笔记，对于程序员而言，算法一定是重中之重，这本书是一位阿里P8刷leetcode整理出来的，身边不少朋友通过它加入大厂：
Github 疯传！史上最强悍！阿里大佬「LeetCode刷题手册」开放下载了！这本书的目录非常经典：

http://pic1.zhimg.com/v2-adbb447e5009e2d10fbbda795120b1ab_r.jpg?source=1940ef5c
良好习惯之规范

[*]一个说明或一个语句占一行，例如：包含头文件、一个可执行语句结束都需要换行。
[*]函数体内的语句要有明显缩进，通常以按一下Tab键为一个缩进。
[*]括号要成对写，如果需要删除的话也要成对删除。
[*]当一句可执行语句结束的时候末尾需要有分号。
[*]代码中所有符号均为英文半角符号。

http://pic1.zhimg.com/v2-43dd2f12337075631d2f035ab7b32357_r.jpg?source=1940ef5c

程序解释——注释
注释是写给程序员看的，不是写给电脑看的。
C语言注释方法有两种：
多行注释： /* 注释内容 */
单行注释： //注释一行
有名有姓的C(标识符)
C语言规定，标识符可以是字母(A～Z，a～z)、数字(0～9)、下划线_组成的字符串，并且第一个字符必须是字母或下划线。在使用标识符时还有注意以下几点：

[*]标识符的长度最好不要超过8位，因为在某些版本的C中规定标识符前8位有效，当两个标识符前8位相同时，则被认为是同一个标识符。
[*]标识符是严格区分大小写的。例如Imooc和imooc 是两个不同的标识符。
[*]标识符最好选择有意义的英文单词组成做到"见名知意"，不要使用中文。
[*]标识符不能是C语言的关键字。想了解更多C语言关键字的知识。
另外，看C语言经典书籍是很好的入门方式，我在过去12年学习过的书单，其中包括大量C语言经典书籍，打包送给大家：

http://picx.zhimg.com/v2-f2c98d56488a69f9b157c642e43de308_r.jpg?source=1940ef5c
以上这些书籍，我已经帮大家打包好了，点击下方链接直接获取：
计算机经典书籍
变量及赋值
变量就是可以变化的量，而每个变量都会有一个名字（标识符）。变量占据内存中一定的存储单元。使用变量之前必须先定义变量，要区分变量名和变量值是两个不同的概念。



http://picx.zhimg.com/50/v2-64f2cd73f550a7792ffde05327360836_720w.jpg?source=1940ef5c

变量定义的一般形式为：数据类型 变量名;
多个类型相同的变量：数据类型 变量名, 变量名, 变量名...;

http://pic1.zhimg.com/50/v2-288792b9f35621e95d29c6cc9d2b5105_720w.jpg?source=1940ef5c

注意:在定义中不允许连续赋值，如int a=b=c=5;是不合法的。
变量的赋值分为两种方式:

[*]先声明再赋值
[*]声明的同时赋值
基本数据类型
C语言中，数据类型可分为：

[*]基本数据类型
[*]构造数据类型
[*]指针类型
[*]空类型四大类

http://pic1.zhimg.com/v2-b82c1ad3e98a00bb5454b99a99bb6ac9_r.jpg?source=1940ef5c

最常用的整型, 实型与字符型(char,int,float,double):

http://pic1.zhimg.com/v2-864d0fb508e1ce31be20c9c90497a8f3_r.jpg?source=1940ef5c

整型数据是指不带小数的数字(int,short int,long int, unsigned int, unsigned short int,unsigned long int):

http://picx.zhimg.com/v2-db1e8b2294a1fae432c9ae7d99434706_r.jpg?source=1940ef5c

注：

[*]intshort intlong int是根据编译环境的不同，所取范围不同。
[*]而其中short int和long int至少是表中所写范围, 但是int在表中是以16位编译环境写的取值范围。
[*]另外 c语言int的取值范围在于他占用的字节数 ，不同的编译器，规定是不一样。
[*]ANSI标准定义int是占2个字节，TC是按ANSI标准的，它的int是占2个字节的。但是在VC里，一个int是占4个字节的。
浮点数据是指带小数的数字。
生活中有很多信息适合使用浮点型数据来表示，比如：人的体重(单位：公斤)、商品价格、圆周率等等。
因为精度的不同又分为3种(float,double,long double)：

http://pic1.zhimg.com/v2-93f4e6594172bbc0580dce6569530379_r.jpg?source=1940ef5c

注：C语言中不存在字符串变量，字符串只能存在字符数组中,这个后面会讲。
格式化输出语句
格式化输出语句，也可以说是占位输出，是将各种类型的数据按照格式化后的类型及指定的位置从计算机上显示。
其格式为：printf("输出格式符"，输出项);

http://picx.zhimg.com/v2-b00d68abdc9c89f11b459298c34afae5_r.jpg?source=1940ef5c

当输出语句中包含普通字符时，可以采用一下格式：
printf("普通字符输出格式符", 输出项);

http://pica.zhimg.com/50/v2-580aa6963943de86b00bc92d9ef3ea45_720w.jpg?source=1940ef5c

注意：格式符的个数要与变量、常量或者表达式的个数一一对应
不可改变的常量
在程序执行过程中，值不发生改变的量称为常量。
mtianyan: C语言的常量可以分为直接常量和符号常量。

[*]直接常量也称为字面量，是可以直接拿来使用，无需说明的量，比如：

[*]整型常量：13、0、-13；
[*]实型常量：13.33、-24.4；
[*]字符常量：‘a’、‘M’
[*]字符串常量：”I love imooc!”


http://picx.zhimg.com/50/v2-6e8b073777288f40db894e94ab884fa7_720w.jpg?source=1940ef5c

在C语言中，可以用一个标识符来表示一个常量，称之为符号常量。符号常量在使用之前必须先定义，其一般形式为：
#define 标识符 常量值
#include <stdio.h>
#define POCKETMONEY 10    //定义常量及常量值
int main()
{
// POCKETMONEY = 12;//小明私自增加零花钱对吗？
printf("小明今天又得到%d元零花钱\n", POCKETMONEY);
return 0;
}

符号常量不可以被改变。
自动类型转换
数据类型存在自动转换的情况.
自动转换发生在不同数据类型运算时，在编译的时候自动完成。

http://pic1.zhimg.com/50/v2-9fd463a1adc88a01a17814f0a357ff1b_720w.jpg?source=1940ef5c

char类型数据转换为int类型数据遵循ASCII码中的对应值.
注:
字节小的可以向字节大的自动转换，但字节大的不能向字节小的自动转换
char可以转换为int，int可以转换为double，char可以转换为double。但是不可以反向。
强制类型转换
强制类型转换是通过定义类型转换运算来实现的。其一般形式为：
(数据类型) (表达式)
其作用是把表达式的运算结果强制转换成类型说明符所表示的类型
在使用强制转换时应注意以下问题：

[*]数据类型和表达式都必须加括号, 如把(int)(x/2+y)写成(int)x/2+y则成了把x转换成int型之后再除2再与y相加了。
[*]转换后不会改变原数据的类型及变量值，只在本次运算中临时性转换。
[*]强制转换后的运算结果不遵循四舍五入原则。
运算符号
C语言中运算符:
※ 算术运算符 ※ 赋值运算符 ※ 关系运算符 ※ 逻辑运算符 ※ 三目运算符
算术运算符
c语言基本运算符:



http://picx.zhimg.com/v2-da7b8d97b27dbb4c9e8dddfc502e219b_r.jpg?source=1940ef5c

除法运算中注意：
如果相除的两个数都是整数的话，则结果也为整数，小数部分省略，如8/3 = 2;
而两数中有一个为小数，结果则为小数，如：9.0/2 = 4.500000。
mtianyan: 取余运算中注意：
该运算只适合用两个整数进行取余运算，如：10%3 = 1；
mtianyan: notes: 而10.0%3则是错误的；运算后的符号取决于被模数的符号，如(-10)%3 = -1;而10%(-3) = 1;
mtianyan: %%表示这里就是一个%符.
注：C语言中没有乘方这个运算符，也不能用×, ÷等算术符号。
自增与自减运算符

[*]自增运算符为++，其功能是使变量的值自增1
[*]自减运算符为--，其功能是使变量值自减1。
它们经常使用在循环中。自增自减运算符有以下几种形式：



http://picx.zhimg.com/v2-e3afe35b878c70ca611e8de00f457a95_r.jpg?source=1940ef5c

赋值运算符
C语言中赋值运算符分为简单赋值运算符和复合赋值运算符
简单赋值运算符=号了，下面讲一下复合赋值运算符：
复合赋值运算符就是在简单赋值符=之前加上其它运算符构成.
例如+=、-=、*=、/=、%=
分析：定义整型变量a并赋值为3，a += 5;这个算式就等价于a = a+5; 将变量a和5相加之后再赋值给a
注意：复合运算符中运算符和等号之间是不存在空格的。
关系运算符
C语言中的关系运算符:



http://picx.zhimg.com/v2-e9ad66ea0365d806ecb3069d9dcbab12_r.jpg?source=1940ef5c

关系表达式的值是真和假，在C程序用整数1和0表示。
注意：>=, <=, ==, !=这种符号之间不能存在空格。
逻辑运算符
C语言中的逻辑运算符:



http://picx.zhimg.com/50/v2-f2f70345eae4770b98d78bef5b58043c_720w.jpg?source=1940ef5c

逻辑运算的值也是有两种分别为真和假，C语言中用整型的1和0来表示。其求值规则如下：

[*]与运算 &&
参与运算的两个变量都为真时，结果才为真，否则为假。例如：5>=5 && 7>5 ，运算结果为真；

[*]或运算 ||
参与运算的两个变量只要有一个为真，结果就为真。 两个量都为假时，结果为假。例如：5>=5||5>8，运算结果为真；

[*]非运算!
参与运算的变量为真时，结果为假；参与运算量为假时，结果为真。例如：!(5>8)，运算结果为真。
三目运算符
C语言中的三目运算符：?:，其格式为：
表达式1 ? 表达式2 : 表达式3;
执行过程是：
先判断表达式1的值是否为真，如果是真的话执行表达式2；如果是假的话执行表达式3。
#include <stdio.h>
int main()
{
//定义小编兜里的钱
double money =12.0 ;
//定义打车回家的费用
double cost =11.5 ;
printf("小编能不能打车回家呢："); //输出y小编就打车回家了，输出n小编就不能打车回家 printf("%c\n",money>=cost?'y':'n' );
return 0;
}
运算符大比拼之优先级比较
各种运算符号的顺序:



http://picx.zhimg.com/50/v2-4348a0c090b2655ca0a1aaf11ce49050_720w.jpg?source=1940ef5c

优先级别为1的优先级最高，优先级别为10的优先级别最低。
分支结构之简单if语句
C语言中的分支结构语句中的if条件语句。
简单if语句的基本结构如下：
if(表达式) { 执行代码块; }
其语义是：如果表达式的值为真，则执行其后的语句，否则不执行该语句。
注意：if()后面没有分号，直接写{}
分支结构之简单if-else语句
简单的if-else语句的基本结构:



http://picx.zhimg.com/50/v2-d23422baf66b54da0d242714d4a8c48d_720w.jpg?source=1940ef5c

语义是: 如果表达式的值为真，则执行代码块1，否则执行代码块2。
注意：
if()后面没有分号，直接写{},else后面也没有分号，直接写{}
分支结构之多重if-else语句
C语言中多重if-else语句，其结构如下：



http://pic1.zhimg.com/50/v2-21db06788cc0a409a5067b13ac940f9d_720w.jpg?source=1940ef5c

语义是：依次判断表达式的值，当出现某个值为真时，则执行对应代码块，否则执行代码块n。
注意：当某一条件为真的时候，则不会向下执行该分支结构的其他语句。
分支结构之嵌套if-else语句
C语言中嵌套if-else语句。嵌套if-else语句的意思，就是在if-else语句中，再写if-else语句。其一般形式为：



http://picx.zhimg.com/50/v2-595f1a4772c4b521ae964f44eaab4058_720w.jpg?source=1940ef5c

循环结构之while循环
反复不停的执行某个动作就是江湖人称的循环 。
C语言中有三种循环结构,先看一下C语言while循环的结构



http://picx.zhimg.com/50/v2-02b9e422be3be8efab583bc06f8ce94e_720w.jpg?source=1940ef5c

其中表达式表示循环条件，执行代码块为循环体。
while语句的语义是：计算表达式的值，当值为真(非0)时， 执行循环体代码块。

[*]while语句中的表达式一般是关系表达或逻辑表达式，当表达式的值为假时不执行循环体，反之则循环体一直执行。
[*]一定要记着在循环体中改变循环变量的值，否则会出现死循环（无休止的执行）。
[*]循环体如果包括有一个以上的语句，则必须用{}括起来，组成复合语句。
循环结构之do-while循环
C语言中的do-while循环，一般形式如下：



http://pic1.zhimg.com/50/v2-925ed07730b265b17477ceaca49da0b7_720w.jpg?source=1940ef5c

do-while循环语句的语义是:
它先执行循环中的执行代码块，然后再判断while中表达式是否为真，如果为真则继续循环；如果为假，则终止循环。因此，do-while循环至少要执行一次循环语句。
注意：mtianyan: 使用do-while结构语句时，while括号后必须有分号。
循环结构之for循环(一)
c语言中for循环一般形式：



http://pic1.zhimg.com/50/v2-b631430f4495970ed53b702bbc943c6f_720w.jpg?source=1940ef5c

它的执行过程如下：

[*]执行表达式1，对循环变量做初始化；
[*]判断表达式2，若其值为真(非0)，则执行for循环体中执行代码块，然后向下执行；若其值为假(0)，则结束循环;
[*]执行表达式3，(i++)等对于循环变量进行操作的语句;
[*]执行for循环中执行代码块后执行第二步;第一步初始化只会执行一次。
[*]循环结束，程序继续向下执行。
注意：for循环中的两个分号一定要写
循环结构之for循环(二)
在for循环中:

[*]表达式1是一个或多个赋值语句，它用来控制变量的初始值；
[*]表达式2是一个关系表达式，它决定什么时候退出循环；
[*]表达式3是循环变量的步进值，定义控制循环变量每循环一次后按什么方式变化。
[*]这三部分之间用分号 ; 分开。
使用for语句应该注意：

[*]for循环中的“表达式1、2、3”均可不写为空，但两个分号(;;)不能缺省。
[*]省略“表达式1（循环变量赋初值）”，表示不对循环变量赋初始值。
[*]省略“表达式2(循环条件)”，不做其它处理，循环一直执行（死循环）。
[*]省略“表达式3(循环变量增减量)”，不做其他处理，循环一直执行（死循环）。
[*]表达式1可以是设置循环变量的初值的赋值表达式，也可以是其他表达式。
[*]表达式1和表达式3可以是一个简单表达式也可以是多个表达式以逗号分割。

http://picx.zhimg.com/v2-4a5a9293422f42907ac166b933065f11_r.jpg?source=1940ef5c


[*]表达式2一般是关系表达式或逻辑表达式，但也可是数值表达式或字符表达式，只要其值非零，就执行循环体。
[*]各表达式中的变量一定要在for循环之前定义。
怎么获得一个数的百位，十位和个位

[*]百位数：num/100 可以获得，因为 int 是整数型，小数部分会省略。比如 765/100 的结果是7
[*]十位数：num%100/10 。比如765%100先得到65，65/10得到6
[*]个位数：num%10。765%10得到5
循环结构之三种循环比较
while, do-while和for三种循环在具体的使用场合上是有区别的，如下：

[*]在知道循环次数的情况下更适合使用for循环;
[*]在不知道循环次数的情况下适合使用while或者do-while循环:


[*]如果有可能一次都不循环应考虑使用while循环
[*]如果至少循环一次应考虑使用do-while循环。


但是从本质上讲，while,do-while和for循环之间是可以相互转换的。
循环结构之多重循环
多重循环就是在循环结构的循环体中又出现循环结构。
在实际开发中一般最多用到三层重循环。
因为循环层数越多，运行时间越长，程序越复杂，所以一般用2-3层多重循环就可以了。另外不同循环之间也是可以嵌套的。
多重循环在执行的过程中，外层循环为父循环，内层循环为子循环，
父循环一次，子循环需要全部执行完，直到跳出循环。父循环再进入下一次，子循环继续执行...



http://pic1.zhimg.com/v2-72fd7f1d3d109bde4a41b1d2a90feb35_r.jpg?source=1940ef5c

mtianyan: 打印三角形星星堆
#include <stdio.h> int main() { int i, j, k; for(i=1; i<5; i++) { /* 观察每行的空格数量，补全循环条件 */ for(j=i; j<5; j++) { printf(" "); //输出空格 } /* 观察每行*号的数量，补全循环条件 */ for( k=0;k<2*i-1;k++) { printf("*"); //每行输出的*号 } printf("\n"); //每次循环换行 } return 0; }
使用for循环打印9×9乘法表
#include <stdio.h> int main() { // 定义相乘数字i,j以及结果result int i, j, result; for(i=9;i>=1;i--) { for(j=1;j<=i;j++) { printf("%d*%d=%d ",i,j,result=i*j); } printf("\n"); } return 0; }
结束语句之break语句
那么循环5次的时候，需要中断不继续训练。在C语言中，可以使用break语句进行该操作.
使用break语句时注意以下几点：

[*]在没有循环结构的情况下，break不能用在单独的if-else语句中。
[*]在多层循环中，一个break语句只跳出当前循环。
另外，在使用for循环之际，一定要注意时间复杂度，不然很容易影响程序效率，时间复杂度和空间复杂度一定要掌握牢固。
这里面涉及一些算法知识，算法对程序员来说非常重要，这里给题主和大家送一本BAT大佬的算法笔记，这本书是一位阿里P8刷leetcode整理出来的，身边不少朋友通过它加入大厂：
Github 疯传！史上最强悍！阿里大佬「LeetCode刷题手册」开放下载了！
http://picx.zhimg.com/v2-49478778448d6ea7061dadb7ab66b8cf_r.jpg?source=1940ef5c
看看这本书的目录和排版！相当经典！
接下来，我们继续呀～
结束语句之continue语句
那么循环5次的时候，需要中断后继续训练。在C语言中，可以使用continue语句进行该操作
continue语句的作用是结束本次循环开始执行下一次循环。
break语句与continue语句的区别是:
break是跳出当前整个循环，continue是结束本次循环开始下一次循环。
分支结构之switch语句
switch语句结构如下:



http://picx.zhimg.com/50/v2-714e3591aa3b7e39bf65e00fe7381e28_720w.jpg?source=1940ef5c

mtianyan: switch语句时还应注意以下几点：

[*]在case后的各常量表达式的值不能相同，否则会出现错误。
[*]在case子句后如果没有break;会一直往后执行一直到遇到break;才会跳出switch语句。
[*]switch后面的表达式语句只能是整型或者字符类型。
[*]在case后，允许有多个语句，可以不用{}括起来。
[*]各case和default子句的先后顺序可以变动，而不会影响程序执行结果。
[*]default子句可以省略不用。
mtianyan: switch与if语句的应用(计算是该年的第几天)

#include <stdio.h>

int main()

{

/* 定义需要计算的日期 */

    int date = 0;

    int year = 2008;

    int month = 8;

    int day = 8;

    switch(month)

    {

      case 12:date+=30;

      case 11:date+=31;

      case 10:date+=30;

      case 9:date+=31;

      case 8:date+=31;

      case 7:date+=30;

      case 6:date+=31;

      case 5:date+=30;

      case 4:date+=31;

      case 3:

      if((year%4==0&&year%100!=0)||year%400==0)

      {

            date+=29;

      }

      else

      {

            date+=28;

      }
      case 2:

      date+=31;

      case 1:

      date+=day;

      printf("%d年%d月%d日是该年的第%d天",year,month,day,date);

      break;

      default:

      printf("error");

      break;

    }

    return 0;

}

正确: continue只能用在循环体内
臭名远扬之goto语句

C语言中也有这样的语句，就是goto语句，goto语句是一种无条件分支语句.
goto 语句的使用格式为：
goto 语句标号;



http://pica.zhimg.com/50/v2-4e51efdaed2d152ebed6e3071f23681e_720w.jpg?source=1940ef5c

自创函数
C语言提供了大量的库函数: 比如stdio.h提供输出函数
自定义函数的一般形式：



http://pica.zhimg.com/50/v2-ea3e290b66328c4da7eb458d4e7c51fb_720w.jpg?source=1940ef5c

注意：

[*][] 包含的内容可以省略，数据类型说明省略，默认是 int 类型函数; 参数省略表示该函数是无参函数，参数不省略表示该函数是有参函数;
[*]函数名称遵循标识符命名规范；
[*]mtianyan: 自定义函数尽量放在 main 函数之前，如果要放在main函数后面的话, 需要在main函数之前先声明自定义函数，声明格式为：
[数据类型说明] 函数名称（[参数]）;
函数调用
我们需要用到自定义的函数的时候，就得调用它，那么在调用的时候就称之为函数调用。
在C语言中，函数调用的一般形式为：
函数名（[参数]）;
注意：

[*]对无参函数调用的时候可以将[]包含的省略。
[*][]中可以是常数，变量或其它构造类型数据及表达式,多个参数之间用逗号分隔。

有参与无参
在函数中不需要函数参数的称之为无参函数，在函数中需要函数参数的称之为有参函数。
有参和无参函数的一般形式如下：



http://pic1.zhimg.com/v2-ea1352ef590b4ee72c25c8dac1d18971_r.jpg?source=1940ef5c

有参函数和无参函数的唯一区别在于：函数 () 中多了一个参数列表。

[*]有参函数更为灵活，输出的内容可以随着n的改变而随意变动，只要在main函数中传递一个参数就可以了
[*]而在无参函数中输出的相对就比较固定，当需要改动的时候还需要到自定义的方法内改变循环变量的值。
mtianyan: 形参与实参
函数的参数分为形参和实参两种。

[*]形参是在定义函数名和函数体的时候使用的参数,目的是用来接收调用该函数时传入的参数。
就类似小明，说了的话而不实际行动；

[*]实参是在调用时传递该函数的参数。
就如小刚能实际行动起来。
函数的形参和实参具有以下特点：

[*]形参只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只有在函数内部有效。
函数调用结束返回主调函数后则不能再使用该形参变量。

[*]实参可以是常量、变量、表达式、函数等。
无论实参是何种类型的量，在进行函数调用时，它们都必须具有确定的值，以便把这些值传送给形参。因此应预先用赋值等办法使实参获得确定值。

[*]在参数传递时，实参和形参在数量上，类型上，顺序上应严格一致，否则会发生类型不匹配的错误。


http://pic1.zhimg.com/50/v2-fc8775b688fec240e2290ddf3826d2f4_720w.jpg?source=1940ef5c

函数的返回值
函数的返回值是指函数被调用之后，执行函数体中的程序段所取得的并返回给主调函数的值。
函数的返回值要注意以下几点：

[*]函数的值只能通过return语句返回主调函数。
return语句的一般形式为:
return 表达式   或者为：return (表达式);

[*]函数值的类型和函数定义中函数的类型应保持一致。
notes: 如果两者不一致，则以函数返回类型为准，自动进行类型转换。

[*]没有返回值的函数，返回类型为 void。
注意：
void 函数中可以有执行代码块，但是不能有返回值.
mtianyan: void函数中如果有return语句，该语句只能起到结束函数运行的功能。其格式为: return;
递归函数（一）
递归就是一个函数在它的函数体内调用它自身。
执行递归函数将反复调用其自身，每调用一次就进入新的一层。
注意递归函数必须有结束条件
递归函数（二）
5的阶乘这个例子进行一下剖析，看一看他的运算过程：



http://picx.zhimg.com/v2-14ee2dca05b8789cde6dc66d83353778_r.jpg?source=1940ef5c

程序在计算5的阶乘的时候，先执行递推，当n=1或者n=0的时候返回1，再回推将计算并返回。由此可以看出递归函数必须有结束条件。
递归函数特点：

[*]每一级函数调用时都有自己的变量，但是函数代码并不会得到复制，如计算5的阶乘时每递推一次变量都不同；
[*]每次调用都会有一次返回，如计算5的阶乘时每递推一次都返回进行下一次；
[*]递归函数中，位于递归调用前的语句和各级被调用函数具有相同的执行顺序；
[*]递归函数中，位于递归调用后的语句的执行顺序和各个被调用函数的顺序相反；
[*]递归函数中必须有终止语句。
一句话总结递归：自我调用且有完成状态
任务：猴子第一天摘下N个桃子，当时就吃了一半，还不过瘾，就又多吃了一个。第二天又将剩下的桃子吃掉一半，又多吃了一个。以后每天都吃前一天剩下的一半零一个。到第10天在想吃的时候就剩一个桃子了,问第一天共摘下来多少个桃子？并反向打印每天所剩桃子数。#include <stdio.h>
int getPeachNumber(int n)
{
    int num;   
    if(n==10)
    {
       return 1;      
    }
    else
    {
      num = (getPeachNumber(n+1)+1)*2;
      printf("第%d天所剩桃子%d个\n", n, num);
    }
    return num;
}
int main()
{
    int num = getPeachNumber(1);
    printf("猴子第一天摘了:%d个桃子。\n", num);
    return 0;
}
递归demo。

有5个人坐在一起，问第5个人多少岁？他说比第4个人大2岁。问第4个人岁数，他说比第3个人大2岁。问第3个人，又说比第2人大两岁。问第2个人，说比第1个人大两岁。最后 问第1个人，他说是10岁。请问第5个人多大？
程序分析：
利用递归的方法，递归分为回推和递推两个阶段。要想知道第5个人岁数，需知道第4人的岁数，依次类推，推到第1人（10岁），再往回推。
#include <stdio.h>
int dfs(int n) {
    return n == 1 ? 10 : dfs(n - 1) + 2;
}
int main()
{

    printf("第5个人的年龄是%d岁", dfs(5));
    return 0;
}

局部与全局

C语言中的变量，按作用域范围可分为两种，即局部变量和全局变量。

[*]局部变量也称为内部变量。局部变量是在函数内作定义说明的。其作用域仅限于函数内， 离开该函数后再使用这种变量是非法的。在复合语句中也可定义变量，其作用域只在复合语句范围内。
[*]全局变量也称为外部变量，它是在函数外部定义的变量。它不属于哪一个函数，它属于一个源程序文件。其作用域是整个源程序。
变量存储类别
mtianyan: C语言根据变量的生存周期来划分，可以分为静态存储方式和动态存储方式。

[*]静态存储方式：是指在程序运行期间分配固定的存储空间的方式。静态存储区中存放了在整个程序执行过程中都存在的变量，如全局变量。
[*]动态存储方式：是指在程序运行期间根据需要进行动态的分配存储空间的方式。动态存储区中存放的变量是根据程序运行的需要而建立和释放的，通常包括：函数形式参数；自动变量；函数调用时的现场保护和返回地址等。
C语言中存储类别又分为四类：

[*]自动（auto）、
[*]静态（static）、
[*]寄存器的（register）
[*]外部的（extern）。
1、用关键字auto定义的变量为自动变量，auto可以省略，auto不写则隐含定为“自动存储类别”，属于动态存储方式。如：



http://pic1.zhimg.com/50/v2-e18294f1726d62fbbb690db052bc8b21_720w.jpg?source=1940ef5c

2、用static修饰的为静态变量，如果定义在函数内部的，称之为静态局部变量；如果定义在函数外部，称之为静态外部变量。如下为静态局部变量：



http://picx.zhimg.com/50/v2-2381fdc973fce8c290ec149c0efbca87_720w.jpg?source=1940ef5c

注意：静态局部变量属于静态存储类别，在静态存储区内分配存储单元，在程序整个运行期间都不释放；静态局部变量在编译时赋初值，即只赋初值一次；如果在定义局部变量时不赋初值的话，则对静态局部变量来说，编译时自动赋初值0（对数值型变量）或空字符（对字符变量）。
3、为了提高效率，C语言允许将局部变量得值放在CPU中的寄存器中，这种变量叫“寄存器变量”，用关键字register作声明。例如：



http://pica.zhimg.com/50/v2-683e6f4ae9f7778a62dca3829c495d3e_720w.jpg?source=1940ef5c

mtianyan: 注意：只有局部自动变量和形式参数可以作为寄存器变量；一个计算机系统中的寄存器数目有限，不能定义任意多个寄存器变量；局部静态变量不能定义为寄存器变量。
4、用extern声明的的变量是外部变量，外部变量的意义是某函数可以调用在该函数之后定义的变量。如：



http://pica.zhimg.com/v2-f8facc5dda1e65a8a6192fd1f1afeca7_r.jpg?source=1940ef5c

内部函数与外部函数

[*]在C语言中不能被其他源文件调用的函数称谓内部函数 ，内部函数由static关键字来定义，因此又被称谓静态函数，形式为：
static [数据类型] 函数名（[参数]）
[*]这里的static是对函数的作用范围的一个限定，限定该函数只能在其所处的源文件中使用，因此在不同文件中出现相同的函数名称的内部函数是没有问题的。
[*]在C语言中能被其他源文件调用的函数称谓外部函数 ，外部函数由extern关键字来定义，形式为：
extern [数据类型] 函数名([参数])
[*]C语言规定，在没有指定函数的作用范围时，系统会默认认为是外部函数，因此当需要定义外部函数时extern也可以省略。
静态变量只赋值一次
外部函数练习

hello.c
#include <stdio.h>
#include "test.c"   //引用test.c文件
extern void printLine()   //这里定义的方法对吗？
{
   printf("**************\n");   
}
int main()
{
    say();
    return 0;
}
test.c
#include <stdio.h>
void printLine();
static void say(){
printLine();
printf("I love imooc\n");
printf("good good study!\n");
printf("day day up!\n");
printLine();
}
对于hello.c来说，直接引入了test.c文件。那么就可以调用testc中的static方法say()
而对于test.c并没有引入，可以通过声明来调用另一个源文件中暴露出来的方法。
综合练习

北京市出租车打车计费规则如下：
1. 每公里单价计费2.3元
2. 起步价13元(包含3公里)
3. 晚上23点(含)至次日凌晨5点(不含)打车，每公里单价计费加收20%。
4. 每次乘车加收1元钱的燃油附加税。
小明每天上下班都要打车，公司和家的距离为12公里，上午上班时间为9点，下午下班时间为6点。
请编写一个小程序计算小明每天打车的总费用。
#include <stdio.h>

float taxifee(int clock,int miles)
{
    float money;
    if(miles<=3)
    {
      money=14;
      printf("费用为14\n");
    }
    else
    {
      if(clock>=23 || clock<5)
      {
            money=13+1+2.3*(miles-3)*1.2;
            printf("夜间车费为：%f\n",money);
      }
      else
      {
            money=13+1+2.3*(miles-3);
            printf("日间车费为：%f\n",money);
      }
    }

    return money;   
}
int main()
{
    printf("打的总费用：%.1f\n",taxifee(9,12)+taxifee(18,12));
    return 0;
}

数组初体验
程序中也需要容器，只不过该容器有点特殊，它在程序中是一块连续的，大小固定并且里面的数据类型一致的内存空间，它还有个好听的名字叫数组。可以将数组理解为大小固定，所放物品为同类的一个购物袋，在该购物袋中的物品是按一定顺序放置的。
我们来看一下如何声明一个数组：
数据类型 数组名称[长度];
数组只声明也不行啊，看一下数组是如何初始化的。说到初始化，C语言中的数组初始化是有三种形式的，分别是：

[*]数据类型 数组名称[长度n] = {元素1,元素2…元素n};
[*]数据类型 数组名称[] = {元素1,元素2…元素n};
[*]数据类型 数组名称[长度n]; 数组名称 = 元素1; 数组名称 = 元素2; 数组名称 = 元素n;
我们将数据放到数组中之后又如何获取数组中的元素呢？
获取数组元素时： 数组名称[元素所对应下标];
如：初始化一个数组 int arr = {1,2,3}; 那么arr就是元素1。
注意：

[*]数组的下标均以0开始；
[*]数组在初始化的时候，数组内元素的个数不能大于声明的数组长度；
[*]mtianyan: 如果采用第一种初始化方式，元素个数小于数组的长度时，多余的数组元素初始化为0；
[*]在声明数组后没有进行初始化的时候，静态（static）和外部（extern）类型的数组元素初始化元素为0，自动（auto）类型的数组的元素初始化值不确定。
数组的遍历
数组就可以采用循环的方式将每个元素遍历出来，而不用人为的每次获取指定某个位置上的元素，例如我们用for循环遍历一个数组：



http://picx.zhimg.com/50/v2-189a04ba5a7bb3a554b0f713822d8cbb_720w.jpg?source=1940ef5c

注意以下几点：

[*]最好避免出现数组越界访问，循环变量最好不要超出数组的长度.
[*]C语言的数组长度一经声明，长度就是固定，无法改变，并且C语言并不提供计算数组长度的方法。
由于C语言是没有检查数组长度改变或者数组越界的这个机制，可能会在编辑器中编译并通过，但是结果就不能肯定了，因此还是不要越界或者改变数组的长度
c语言获取数组长度
int length = sizeof(arr)/sizeof(arr);
数组作为函数参数
数组可以由整个数组当作函数的参数，也可以由数组中的某个元素当作函数的参数：

[*]整个数组当作函数参数，即把数组名称传入函数中，例如：


http://picx.zhimg.com/50/v2-ba5791218153611ff2b3ad0015f24373_720w.jpg?source=1940ef5c


[*]数组中的元素当作函数参数，即把数组中的参数传入函数中，例如：


http://picx.zhimg.com/50/v2-408e32d5a3269051283284066de094ba_720w.jpg?source=1940ef5c

数组作为函数参数时注意以下事项：

[*]数组名作为函数实参传递时，函数定义处作为接收参数的数组类型形参既可以指定长度也可以不指定长度。
[*]数组元素作为函数实参传递时，数组元素类型必须与形参数据类型一致。
mtianyan: 数组的应用（一）[冒泡排序]

以升序排序为例冒泡排序的思想：相邻元素两两比较，将较大的数字放在后面，直到将所有数字全部排序。就像小学排队时按大小个排一样，将一个同学拉出来和后面的比比，如果高就放后面，一直把队伍排好。
#include <stdio.h>
int main()
{
    double arr[]={1.78, 1.77, 1.82, 1.79, 1.85, 1.75, 1.86, 1.77, 1.81, 1.80};
    int i,j;
    printf("\n************排队前*************\n");
    for(i=0;i<10;i++)
    {
      if(i != 9)   
            printf("%1.2f, ", arr);//%1.2f表示小数点前一位，小数点后精确到两位
      else
            printf("%1.2f", arr);    //%1.2f表示小数点前一位，小数点后精确到两位
    }
    for(i=8; i>=0; i--)
    {
      for(j=0;j<=i;j++)
      {
            if( arr>arr)      //当前面的数比后面的数大时
            {
                double temp;    //定义临时变量temp
                temp=arr;//将前面的数赋值给temp
                arr=arr;             //前后之数颠倒位置
                arr=temp;//将较大的数放在后面   
            }               
      }               
    }
    printf("\n************排队后*************\n");
    for(i=0;i<10;i++)
    {
      if(i != 9)   
            printf("%1.2f, ", arr);//%1.2f表示小数点前一位，小数点后精确到两位   
      else
            printf("%1.2f", arr);    //%1.2f表示小数点前一位，小数点后精确到两位
    }
    return 0;   
}
数组的应用（二）[数组查找功能]

当我们购物之后，拎着购物袋回到家，会一一检查购物袋中的物品看是否缺少或者都是想购之物。
那么应用到程序中，可以使用数组查找功能，看看是否存在该数据，如果存在并返回该元素的下标。
#include <stdio.h>
int getIndex(int arr,int value)
{
    int i;
    int index;
    for(i=0;i<5;i++)
    {
/* 请完善数组查询功能 */
       if(arr==value)
      {
            index=i;
            break;
      }
       index=-1;
    }
    return index;
}

int main()
{
    int arr={3,12,9,8,6};
    int value = 8;
    int index = getIndex(arr,value);      //这里应该传什么参数呢？
    if(index!=-1)
    {
      printf("%d在数组中存在，下标为：%d\n",value,index);            
    }
    else
    {
      printf("%d在数组中不存在。\n",value);   
    }
    return 0;   
}

字符串与数组
C语言中，是没有办法直接定义字符串数据类型的，但是我们可以使用数组来定义我们所要的字符串。一般有以下两种格式：

[*]char 字符串名称[长度] = "字符串值";
[*]char 字符串名称[长度] = {'字符1','字符2',...,'字符n','\0'};
注意：

[*][]中的长度是可以省略不写的；
[*]采用第2种方式的时候最后一个元素必须是'\0'，'\0'表示字符串的结束标志；
[*]采用第2种方式的时候在数组中不能写中文。
在输出字符串的时候要使用：printf(“%s”,字符数组名字);或者puts(字符数组名字);。
mtianyan:字符串函数
常用的字符串函数如下(strlen,strcmp,strcpy,strcat,atoi):



http://picx.zhimg.com/v2-79359b2da8f06f892913ce76c87c0291_r.jpg?source=1940ef5c

使用字符串函数注意以下事项：

[*]strlen()获取字符串的长度，在字符串长度中是不包括‘\0’而且汉字和字母的长度是不一样的。比如：


http://picx.zhimg.com/v2-da1d44e654e955df81cdac6a8dbee3ea_r.jpg?source=1940ef5c


[*]strcmp()在比较的时候会把字符串先转换成ASCII码再进行比较,返回的结果为0表示s1和s2的ASCII码相等,返回结果为1表示s1比s2的ASCII码大,返回结果为-1表示s1比s2的ASCII码小，例如：


http://pic1.zhimg.com/v2-6a808f9961e4ef7b9ef0d08e055eca2d_r.jpg?source=1940ef5c


[*]strcpy()拷贝之后会覆盖原来字符串且不能对字符串常量进行拷贝，比如：


http://pic1.zhimg.com/v2-69b4e0ab6f3de86cb0c82ad83029ad03_r.jpg?source=1940ef5c


[*]strcat在使用时s1与s2指的内存空间不能重叠，且s1要有足够的空间来容纳要复制的字符串，如：


http://picx.zhimg.com/50/v2-8897f50e190fc5e4575b8240879f74f3_720w.jpg?source=1940ef5c

多维数组
多维数组的定义格式是：
数据类型 数组名称[常量表达式1][常量表达式2]...[常量表达式n];



http://picx.zhimg.com/50/v2-9ea11aa17145e94c0de16d826fb4cfb4_720w.jpg?source=1940ef5c

定义了一个名称为num，数据类型为int的二维数组。其中第一个表示第一维下标的长度，就像购物时分类存放的购物；第二个表示第二维下标的长度，就像每个购物袋中的元素。



http://pic1.zhimg.com/50/v2-9c8f8c8019920aaf210213344f8ecf84_720w.jpg?source=1940ef5c

多维数组的初始化与一维数组的初始化类似也是分两种：

[*]数据类型 数组名称[常量表达式1][常量表达式2]...[常量表达式n] = {{值1,..,值n},{值1,..,值n},...,{值1,..,值n}};
[*]数据类型 数组名称[常量表达式1][常量表达式2]...[常量表达式n]; 数组名称[下标1][下标2]...[下标n] = 值;
多维数组初始化要注意以下事项：

[*]采用第一种始化时数组声明必须指定列的维数。mtianyan: 因为系统会根据数组中元素的总个数来分配空间，当知道元素总个数以及列的维数后，会直接计算出行的维数；
[*]采用第二种初始化时数组声明必须同时指定行和列的维数。
二维数组定义的时候，可以不指定行的数量，但是必须指定列的数量
二维数组定义的时候，可以不指定行的数量，但是必须指定列的数量。
多维数组的遍历
多维数组也是存在遍历的，和一维数组遍历一样，也是需要用到循环。不一样的就是多维数组需要采用嵌套循环
注意：多维数组的每一维下标均不能越界
综合练习：
#include <stdio.h>
#define N 10
//打印分数
void printScore(int score[])
{
    int i;
    printf("\n");
    for(i=0;i<N;i++)
    {
      printf("%d ",score);               
    }
    printf("\n");   
}
//计算考试总分
int getTotalScore(int score[])
{
    int sum = 0;
    int i;
    for(i=0;i<N;i++)
    {
      sum+=score;               
    }
    return sum;
}
//计算平均分
int getAvgScore(int score[])
{
    return getTotalScore(score)/N;   
}
//计算最高分
int getMax(int score[])
{
    int max = -1;
    int i;
    for(i=0;i<N;i++)
    {
      if(score>max)
      {
            max = score;            
      }               
    }
    return max;
}
//计算最低分
int getMin(int score[])
{
    int min =100;
    int i;
    for(i=0;i<N;i++)
    {
      if(score< min)
      {
            min = score;            
      }               
    }
    return min;
}
//分数降序排序
void sort(int score[])
{
    int i,j;
    for(i=N-2;i>=0;i--)
    {
      for(j=0;j<=i;j++)
      {
            if(score<score)
            {
                int temp;
                temp = score;
                score = score;
                score=temp;                  
            }               
      }                  
    }
    printScore(score);   
}

int main()
{
    int score={67,98,75,63,82,79,81,91,66,84};
    int sum,avg,max,min;
    sum = getTotalScore(score);
    avg = getAvgScore(score);
    max = getMax(score);
    min = getMin(score);
    printf("总分是：%d\n",sum);
    printf("平均分是：%d\n",avg);
    printf("最高分是：%d\n",max);
    printf("最低分是：%d\n",min);
    printf("----------成绩排名---------\n");
    sort(score);
    return 0;   
}

ymabianzi 发表于 2023-10-3 19:52:01

推荐一个可能是最好的计算机面试求职网站

前段时间我发现了一个很好的面试求职网站，能够根据指定行业、公司、面试岗位、科目以及考察时间等进行定向筛选面试真题，还附带了最近考察时间和累计考察次数。
这简直是一大神器！！！
比如我想查一下行业为互联网，公司为字节跳动，考察岗位为后端，科目不限，而考察时间为最近一年之类的面试题有哪些？

http://picx.zhimg.com/v2-4778160611b3991161a71a030375f456_r.jpg?source=1940ef5c
行业除了互联网还有国企、银行、外企等行业，截止我发现的时候是这样的，好像该网站后期又在逐步添加新的数据了。

http://picx.zhimg.com/v2-b9c6e3d3a678f6d23fcd44932f723daf_r.jpg?source=1940ef5c
就拿互联网来说，国内外主流一二线大厂全都覆盖了，比如字节跳动、阿里、腾讯、百度、美团等。

http://picx.zhimg.com/v2-9e7d9c5aa76ef35178346d2049f931dd_r.jpg?source=1940ef5c
这里分享一下该网站，这么好的东西不能藏私，如果对你有帮助的话，帮忙点个赞就是最大的支持了！！感谢感谢！
网站链接：https://top.interviewguide.cn/
<hr/>首先给大家推荐一个C语言/C++学习平台，这可能是你见过的最好的C/C++学习仓库！
C语言/C入门、学习路线、电子书籍推荐与下载、视频推荐、小项目、干货文章、笔试面试、C语言/C++ 规范、开源项目秉着好东西不藏私的原则分享出来，如果对你有用可以点赞支持一下我！
10套程序员最适合的简历模板！Word格式，白嫖可用~对了，简单介绍一下自己，我是飞宇，本硕均于某中流985 CS就读，以前是在百度搜索部门做后端研发实习生，后来又去了字节某电商部门担任后端研发工程师。
虽然是所谓的科班出生，但学校教育质量就不提了。。。懂得都懂，所以我学习计算机基本全靠自学，B站、github、网易云课堂、YouTube等就是我的学习课堂
欢迎关注我 @韩飞宇 ! 我会继续分享一些计算机学习经验、一些不错的编程资源以及自己在互联网一二线公司工作的工作体验和日常生活等。
谷歌高级研发工程师出品！支持Java、C++、Go三种语言的Leetcode刷题笔记~这是一份涵盖大部分 C++ 程序员所需要掌握的知识。入门、进阶、深入、校招、社招，准备 C++学习 & 面试，首选CppGuide！

http://pic1.zhimg.com/v2-4b54518bbd4e99e74a6f5a39a06255a2_r.jpg?source=1940ef5c

可能是你见过的最好的C/C++学习仓库

目前已经开源在了github上，如果你因为网络等原因无法访问github，我在国内的码云也放了一份，同样可以供你学习C/C++！
github开源地址：https://github.com/GrindGold/CppGuide
码云开源地址：https://gitee.com/grindgold/CppGuide
快来白嫖！腾讯字节阿里美团等一二线互联网大厂真实面经！1.入门程序
#include <stdio.h>
int main()
{
        printf("Hello World!");
        return 0;
}计算机专业必读书籍汇总！(含下载)秉着好东西不藏私的原则分享出来！我把自己学习计算机八九年以来的书籍分享出来了，最后汇总开源成为一个计算机经典编程书籍仓库了。

http://pic1.zhimg.com/v2-be09a09a54cd177a06fd3261ad3d25fb_r.jpg?source=1940ef5c

我学习计算机以来自己收藏的计算机电子书

如果对你有用可以点赞支持一下我！后续会继续分享一些计算机学习的编程资源！

http://pica.zhimg.com/v2-0d3b211da2c1d0056b6848d64ce42840_r.jpg?source=1940ef5c
其中包括经典大黑书、编程电子书、电子书、编程书籍，包括计算机基础、C/C++、Java、Python、面试题、架构设计、算法系列等经典电子书。
目前已经开源在了github上，如果你因为网络等原因无法访问github，我在码云也放了一份，同样可以供你学习编程！
github开源地址：https://github.com/GrindGold/pdf
码云开源地址：https://gitee.com/grindgold/pdf
开发必备！C++离线版参考手册！免费分享！2.数据类型

数据类型:
1.基本数据类型：
1.1. 整型:int 4个字节
1.2. 字符型:char 1个字节
1.3. 实型(浮点型)

[*]1.3.1.单精度型:float 4个字节
[*]1.3.2.双精度型:double 8个字节
2.构造类型：
2.1.枚举类型
2.2.数组类型
2.3.结构体类型
2.4.共用体类型
3.指针类型：
4.空类型：
3.格式化输出语句


[*]%d:十进制整数;
[*]%c:单个字符;
[*]%s:字符串;
[*]%f:6位小数;
#include <stdio.h>
int main()
{
        int age = 18;
        float height = 1.85;
        char unit = 'm';
        printf("小明今年%d岁\n", age);
        printf("小明身高%f%c\n", height, unit);
        printf("小明现在在慕课网上学习IT技术\n");
        return 0;
}4.常量

值不发生改变的量成为常量;
定义字符常量(注意后面没有;)
#include <stdio.h>
#define POCKETMONEY 10 //定义常量及常量值
int main()
{
        printf("小明今天又得到%d元零花钱\n", POCKETMONEY);
        return 0;
}5.运算符

5.1.算数运算符:+,-,*,/,%,++,--;前++/--,先运算,再取值.后++/--,先取值,再运算;
5.2.赋值运算符:
5.3.关系运算符;
5.4.逻辑运算符;
5.5.三目运算符:

[*]表达式1 ? 表达式2 : 表达式3;
6.水仙花数计算

输出所有三位数的水仙花数字
所谓“水仙花数”是指一个三位数，其各位数字立方和等于该数，如：153就是一个水仙花数，153=111+555+333。
#include <stdio.h>

int main()
{
        //定义三位数num,个位数sd,十位数td,百位数hd
        int num, sd, td, hd;
        //循环所有三位数
        for( num=100 ; num<1000 ; num++ )
        {
                //获取三位数字num百位上的数字
                hd = num/100 ;
                //获取三位数字num十位上的数字
                td = num/10%10 ;
                //获取三位数字num个位上的数字
                sd = num%10 ;
                //水仙花数的条件是什么？
                if(num ==hd*hd*hd+td*td*td+sd*sd*sd )
                {
                        printf("水仙花数字：%d\n", num);
                }
        }
        return 0;
}7.打印正三角形的*

#include <stdio.h>
int main()
{
        int i, j, k;
        for(i=1; i<5; i++)
        {
                /* 观察每行的空格数量，补全循环条件 */
                for( j=i ; j<5 ; j++ )
                {
                        printf(" "); //输出空格
                }
                /* 观察每行*号的数量，补全循环条件 */
                for( k=0 ; k<2*i-1 ; k++ )
                {
                        printf("*"); //每行输出的*号
                }
                printf("\n"); //每次循环换行
        }
        return 0;
}8.臭名远扬的goto语句

很少使用
#include <stdio.h>
int main()
{
        int sum = 0;
        int i;
        for(i=1; i<=10; i++)
        {
                printf("%d\n", i);
                if(i==3){
                        goto LOOP;//满足条件就执行goto语句
                }
        }
        //执行goto
LOOP:printf("结束for循环了...."); //请选择合适位置添加标识符
        return 0;
}9.形参与实参

形参:形参是在定义函数名和函数体的时候使用的参数,目的是用来接收调用该函数时传入的参数;
实参:实参是在调用时传递该函数的参数。
函数的形参和实参具有以下特点：

[*]形参只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只有在函数内部有效。函数调用结束返回主调函数后则不能再使用该形参变量。
[*]实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须具有确定的值，以便把这些值传送给形参。因此应预先用赋值等办法使实参获得确定值。
[*]在参数传递时，实参和形参在数量上，类型上，顺序上应严格一致，否则会发生类型不匹配”的错误。
10.函数返回值注意

注意：void函数中可以有执行代码块，但是不能有返回值，另void函数中如果有return语句，该语句只能起到结束函数运行的功能。其格式为：return;
11.递归

#include <stdio.h>

int getPeachNumber(int n) //这里要定义n，要不编译器会报错！
{
        int num;
        if(n==10)
        {
                return 1;
        }
        else
        {
                num = (getPeachNumber(n+1)+1)*2;
                printf("第%d天所剩桃子%d个\n", n, num);
        }
        return num;
}
int main()
{
        int num = getPeachNumber(1);
        printf("猴子第一天摘了:%d个桃子。\n", num);
        return 0;
}12.变量存储类别 !

12.1.生存周期划分存储方式
C语言根据变量的生存周期来划分，可以分为静态存储方式和动态存储方式。
静态存储方式：是指在程序运行期间分配固定的存储空间的方式。静态存储区中存放了在整个程序执行过程中都存在的变量，如全局变量。
动态存储方式：是指在程序运行期间根据需要进行动态的分配存储空间的方式。动态存储区中存放的变量是根据程序运行的需要而建立和释放的，通常包括：函数形式参数；自动变量；函数调用时的现场保护和返回地址等。
12.2.存储类型划分
C语言中存储类别又分为四类：自动（auto）、静态（static）、寄存器的（register）和外部的（extern） ;

[*]用关键字auto定义的变量为自动变量，auto可以省略，auto不写则隐含定为“自动存储类别”，属于动态存储方式。
[*]用static修饰的为静态变量，如果定义在函数内部的，称之为静态局部变量；如果定义在函数外部，称之为静态外部变量。
注意：静态局部变量属于静态存储类别，在静态存储区内分配存储单元，在程序整个运行期间都不释放；静态局部变量在编译时赋初值，即只赋初值一次；如果在定义局部变量时不赋初值的话，则对静态局部变量来说，编译时自动赋初值0（对数值型变量）或空字符（对字符变量）

[*]为了提高效率，C语言允许将局部变量的值放在CPU中的寄存器中，这种变量叫“寄存器变量”，用关键字register作声明。
注意：只有局部自动变量和形式参数可以作为寄存器变量；一个计算机系统中的寄存器数目有限，不能定义任意多个寄存器变量；局部静态变量不能定义为寄存器变量。

[*]用extern声明的的变量是外部变量，外部变量的意义是某函数可以调用在该函数之后定义的变量。
#includ <stdio.h>
//来源公众号：C语言与CPP编程
int main()
{
        //定义外部局部变量
        extern int x;
        return 0;
}
int x=100;13.内部函数外部函数 !

在C语言中不能被其他源文件调用的函数称为内部函数 ，内部函数由static关键字来定义，因此又被称为静态函数，形式为：
static [数据类型] 函数名（[参数]）
这里的static是对函数的作用范围的一个限定，限定该函数只能在其所处的源文件中使用，因此在不同文件中出现相同的函数名称的内部函数是没有问题的。
在C语言中能被其他源文件调用的函数称为外部函数 ，外部函数由extern关键字来定义，形式为：
extern [数据类型] 函数名([参数])
C语言规定，在没有指定函数的作用范围时，系统会默认认为是外部函数，因此当需要定义外部函数时extern也可以省略。 extern可以省略; 14.数组 数组:一块连续的，大小固定并且里面的数据类型一致的内存空间， 数组的声明:数据类型 数组名称[长度n]

[*]数据类型 数组名称[长度n] = {元素1,元素2,元素3,......};
[*]数据类型 数组名称[] = {元素1,元素2,元素3,......};
[*]数类类型 数组名称[长度n]; 数组名称 = 元素1;数组名称 = 元素2;...... 注意： 1、数组的下标均以0开始； 2、数组在初始化的时候，数组内元素的个数不能大于声明的数组长度； 3、如果采用第一种初始化方式，元素个数小于数组的长度时，多余的数组元素初始化为0； 4、在声明数组后没有进行初始化的时候，静态（static）和外部（extern）类型的数组元素初始化元素为0，自动（auto）类型的数组的元素初始化值不确定。
15.数组遍历

#include <stdio.h>

int main()
{
        int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
        int i;
        for(i=0;i<10;i++)
        {
                printf("%d\n",arr);
        }
        return 0;
}
[*]数组的冒泡排序
冒泡排序的思想：相邻元素两两比较，将较大的数字放在后面，直到将所有数字全部排序。

[*]字符串与数组
在C语言中,是没有办法直接定义子字符串数据类型的,需使用数组来定义所要的字符串,形式如下:

[*]char 字符串名称[长度] = "字符串内容";
[*]char 字符串名称[长度] = {'字符串1','字符串2',....,'字符串n','\0'};
注:

[*][]中的长度可以省略不写;
[*]采用第二种方式最后一个元素必须是'\0',表示结束;
[*]第二种方式不能写中文!; 输出字符串时,要使用:printf("%s",字符数组名);或puts(字符数组名);
16.字符串函数


[*]strlen(s):获取字符串s的长度;
[*]strcmp(s1,s2):比较字符串;比较的时候会把字符串转换成ASCII码再进行比较,返回结果为0表示s1和s2的ASCII码值相等,返回结果为1表示s1比s2的ASCII码大,返回结果为-1表示s1比s2的ACSII码小;
[*]strcpy(s1,s2):字符串拷贝;s2会取代s1中的内容;
[*]strcat(s1,s2)将s2拼接到s1后面;注意:s1的length要足够才可以!
[*]atoi(s1)将字符串转为整数!
17.多维数组

数据类型 数组名称[常量表达式1]...[常量表达式n];
多维数组的初始化与一维数组的初始化类似也是分两种：

[*]数据类型 数组名称[常量表达式1][常量表达式2]...[常量表达式n] = {{值1,..,值n},{值1,..,值n},...,{值1,..,值n}};
[*]数据类型 数组名称[常量表达式1][常量表达式2]...[常量表达式n]; 数组名称[下标1][下标2]...[下标n] = 值;
多维数组初始化要注意以下事项：

[*]采用第一种始化时数组声明必须指定列的维数。因为系统会根据数组中元素的总个数来分配空间，当知道元素总个数以及列的维数后，会直接计算出行的维数；
[*]采用第二种初始化时数组声明必须同时指定行和列的维数。
18.多维度数组的遍历

使用嵌套循环
注意:多维数组的每一维下标均不能越界!
19.结构体

C 数组允许定义可存储相同类型数据项的变量，结构是 C 编程中另一种用户自定义的可用的数据类型，它允许您存储不同类型的数据项。
结构用于表示一条记录，假设您想要跟踪图书馆中书本的动态，您可能需要跟踪每本书的下列属性：

[*]Title
[*]Author
[*]Subject
[*]Book ID
定义结构
为了定义结构，您必须使用 struct 语句。struct 语句定义了一个包含多个成员的新的数据类型，struct 语句的格式如下：
struct tag {
    member-list
    member-list
    member-list
    ...
} variable-list ;tag 是结构体标签。
member-list 是标准的变量定义，比如 int i; 或者 float f，或者其他有效的变量定义。
variable-list 结构变量，定义在结构的末尾，最后一个分号之前，您可以指定一个或多个结构变量。下面是声明 Book 结构的方式：
struct Books
{
   chartitle;
   charauthor;
   charsubject;
   int   book_id;
} book;在一般情况下，tag、member-list、variable-list 这 3 部分至少要出现 2 个。以下为实例：
//此声明声明了拥有3个成员的结构体，分别为整型的a，字符型的b和双精度的c
//同时又声明了结构体变量s1
//这个结构体并没有标明其标签
struct
{
    int a;
    char b;
    double c;
} s1;

//此声明声明了拥有3个成员的结构体，分别为整型的a，字符型的b和双精度的c
//结构体的标签被命名为SIMPLE,没有声明变量
struct SIMPLE
{
    int a;
    char b;
    double c;
};
//用SIMPLE标签的结构体，另外声明了变量t1、t2、t3
struct SIMPLE t1, t2, *t3;

//也可以用typedef创建新类型
typedef struct
{
    int a;
    char b;
    double c;
} Simple2;
//现在可以用Simple2作为类型声明新的结构体变量
Simple2 u1, u2, *u3;访问结构成员
为了访问结构的成员，我们使用成员访问运算符（.）。成员访问运算符是结构变量名称和我们要访问的结构成员之间的一个句号。您可以使用 struct 关键字来定义结构类型的变量。下面的实例演示了结构的用法：
#include <stdio.h>
#include <string.h>
//来源公众号：C语言与CPP编程

struct Books
{
   chartitle;
   charauthor;
   charsubject;
   int   book_id;
};

int main( )
{
   struct Books Book1;      /* 声明 Book1，类型为 Books */
   struct Books Book2;      /* 声明 Book2，类型为 Books */

   /* Book1 详述 */
   strcpy( Book1.title, "C Programming");
   strcpy( Book1.author, "Nuha Ali");
   strcpy( Book1.subject, "C Programming Tutorial");
   Book1.book_id = 6495407;

   /* Book2 详述 */
   strcpy( Book2.title, "Telecom Billing");
   strcpy( Book2.author, "Zara Ali");
   strcpy( Book2.subject, "Telecom Billing Tutorial");
   Book2.book_id = 6495700;

   /* 输出 Book1 信息 */
   printf( "Book 1 title : %s\n", Book1.title);
   printf( "Book 1 author : %s\n", Book1.author);
   printf( "Book 1 subject : %s\n", Book1.subject);
   printf( "Book 1 book_id : %d\n", Book1.book_id);

   /* 输出 Book2 信息 */
   printf( "Book 2 title : %s\n", Book2.title);
   printf( "Book 2 author : %s\n", Book2.author);
   printf( "Book 2 subject : %s\n", Book2.subject);
   printf( "Book 2 book_id : %d\n", Book2.book_id);

   return 0;
}
学好C++才是入职大厂的敲门砖！ 当年要是有这课，我的C++也不至于这样
已失效
20.共用体

共用体是一种特殊的数据类型，允许您在相同的内存位置存储不同的数据类型。您可以定义一个带有多成员的共用体，但是任何时候只能有一个成员带有值。共用体提供了一种使用相同的内存位置的有效方式。
#include <stdio.h>
#include <string.h>

union Data
{
   int i;
   float f;
   charstr;
};

int main( )
{
   union Data data;      

   printf( "Memory size occupied by data : %d\n", sizeof(data));

   return 0;
}21.指针

#include <stdio.h>

int main ()
{
   intvar = 20;   /* 实际变量的声明 */
   int*ip;      /* 指针变量的声明 */

   ip = &var;/* 在指针变量中存储 var 的地址 */

   printf("Address of var variable: %p\n", &var);

   /* 在指针变量中存储的地址 */
   printf("Address stored in ip variable: %p\n", ip );

   /* 使用指针访问值 */
   printf("Value of *ip variable: %d\n", *ip );

   return 0;
}22.文件读写

写入文件
#include <stdio.h>

int main()
{
   FILE *fp = NULL;

   fp = fopen("/tmp/test.txt", "w+");
   fprintf(fp, "This is testing for fprintf...\n");
   fputs("This is testing for fputs...\n", fp);
   fclose(fp);
}读取文件
#include <stdio.h>

int main()
{
   FILE *fp = NULL;
   char buff;

   fp = fopen("/tmp/test.txt", "r");
   fscanf(fp, "%s", buff);
   printf("1: %s\n", buff );

   fgets(buff, 255, (FILE*)fp);
   printf("2: %s\n", buff );
   
   fgets(buff, 255, (FILE*)fp);
   printf("3: %s\n", buff );
   fclose(fp);

}C语言与C++学习路线

23.排序算法

十大经典排序算法(动态演示+代码)
24.查找算法

九种查找算法
25.面试知识

C语言与C++面试知识总结
26.字符串操作

字符串操作的全面总结
27. C语言常用标准库解读

C语言常用标准库解读
28. C语言最常用的贪心算法

C语言最常用的贪心算法就这么被攻克了
29. 常见的C语言内存错误及对策

常见的C语言内存错误及对策
30. C语言实现面向对象的原理

C语言实现面向对象的原理
31. C语言/C++内存管理

看完这篇你还能不懂C语言/C++内存管理？
32. 再谈C语言指针

再谈指针：大佬给你拨开 C 指针的云雾
C语言函数指针之回调函数
C语言指针详解(文末有福利)
33. C语言预处理命令

长文详解：C语言预处理命令
34. C语言高效编程与代码优化

C语言高效编程与代码优化
35. C语言结构体

C语言之结构体就这样被攻克了！值得收藏！
36. 原码, 反码, 补码 详解

原码, 反码, 补码 详解
37. C语言宏定义

简述C语言宏定义的使用
38. c语言之共用体union、枚举、大小端模式

c语言之共用体union、枚举、大小端模式

C 语言可以零基础入门，它的语法是很多高级编程语言的基础，比如说 Java、C++；并且起到承上启下的作用，向上可以学习高级编程语言，向下可以学习计算机组成原理、操作系统等等偏基础的计算机基础知识。

http://picx.zhimg.com/v2-c7904296a894babecaa25921624677d5_r.jpg?source=1940ef5c
书籍

第一本书《阿哈C语言》的写书风格个人认为比较风趣幽默，对于培养兴趣，基础学习还是很不错的
《C程序设计语言》，机械工业出版社，作者Brian W. Kernighan / （美）Dennis M. Ritchie。C 语言之父写的，入门经典书籍。
《C Primer Plus》 ，人民邮电出版社，作者 Stephen Prata。 可以作为 C 语言工具书，也可以作为入门，内容循序渐进，能够锻炼编程思想。
《C和指针》 深入了解指针，看完以后对指针不再害怕。
《C陷阱与缺陷》 正如书上所说，“本书所揭示的知识，至少能够帮助你减少 C 代码和初级 C++ 代码中 90% 的 Bug”，看完后可以避免 C 语言开发的一些坑。


[*]<a href="http://link.zhihu.com/?target=https%3A//pan.baidu.com/s/1e0zPOp-fhGKKKiILGHx_Ew" class=" wrap external" target="_blank" rel="nofollow noreferrer">征服C指针 提取码：wwcd
[*]经典C程序100例 提取码：t8oe
[*]C专家编程 提取码：uso7
[*]C语言指针经验总结 提取码：ibjw
[*]C语言深度解剖 提取码：6qho
[*]C语言深度解剖 解开程序员面试笔试的秘密 提取码：ffh1
[*]c语言入门经典(第5版) 提取码：lzro
[*]C语言解析教程 提取码：mfgv
[*]C语言函数大全 提取码：ir2d
[*]C语言的科学和艺术 提取码：zm88
[*]C语言答疑解惑与典型题解 提取码：8cw5
[*]C语言从入门到精通 第2版明日科技 提取码：4s8h
[*]C语言程序设计_现代方法 提取码：t4vn
[*]C语言常见问题集（问题提高版） 提取码：xto5
[*]C语言参悟之旅 提取码：5h1t
[*]C语言参考手册第五版 提取码：t3g1
[*]C语言编程精粹 提取码：5oai
[*]C陷阱与缺陷 提取码：nejz
[*]C和指针（中文版） 提取码：1gvd
[*]C程序设计语言(英文第2版)及其课后题答案 提取码：wzky
[*]C程序设计语言（第2版 新版）及课后答案 提取码：rowl
[*]C 程序设计语言（第2版） 提取码：4s98
[*]C Primer Plus 中英版 提取码：um90
[*]C Primer Plus 第6版 中文版 提取码：n30r
[*]21天学通C语言 第7版 提取码：8fuj
[*][学通C语言的24堂课].刘彬彬&孙秀梅 提取码：f44n
[*].明日科技.扫描版 提取码：bn80
网课

1、《郝斌C语言自学教程》
《郝斌C语言自学教程》_哔哩哔哩_bilibili​www.bilibili.com/video/BV1os411h77o?from=search&seid=150264751692483786672、《程序设计入门——C语言》（浙大翁恺）
程序设计入门——C语言（浙大翁恺）_哔哩哔哩_bilibili​www.bilibili.com/video/BV1ME411h75N?p=48小项目
包括C语言迷宫、24点游戏、奔跑的火柴人、超市管理系统、打字母、电子时钟、对对碰、俄罗斯方块、黑白棋、华容道、火车票订票管理源码、连连看、商品销售系统、象棋、超级玛丽、图书管理系统、学生成绩管理系统.......
大量好玩的C语言程序，训练编程思维，培养解决问题的思路，领略多姿多彩的 C 语言。！​mp.weixin.qq.com/s/ZUHtQxaahrGjvAZVu5jKKg欢迎关注我 @韩飞宇 !

http://picx.zhimg.com/v2-fbd607e24ab47d53104fae26cfd6033f_r.jpg?source=1940ef5c

让我看看是哪个小可爱给我点赞了

简单介绍一下自己，我是飞宇，本硕均于某中流985 CS就读，以前是在百度搜索部门做后端研发实习生，后来又去了字节某电商部门担任后端研发工程师。
虽然是所谓的科班出生，但学校教育质量就不提了。。。懂得都懂，所以我学习计算机基本全靠自学，B站、github、网易云课堂、YouTube等就是我的学习课堂。
我会继续分享一些计算机学习经验、一些不错的编程资源以及自己在互联网一二线公司工作的工作体验和日常生活等。
这是我的计算机编程资源收集仓库:github开源地址 ，码云开源地址;
这是我自己学习Linux C/C++以来的学习总结:github开源地址，码云开源地址

春天 发表于 2023-10-3 19:52:30

花9分钟让自己睡着，剩下1分钟用来做梦。
当然了，既然有这样的问题，说明你是有学C语言的困惑，提供一套郝斌老师30小时左右的课吧。
30小时不是说你看30小时就能学会了，要有效率。
1、C语言概述
2、C语言实现Hello Word
3、C语言起源
4、C语言特点
5、C语言应用领域
6、C语言的重要性
7、C语言怎么学
8、C语言学习目标
9、C语言常见困惑
10、C语言总纲

11、C语言一元二次方程
12、C语言开发工具介绍
13、C语言阶段总结
14、C语言要掌握的计算机知识
15、cpu、内存之间的关系
16、C语言HelloWorld如何运行起来
17、C语言数据类型
18、C语言变量是什么
19、编程基础
20、C语言变量为什么初始化

21、C语言如何定义变量
22、什么是进制
23、常量在C语言中如何表示
24、常量怎么存储在计算机中
25、预备专业知识
26、C语言代码的规范化
27、什么是字节
28、C语言不同类型数据之间相互赋值
29、C语言char常见问题
30、什么是ASCII码表

31、C语言printf和scanf
32、C语言printf详解_1
33、对初学者的建议
34、如何编写出更有保存价值的程序
35、C语言printf用法详解_2
36、C语言printf为什么需要输出控制符
37、C语言printf总结
38、C语言scanf不含输入控制符的用法
39、C语言scanf含有非输入控制符
40、C语言一次给多个变量键盘赋值

41、C语言如何使用scanf编写高质量代码
42、C语言运算符的分类和简介
43、C语言除法与取余运算符
44、C语言逻辑运算符
45、初学C语言运算符的建议
46、C语言scanf总结
47、C语言流程控制
48、C语言流程控制的分类
49、C语言流程控制小结
50、C语言流程控制的重要性

51、C语言if语句概述
52、C语言if语句用法
53、C语言if范围问题
54、C语言if else用法
55、C语言if else if else用法
56、C语言对真假的处理
57、C语言求分数等级
58、C语言互换两个数字
59、C语言对3个数排序
60、如何看懂一个C语言程序

61、C语言阶段小结
62、C语言空语句的问题
63、C语言if语句易错点解析
64、C语言witch简述
65、C语言循环的定义
66、C语言循环的分类
67、C语言为什么用for循环
68、C语言for循环用法
69、C语言for与if的嵌套
70、C语言阶段小结

71、C语言强制类型转换
72、浮点数的存错带来的问题
73、C语言for和if嵌套例题
74、C语言多层for嵌套的使用
75、计算机进制
76、C语言自增自减
77、C语言运算符_1
78、C语言运算符_2
79、C语言多个for循环执行顺序
80、C语言for循环嵌套

81、C语言while概述
82、C语言while执行顺序
83、C语言for与while比较
84、C语言实现回文数
85、C语言如何看懂一个程序
86、C语言斐波那契
87、C语言何时使用for或者while
88、C语言 do while for while的区别
89、C语言一元二次方程
90、C语言 switch 入门

91、C语言 switch 小结
92、C语言break语句
93、C语言 continue语句
94、C语言学C语言为什么无法做出像样东西
95、C语言流程控制总结
96、C语言流程控制测试
97、C语言数组概述
98、C语言数组的使用
99、C语言为什么用数组
100、C语言数组杂谈

101、C语言一维数组
102、C语言二维数组
103、C语言多维数组
104、C语言函数概述
105、C语言函数使用简单概述
106、C语言为什么用函数
107、C语言什么是函数
108、C语言如何定义函数
109、C语言return和break的区别
110、C语言函数分类

111、C语言函数举例
112、C语言函数小结
113、C语言函数声明
114、C语言函数形参与实参
115、如何在开发中合理设计函数
116、C语言函数小结
117、C语言常用系统函数
118、C语言递归
119、C语言函数回顾
120、C语言变量的作用域和存储方式

121、C语言指针简述
122、C语言指针的重要性
123、C语言什么是地址
124、C语言什么是指针
125、C语言指针的基本类型
126、C语言指针常见错误分析
127、C语言互换两个数字
128、C语言星号的三种含义
129、C语言指针小结
130、C语言指针为什么可以使被调函数修改主调函数

131、C语言一维数组和指针的关系
132、C语言下标和指针的关系
133、C语言一维数组名的含义
134、C语言确定一个一维数组需要2个参数及其原因
135、C语言阶段小结
136、C语言指针变量的运算
137、C语言指针变量占几个字节
138、C语言动态内存分配概述
139、C语言传统数组的缺点
140、C语言为什么需要动态内存分配

141、C语言malloc函数
142、C语言malloc函数的用法
143、C语言动态一维数组的构造
144、C语言动态内存与静态内存对比
145、C语言多级指针
146、C语言阶段小结
147、C语言指针杂谈
148、C语言静态变量不能跨函数使用
149、C语言动态内存可以跨函数使用详解
150、C语言跨函数使用内存习题测试

151、C语言什么是结构体
152、C语言如何定义结构体
153、C语言如何使用结构体变量
154、C语言结构体的赋值和初始化
155、C语言如何取出结构体变量中的每一个成员
156、C语言结构体小结
157、C语言阶段总结
158、C语言结构体回顾
159、C语言通过函数完成对结构体变量的输入和输出
160、C语言应该发送内容还是应该发送地址

161、C语言指针优化总结
162、C语言结构变量的运算
163、C语言冒泡排序
164、C语言学生管理系统
165、C语言枚举_1
166、C语言枚举_2
167、C语言进制转换
168、C语言补码_1
169、C语言小结
170、C语言补码_2

171、C语言链表_1
172、C语言链表_2
173、C语言链表_3
174、狭义的算法
175、广义的算法
176、C语言位运算符
177、C语言文件 宏 typedef 杂谈
178、C语言期末习题解析_1
179、C语言期末习题解析_2
180、C语言null的含义
181、C语言期末习题解析_3
页: [1]
查看完整版本: 如何在十分钟之内学完C语言？