页面“开车 科目三”与“C基础”之间的差异

来自linux中国网wiki
(页面间的差异)
跳到导航 跳到搜索
 
 
第1行: 第1行:
=点火=
 
点火要踩离合哦
 
离合要 快踩慢放 慢慢 起步
 
刹车 要
 
  
=共享汽车=
 
[https://www.zhihu.com/question/334597777 想问一下广州这边共享汽车哪个好用点?]
 
  
[https://www.sohu.com/a/243719873_464675  广州共享汽车用车程序和价格对比! ]
 
  
[https://www.zhihu.com/question/63727719 广州有哪些共享汽车的公司,质量都如何?]
+
 +
good
 +
http://akaedu.github.io/book/
  
=pre 2020=
 
<pre>
 
  
有两个牌要自己看  过jiang磅 30m  和下面的直线要注意
+
[https://zhuanlan.zhihu.com/p/90971489 C语言编程学习必备的一些网站,干货收藏!]
 +
 
 +
[https://www.bilibili.com/video/BV17s411N78s/?spm_id_from=333.788.videocard.0 带你学C带你飞》]
 +
=如何学习C=
 +
 
 +
[https://blog.csdn.net/qwe6620692/article/details/88107248  学习C语言,如何看懂及掌握一个程序]
 +
 
 +
=2021学习C APUE=
 +
http://www.apuebook.com/
 +
 
 +
[https://www.zhihu.com/topic/19705459/hot UNIX环境高级编程(书籍)笔记什么都 有呀 ]
 +
 
 +
[https://www.zhihu.com/question/19939011 《UNIX环境高级编程》这本书怎么看?怎么学习]
  
  
前面是个 2km 提示 所以要多看右边的指标呢 通过学校 不报的,要自己点刹车的地方后,请尽量把车身拉直,通过摄像头后,就是直线行驶项目
 
  
 +
==看法  ==
 +
第二章和第六章可以跳跳,回头看
  
多问,看的多了,总有自己不理解的问题,
+
7.中文版翻译有瑕疵,但是整体还是不错,不至于对阅读产生影响(信号量那章有细节问题,但是信号量那张和csapp第八章几乎重复)
  
需要快速降低速度的时候,我会先踩离合,断开动力,然后刹车控速,  离合就是空档
+
首先,不要抱着一口气把这本书学完的心态去看。      尝试根据自己的兴趣,选择一个规模适当的开源项目,去阅读它的源代码。(例如我选择的就是一个小型的http服务器--Mongoose)当在某一方面发现自己有很多问题时,很希望去弄清楚时,这时候就可以去翻开手中的APUE,带着问题去阅读。这时候学习的效率必然比盲目地去看书更高,而且遗忘率也会降低。但是,仅仅读完是不够的。      很多时候,你看书的时候,会感觉自己看懂了,但是没过多久,又会发现自己忘了。或者,有时候你根本没看懂,而只是囫囵吞枣地看过去。所以,看完后,最好的方法就是写博客。尝试按照自己的理解以及逻辑,去将你学到的知识系统地阐述出来。这样,就算你以后忘了,再去翻翻博文,也能很快就捡起来。
  
 +
十个最值得阅读学习的C开源项目代码
  
一、认真对待平时的练习,把每一次练习都当做考试。科目三细节很多,相信在平时练习的时候大家的教练也会给大家讲解。那么在平时练习的时候,每次练习我都会把它当成考试来看待,想象这是在考试,通过这样的反复练习,一方面能够严格按照考试标准来要求自己,减少考试出错的可能性;另一方面,也算是在不断地提前“熟悉”考试流程,给自己一个心理暗示:我已经很熟练了,至少从个人能力上来说,我已经具备通过考试的条件。
+
    Webbench
 +
    Tinyhttpd
 +
    cJSON
 +
    CMockery
 +
    Libev
 +
    Memcached
 +
    Lua
 +
    SQLite
 +
    UNIX v6
 +
    NETBSD
  
二、降低期望,敢于面对结果。很多人考试前会很紧张,因为害怕自己考不过,归根到底就是期望太高,这样一来反而更加紧张。但是紧张却非常不利于考试的发挥,很多人平时练习的时候都可以满分通过,但是一到考场,因为紧张反而手忙脚乱错误百出导致失败。所以与其这样,还不如降低期望,一是可以告诉自己有可能考不过,做好心理准备;二是不要把结果看得太重,这就是一场小考试,考不过天又不会塌下来,塌下来了还有比我们高的挡着。所以试着“在战略上蔑视,在战术上重视”。
+
建议先看 >> Unix/Linux编程实践教程
  
三、调整好心态,把考试当做平时的练习。在考试前会有一段等待时间,这段时间会有点难熬,这个时候,可以在脑子里过一边流程,把考试时需要做的事情在脑子里过一遍,比如:上车-系安全带-模拟夜间灯光…… 轮到你的时候,深呼吸一口气,告诉自己:稳住。然后可以不断暗示自己:这就是平时的练习,没什么大不了的,这样情绪可以稍微稳定一点。然后慢慢来,把每个步骤都做好,就可以了。所以总得来说我的经验就是两点:一是平时一定认真练习,不要觉得是练习就不重视,只有平时练熟了到考场上才能游刃有余。二是心态很重要,把平时的练习当做考试,把考试当做平时的练习(我在高考和考研的时候都是这样,所以在考场上心态还算稳),降低期望。
+
https://book.douban.com/subject/1219329/
  
 +
http://item.kongfz.com/book/32040616.html?push_type=2&min_price=57.00&utm_source=101004009001
  
 +
https://detail.tmall.com/item.htm?spm=a1z10.1-b.w9858442-8055933095.4.fH3HiL&id=19729431809
  
 +
[https://github.com/woai3c/recommended-books 常用计算机书的下载]
  
,简单点的就是考试时看一下车和线的距离,上车调好座椅后,看一下车前盖与线的交点位置,这样就可以根据具体情况调整了。 别的还有根据车前凸起部分三分之一点,考试号圈右缘,人在路中偏右侧这些对点法。 实际上,引车员一般都会停好位置,我们不用怎么动方向调整的,而且丢了10分好过压线不合格,能出路面胜算就大很多,所以这个可以练习但不要太在乎。 ...
+
[https://blog.csdn.net/qwe6620692/article/details/88107248  学习C语言,如何看懂及掌握一个程序!]
  
qing316 发表于6楼  查看完整内容
+
[https://blog.51cto.com/chinalx1/2143904 十个经典的C开源项目代码]
我说的就是传祺车滴,有预算找一下传祺练也不错,实在紧张可以含薄荷糖,提神醒脑,我科目二和三都这样缓解情绪的。
 
  
 +
[https://developer.51cto.com/art/201903/593703.htm 初学玩转C语言,这17个小项目收下不谢]
  
 +
https://zhuanlan.zhihu.com/p/83185476
  
一、做好起步:起步防熄火、防遗漏
+
== tinyhttpd C 语言实现最简单的 HTTP 服务器 学习 ==
  
  熄火的原因大致有两种:一是心急心惊慌导致的,离合器抬得过快。克服的方法很简单,沉住气,不要慌,离合器慢慢抬,到半联动时,感觉车要动了,别再抬,压住不动,等车走了,估计车轮转了一圈了,再慢慢地完全抬起离合器。
+
[https://www.shuzhiduo.com/A/ZOJPY9Ge5v/ tinyhttpd ------ C 语言实现最简单的 HTTP 服务器]
  
  二是忘松手刹造成熄火。克服方法:按训练场初学时步骤,一步不乱地操作,实在不行就默背口诀:“一拨二踩三挂挡,四鸣五松六观察,慢抬离合起步走”拨转向灯、踩离合器刹车、挂挡、鸣喇叭、松手刹脚刹、观察确认安全,就一步都不会忘掉了。
+
https://github.com/nengm/Tinyhttpd
  
当然了,30公分的距离也不是不能做到。其实靠边停车找30cm的方法和科目二坡道定点时用的方法是一样的。就是当右侧车头的三分之一处与边线重合时,此时刚好是右侧车轮距离边线30cm的距离
+
[https://blog.csdn.net/baiwfg2/article/details/45582723  tinyhttpd源码详解]
  
 +
[https://blog.csdn.net/konghhhhh/article/details/103752962  tinyhttp整理(一)]
  
,简单点的就是考试时看一下车和线的距离,上车调好座椅后,看一下车前盖与线的交点位置,这样就可以根据具体情况调整了。 别的还有根据车前凸起部分三分之一点,考试号圈右缘,人在路中偏右侧这些对点法。 实际上,引车员一般都会停好位置,我们不用怎么动方向调整的,而且丢了10分好过压线不合格,能出路面胜算就大很多,所以这个可以练习但不要太在乎。 ...
+
[https://blog.csdn.net/weixin_30387663/article/details/99664160  tinyhttp源码阅读(注释)]
  
qing316 发表于6楼 查看完整内容
+
[https://juejin.cn/post/6870760453619122183 Tinyhttp源码分析及知识点总结 ]
我说的就是传祺车滴,有预算找一下传祺练也不错,实在紧张可以含薄荷糖,提神醒脑,我科目二和三都这样缓解情绪的。
 
  
 +
[https://www.bilibili.com/video/BV1hy4y1C71M/?spm_id_from=333.788.videocard.1 b站 C/C++ tinyHttp服务器小项目及源码讲解1]
  
 +
[https://blog.csdn.net/wwxy1995/article/details/99362666  tinyhttpd深入解析与源码剖析]
  
一、做好起步:起步防熄火、防遗漏
+
[https://blog.csdn.net/qq_40677350/article/details/90201758  Tinyhttpd-master 源码学习笔记1]
  
  熄火的原因大致有两种:一是心急心惊慌导致的,离合器抬得过快。克服的方法很简单,沉住气,不要慌,离合器慢慢抬,到半联动时,感觉车要动了,别再抬,压住不动,等车走了,估计车轮转了一圈了,再慢慢地完全抬起离合器。
+
[https://blog.csdn.net/yzhang6_10/article/details/51534409  Tinyhttp源码分析]
  
  二是忘松手刹造成熄火。克服方法:按训练场初学时步骤,一步不乱地操作,实在不行就默背口诀:“一拨二踩三挂挡,四鸣五松六观察,慢抬离合起步走”拨转向灯、踩离合器刹车、挂挡、鸣喇叭、松手刹脚刹、观察确认安全,就一步都不会忘掉了。
+
[https://github.com/EZLippi/Tinyhttpd Tinyhttpd非官方镜像,Fork自sourceForge,仅供学习]
  
  
****
 
  
科二没紧张,但科三还是让我很纠结,没睡好觉不说,考试前还紧张,并且在第一次考试挂掉后还失去了信心,慢慢的经过了一个月的重新练习才找了回来。我想说的是,其实大家都紧张,我一紧张就会闭上眼,把考试的场景重新演练一遍,各个动作重新熟练一遍,这样就不紧张了。如果考试的时候紧张,一定要慢点,真开起车来,就没那么紧张了。因为你要想着下一步该怎么做,没时间紧张。
 
  
 +
[https://www.jianshu.com/p/18cfd6019296 tinyhttp源码分析]
  
 +
我把一些核心代码和相应的注释贴在这里,如果你感兴趣全部,可以移步我的github。
 +
https://github.com/zhaozhengcoder/rebuild-the-wheel/tree/master/tinyhttpd
  
我觉得有句话很有必要送给大家,我国的经济学家顾准曾经说过,如果一个人能用历史的角度去考虑发生在自己身上的事情,就不会有任何的恐惧和抱怨,因为他知道那一切都是历史的必然。现在考驾照的人很多,考试的规则也越来越严格,所以一两次没过很正常,尤其是科三考试,因为对考试规则的不熟悉,车辆状况各不相同(甚至离合高低,双闪轻重、刹车软硬都差别很大),在这种情况下,就算是不犯低级错误,挂掉的可能性也有30%左右,毕竟有一些不可控的运气因素在里面,再加上新手对实际路况的处理没那么恰当,所以挂掉也正常。像我这样,多考一回,自然就有经验了。另外我想说的是,你熄火的原因松离合快是一方面,最主要的是你根本就没掌握半联动的概念。鄙视一下自己,我也是科三挂了以后才知道半联动的正确使用方法。离合慢松,车开始动了后,脚马上稳住不要再动,至少要停一秒,然后再慢松。如果没有这个停顿的动作,很容易熄火。如果车排量小、负载大、上坡、转弯、掉头,遇到这种阻力增大的情况,起步是要做油离配合的,也就是在半联动的位置轻给点油。你真以为你是离合快熄火吗,没那么简单。还有很多东西要学,不只是心理素质不好这一方面。关于忘记按喇叭这件事,是因为你没有把起步流程化导致的。考试的时候人紧张,并且很多考试项目是死的,你要把很多步骤流程化。比如起步要做到一踩二挂三转向四喇叭五手刹六观察。把这一句话背好了还会忘记按喇叭吗?一踩离合,二挂1档,三左转向开,四按喇叭,五松手刹,6观察路况。建议你看看我有关科三的回答,有一篇经验的。如果需要可以回复我,我贴上来。你也可以自己在我的回答里找一下,很长的那个。
 
  
 +
[https://www.google.com/search?q=Tinyhttp+%E4%BB%A3%E7%A0%81%E5%AE%8C%E5%85%A8%E8%AE%B2%E8%A7%A3&newwindow=1&safe=active&sxsrf=ALeKk00sI_LE3rix9st768kTRNvSLADqfQ%3A1616990574286&source=hp&ei=blFhYIrjDoTcswW95aqACg&iflsig=AINFCbYAAAAAYGFffrh-H2QmmZeV5OlApkx5kRBpdYOT&oq=Tinyhttp+%E4%BB%A3%E7%A0%81%E5%AE%8C%E5%85%A8%E8%AE%B2%E8%A7%A3&gs_lcp=Cgdnd3Mtd2l6EANQ0QhY0Qhg2gpoAHAAeACAAQCIAQCSAQCYAQCgAQKgAQGqAQdnd3Mtd2l6&sclient=gws-wiz&ved=0ahUKEwiK0qGmz9TvAhUE7qwKHb2yCqAQ4dUDCAY&uact=5 Tinyhttp 代码完全讲解]
  
再次告诫后面学车的真不要和教练冲,因为你还的跟他学。再者教练他们集体素质摆在那,不要太放心上。结果练了四个下午喊我考试,可想而知挂了,挂在直线行驶,而且2次都挂在直线行驶。这个地方教练重来都没说注意啊,回来各种难受,各种百度。学到一个方法把视野尽量看向远方,感觉自己坐在马路中间就行了。一开始我还不能理解我明明坐在左边,干嘛要让自己坐马路中间,后来我明白了你看向远方视野肯定会有偏差,所以这方法是对的。
+
==Mongoose-基于C的Web服务器代码学习 ==
  
 +
[https://www.jianshu.com/p/745c03a8864a Mongoose-基于C的Web服务器 介绍和使用]
  
1.紧张并不可怕。当你在等待的过程中变得紧张时,脑海中不要想着:“我去我去我去,好紧张。”不要将注意力放在自己紧张的这个状态上,而是应该去回忆一会儿上车,将要做的一系列步骤,即使你已经熟的不能再熟,也要逼迫自己去想它,你回想完之后,心也就不慌了。2.切勿好高骛远。一开始不要将目标放的太远,满分过什么的。准备上车的时候,告诉自己,我要挂也要挂在路面上,打灯、喇叭、手刹、安全带什么的绝对不能忘记或是做错。就算是爬也要爬着出去,死也要死在外面。抱着这样的决心开始考试,将注意力集中在努力将动作做规范上。3.线路图要烂熟于心。上路之后心里要有底:前方是什么路段,系统会给出怎样的指令,不要大脑一片空白,掌控这辆车,成功完成整个考试的几率也会提高。4.一定一定要沉住气!!!(三个感叹号,还加粗了,足以说明这点有多重要了吧?)快到终点的时候不要急高兴,觉得自己好像已经过了一样,直到听到语音播报:“考试合格,考试结束。”这句话之后你才能松下这口气,还没听到,就把这口气憋着吧。太多人在要完成考试的时候因为各种差错挂掉了,不觉得非常可惜吗?只要再稳住那么十几秒,你就不用重来,不用挂掉,不用再漫长的等待了。
 
  
回想第一次考科目三,一上车就死在灯光上面,还不是因为做错了,而是抢播报,系统语音没说完就提前打灯做了双闪,系统没感应到,报考试不及格,安全员让我下车T_T
+
[https://blog.csdn.net/hnzwx888/article/details/84971205  Web服务器----mongoose]
下车机械性的绕车一周继续,这次没错灯光,起步颤抖+离合松太快导致车辆死火,扣15分,byebye
 
  
 +
https://github.com/cesanta/mongoose
  
1.做好准备。练车是一直没问题的,考前一天,我自己就坐在床边试着脑中模拟出考试的情况,然后考试怎样就怎么做,两次过后,睡觉。2.早点睡。睡眠不足很容易恍惚,发挥失常,疲劳驾驶真的要不得。3.真.控制住自己。考前买了两条糖,等的时候一直在吃糖玩手机,毕竟还没开始紧张。等到进入候考区域的时候明显感觉到全身肌肉开始僵硬,自我安慰今天天气很冷^_^前面那个上车的时候就开始心跳加速,然后进入第二阶段,自我麻痹。吸一大口气,然后停顿几秒,受不了了才呼气。就这样,一直到叫我上去考试,绕车一周后,按上面方法深呼吸好几次再上车,系安全带,调座椅。。。这个对我很有用,至少能感觉到心跳没有那么快,hehe~4.针对像我一样补考的,查漏补缺。前一次死灯光和起步。前者,等语音播完了,心里默念一边再打灯,同时双闪不用打得太急,毕竟有时间。后者,离合松到车子抖动就可以松刹车了,绝对不会后溜的,不走的再松一点点离合就是了。还有离合松太快的问题,仪表盘显示的速度没到7、8绝对不松离合。
+
[https://www.cnblogs.com/skynet/archive/2010/07/24/1784110.html  Mongoose源码剖析:外篇之web服务器 ]
  
…一踩二挂三转向四喇叭五手刹六看倒车镜
+
[https://blog.csdn.net/lixiaogang_theanswer/article/details/102753370  Mongoose-6.14源码剖析之基础篇]
  
 +
== 我的笔记 ==
 +
apue.3e/include/apue.h
 +
=== chapter 1===
 +
[https://zhuanlan.zhihu.com/p/136700729 APUE读书笔记-01UNIX系统概述]
  
 +
这是原文学不过是 Second Edition  firefox 放大 就可以看  找一下 第三版本吧 Third Edition
 +
https://vaqeteart.gitee.io/file_bed/shared/books/APUE2/toc.html
  
  
 +
=== ?===
  
</pre>
+
[https://www.jb51.net/article/55257.htm C语言实现的ls命令源码分享-apue]
  
[https://zhuanlan.zhihu.com/p/27214901 科目三考试注意事项,看完过了一半!]
+
[https://blog.nowcoder.net/n/9a48a7f697864e3bbdae2fe5bfcb0ef9 C 语言实现 Linux ls 命令]
  
[https://www.bilibili.com/video/av60382571?from=search&seid=3060194934512279866 最新广州华观路改科三视频演示,超详细!]
+
=understanding_unix_programming =
  
[https://zhuanlan.zhihu.com/p/70830978 科二科三,缓解考试紧张小妙招!]
+
==chapter 2  who ==
  
[https://www.bilibili.com/video/av79212437?from=search&seid=3060194934512279866 华观路科目三一次过]
+
<pre>
 +
/* 再看一下书 非常 好的啦 
 +
who命令的实现过程是先打开一个系统文件UTMP_FILE,创建对应的格式struct utmpfd变量,读取数据到这个结构体中,作相应格式输出即可
 +
*/
 +
#include<stdio.h>
 +
#include<utmp.h>
 +
#include<fcntl.h>
 +
#include <time.h>
 +
#include<unistd.h>
 +
#define SHOWHOST
 +
void showtime(long);
 +
void showtime(long timeval){
 +
    char *cp;
 +
    cp = ctime(&timeval);
 +
    //cp[strlen(cp)-1]='\0';
 +
    printf("%s",cp+4 ); //wed jun 21:40:09  +4是因为*cp所指的一串字符前4个字符表示为“星期”,可以忽略此信息
 +
}
 +
// 指向结构体 utmp 的指针 utbufp
 +
void show_info(struct utmp *utbufp)
 +
{
 +
    printf("%-8.8s",utbufp->ut_name) ;
 +
    printf(" ");
 +
  printf("%-8.8s",utbufp->ut_line);
 +
  printf("");
 +
  printf("% 10ld",utbufp->ut_time );
  
[https://www.bilibili.com/video/av74781082/?spm_id_from=333.788.videocard.2 广州华观路科目三2019]
+
  printf(" ");
  
 +
  printf(" ");
  
https://zhuanlan.zhihu.com/p/46601421
+
}
  
 +
int main()
 +
{
 +
  struct utmp current_record;
 +
  int  utmpfd;
 +
  int reclen = sizeof(current_record);
  
https://www.zhihu.com/club/1185561713246801920  知群 加一下
+
  if (( utmpfd = open (UTMP_FILE, O_RDONLY)) == -1) {
 +
  perror(UTMP_FILE);
 +
  return 1;
 +
  }
 +
  while ( read(utmpfd, &current_record, reclen) == reclen )
 +
  show_info(&current_record);
 +
  close(utmpfd);
 +
  return 0;
  
[https://www.bilibili.com/video/av19059119/?spm_id_from=333.788.videocard.17 华观路科目三路考线路实地考察]
+
}
  
  
[https://www.bilibili.com/video/av71246174?from=search&seid=15560125284649048338 广州科目三展贸考场]
 
  
[https://h.bilibili.com/39105848 广州科目三展贸考场示意图]
 
  
=灯光=
 
==视廓灯==
 
两个眼 视廓灯  ;
 
==近光 ==
 
斜线在左 前照灯  近光 ;
 
==远光灯 ==
 
向前推 远光灯  , 
 
  
==左转向 ==
 
左转向  下拉    ;
 
==右 转向==
 
右 转向 上提 
 
  
[https://v.youku.com/v_show/id_XNDQ1MDc1Mjk4OA==.html?spm=a2h0k.11417342.soresults.dtitle 科目三灯光开关操作解读, 新手认识灯光]
 
  
[https://search.bilibili.com/all?keyword=%E5%B9%BF%E5%B7%9E%E7%A7%91%E7%9B%AE%E4%B8%89%20%E7%81%AF%E5%85%89 广州科目三 灯光]
 
  
=追线=
 
不能大于 50
 
  
  
[https://v.qq.com/x/page/c0561vyogf1.html  科目二“雨刮器”对齐边线30cm技巧讲解,科目三靠边停车通过实用 ]
 
=直线行驶=
 
[https://www.bilibili.com/video/av29975748?from=search&seid=2631073638893914060 驾校 c1/2科目三理论课 part5 掉头 直线行驶]、
 
  
直线行驶,不是中间行驶; 微调,不是慢调
 
  
[https://www.bilibili.com/video/av61032846/?spm_id_from=333.788.videocard.8 直线行驶]
 
==原理==
 
<pre>
 
张全蛋
 
透视原理是美术中一门非常基础,也是非常重要的学科。想保持直线行驶,必须遵循透视规律。透视原理是将立体空间里的东西表现在二维画面上所需要遵循的原则,掌握好透视的视觉规律可以让我们更好的保持直线行驶。广义上,近大远小,近实远虚,近浓远淡,等都是透视规律,这篇文章,主要讲一点透视,也就是驾驶员视觉画面上透视规律。
 
  
一点透视也叫平行透视。当我们向一个方向望去的时候,在我们的视野中间想象一条水平线,这根线就是我们的视平线。当一辆车向远方行驶,我们会发现它变得越来越小,最后消失于视平线上的一个点,这个点,就是消失点。同样,向远方延伸的公路,也会渐渐消失于一个消失点。与公路平行的所有线条,最终也会消失于这一个点。
 
  
  
  
 +
C 库函数 void *memset(void *str, int c, size_t n) 复制字符 c(一个无符号字符)到参数 str 所指向的字符串的前 n 个字符。
 +
memset(str,'$',7);
  
 +
This is string.h library function
 +
$$$$$$$ string.h library function
 
</pre>
 
</pre>
https://www.zhihu.com/question/24708600/answer/698949289
 
  
==2020==
+
参考 和书 chapter 2  这个最接近原书的了
 +
 
 +
https://www.cnblogs.com/20145221GQ/p/6060420.html
 +
 
 +
[https://blog.csdn.net/u010307522/article/details/72862589  who命令实现]
 +
 
 +
[https://blog.csdn.net/qq_33850438/article/details/60762519  unix/linux who命令的实现]
 +
 
 +
https://www.runoob.com/cprogramming/c-function-memset.html
 +
===别人实现1===
 +
https://www.cnblogs.com/20145221GQ/p/6060420.html
 +
 
 +
https://gitee.com/20145221/linux-besti-is-2016-2017-1-20145221/blob/master/src/week09/who.c?dir=0&filepath=src%2Fweek09%2Fwho.c&oid=6ca54191e2a046c9de2e42cfc5eb895ff665b429&sha=6cd302d6cb4f0d36f667754e972ce63963483044#
 
<pre>
 
<pre>
现在还有的问题是 如何确定车走过程中提前知道不正,要看哪 ,就直接感觉车头么 感觉老是太晚了
 
  
 +
#include <stdio.h> 
 +
#include <utmp.h>
 +
#include <fcntl.h> 
 +
#include <unistd.h> 
 +
#include <time.h> 
 +
#include <string.h>
 +
 
 +
#define SHOWHOST 
 +
 
 +
void showtime(long timeval){ 
 +
    char* cp; 
 +
    cp = ctime(&timeval); 
 +
    cp[strlen(cp)-1] = '\0';
 +
    printf("%s",cp+4); 
 +
 +
 
 +
void show_info(struct utmp* utbufp){ 
 +
    if(utbufp->ut_type != USER_PROCESS){ 
 +
        return ; 
 +
    } 
 +
 
 +
    printf("%-8.8s",utbufp->ut_name); 
 +
    printf(" "); 
 +
    printf("%-8.8s",utbufp->ut_line); 
 +
    printf(" "); 
 +
    showtime(utbufp->ut_time); 
 +
    printf(" "); 
 +
 
 +
#ifdef SHOWHOST 
 +
    if(utbufp->ut_host[0] != '\0'){ 
 +
        printf("(%s)",utbufp->ut_host); 
 +
    } 
 +
#endif 
 +
    printf("\n"); 
 +
}
  
理想状态下直线行驶轨迹:1.是一条直线 2.跟车道分界线平行要满足上面2点需要满足都条件:
+
int main(){ 
1.车身直(与车道分界线平行)2.方向正(方向盘0度),
+
    struct utmp current_record; 
在实际行驶当中只能无限接近这两个条件,所以需要方向盘需微调(5度)。方向盘转动幅度好判断,关键是判断车身是否直。教练员教的是两眼目视远方(100米以外)。作为学员不能很好领会运用。我们可以自己测试体会下,在空旷的地方看远处越远越好,目光看好一个点,当脑袋左右摆动就会发现,小幅摆动时远处都视线大幅度位移。旋转角度直线越长目标的都位移越大。应用到驾驶中当车子行驶中车身方向偏后,视线跟远处参考点就会大幅偏离,此时微调方向盘修正方向让视线一直正对参考点。不停都修正方向就能使车辆轨迹接近直线。
+
    int utmpfd; 
 +
    int reclen = sizeof(current_record); 
 +
 
 +
    if((utmpfd = open(UTMP_FILE,O_RDONLY)) == -1){ 
 +
        perror(UTMP_FILE); 
 +
 
 +
        return 1; 
 +
    } 
 +
 
 +
    while( read(utmpfd,&current_record,reclen) == reclen ){ 
 +
        show_info(&current_record); 
 +
    } 
 +
 
 +
    close(utmpfd); 
 +
 
 +
    return 0; 
 +
  
我当初是三个毛病 不能看得远 (看的远你才能及时发现及时修正)不能匀加速(一进直线就应该慢慢加速了因为等听到直线行驶你再加速就很容易摆动前轮)  不能轻握方向盘(我因为紧张两只手握方向盘力度不一样还是别人发现的我自己根本不知道自己走直线的状态)  我这三个毛病都是因为自己太紧张了 所以说只要不那么紧张你就能看远方手也能随意得握方向盘,看到走偏了略微动一下方向盘然后马上回过来即修即回(修的幅度不能大我们这边是3°)  有时候太把直线当回事也不好紧张到全身都僵硬了反而走坏了
+
</pre>
 +
===see also===
 +
[https://blog.csdn.net/u010307522/article/details/72862589 who命令实现]
  
  
练了许久都没找到窍门,直到最后一次教练告诉我说身体坐正靠在椅背上,我才终于跑了直线。目光放远,把车身当成一条线,与左右两边边线平行就可以。感觉车头靠近哪边就往相反方向微调点,不要大动方向。
+
===cp===
 +
<pre>
  
仅靠学员的车感保持车身的直线行驶,那肯定是要挂科的。学员可以在行驶过程中寻找合适的参照物,通过观察相对平行,来确保车身的正直。比如车身两边到路边线的距离、马路中央的分道线或者马路牙子。
+
#include        <stdio.h>//标准输入输出
 +
#include        <stdlib.h>//C标准函数库
 +
#include        <unistd.h>//Unix类系统定义符号常量
 +
#include        <fcntl.h>//定义了很多宏和open,fcntl函数原型
  
 +
#define BUFFERSIZE      4096//定义存储器容量
 +
#define COPYMODE        0644//定义复制的长度
  
我就是好奇而已,具体是怎么个考法?没有参照物还是有车线?没参照物这个我就没有太好的办法了,只能纯凭感觉了。如果有车线的话沿着车线开呗?有两个小技巧第一,你左腿的位置大概就是车轮的位置。可以用来大致判断歪没歪,离线多远。第二,没事瞟瞟左后视镜啊,你可以明显的看到车身和线是不是水平。最后就是强调了一万遍的技巧:眼睛往哪看车就往哪走。
+
void oops(char *, char *);
 +
/*注意main函数的两个参数:
 +
  argc记录了用户在运行程序的命令行中输入的参数的个数。
 +
  arg[]指向的数组中至少有一个字符指针,即arg[0].它通常指向程序中的可执行文件的文件名。 */
 +
main(int ac,char *av[])
 +
{
 +
    int in_fd, out_fd,n_chars;    //三个描述符值 in_fd为open返回的描述符 ,create out_fd为open返回的描述符  n_chars  读取的数据 function 见上个who  read的
 +
    char buf[BUFFERSIZE]; //存储器位置
 +
/*cp的参数有两个,分别是要复制的文件,和目的目录,这样一共应该是有三个操作数
 +
  所以要先检查argc的值是否为三,如果不是,返回标准错误*/
 +
        if(ac !=3) {
 +
            fprintf(stderr, "usage:%s source destination\n",* av);
 +
            exit(1);
 +
        }
 +
        /* open files 检查cp的第一个参数,要复制的文件,用open打开,in_fd为open返回的描述符 如果返回-1,代表打开失败,提示错误
 +
          why CP 第一个参数是 av[1],  av[0] 是程序中的可执行的文件名也就是自己
 +
        */
 +
        if ((in_fd=open(av[1],O_RDONLY)) == -1)
 +
            oops("Cannot open",av[1]);
  
后来我看见可以找标志物,我以分道线为标志,以雨刮器为标志(这是我多次实验得出来的雨刮器粗细分割点,对下去刚好是道路中央,靠这一招,我可以始终保持直线,而且在路中间,本来这一招开始屡试不爽,但是被教练反复提醒看远方,且车速变动会有一些判断失误之后,这招被我弃了)考试前一天晚上,我在b站看了一个视频,说是用手握方向盘时,大拇指做出平行于分道线的样子,之后第二天我仔仔细细看了一下开成功的人动作,发现了我本身的原因。我太喜欢调方向了,其实在直线行驶里,车身摆正就最好不要去调方向了。当你感觉到有左溜或者右溜的情况,调一点点,这一点点是特别小,几乎感觉不到的一点,但是能够有用,发现有抑制偏移的情况,回正即可。最后,大拇指配上微调,我虽然第一次卡在突发情况了,第二次满分过,直线行驶特别稳。。
+
/*检查cp的第二个参数,复制的目的地址,用create在目的地址创建新文件,out_fd为open返回的描述符
 +
  如果返回-1,代表创建失败,提示错误 ; create 创建的位置就是av[2] 目标文件的位置是也
 +
  为什么是 av[2]  就是 cp 命令的 第二个参数 也就是 目标文件 ,本来不存在 所以要create
 +
*/
 +
if(out_fd=creat(av[2],COPYMODE)== -1)
 +
    oops("Cannot creat",argv[2])
 +
}
 +
/*copyfiles  cp指令的动作就是读取一个文件的内容到存储器,在新的地址创建空白文件,再从存储器将内容写入新文件。
 +
  这里判断复制是否成功:
 +
  如果能读取顺利,而读取的位数和写的位数不同,是写错误;
 +
  如果读取失败,是读错误。
 +
  why n_chars 是什么
 +
  内核从utmpfd所指定的文件中读取了 reclen字节的数据,存放到 current_record所指定的内存空间中
 +
  while ( read(utmpfd, &current_record, reclen) == reclen )
  
 +
  write out_fd 文件描述符  buf 内存数据, n_chars 要写的字节数
  
 +
循环的把源文件写入目标文件
 +
*/
 +
while ((n_chars= read(int __fd,buf,BUFFERSIZE))>0) {
 +
    if(write(out_fd,buf,n_chars) != n_chars)
 +
        oops("Write error to ", av[2]);
 +
    if (n_chars== -1)
  
 +
        oops("Read error from ",argv[1]);
 +
/*这里执行的是关闭文件的动作,in_fd open的 和out_fd create的两个文件描述符
 +
  所指向的文件只要有一个关闭错误,就提示关闭错误。*/
 +
    if (close(in_fd) == -1 || close(out_fd)== -1)
 +
        oops("Error closing files","");
 +
}
  
 +
/*不太明白为什么是指针了这里 evan  这个是用来输出错误信息的函数*/
 +
void oops(char *s1, char *s2)
 +
{
 +
    fprintf(stderr, "Error:%s", s1);
 +
    perror(s2); // 用来将上一个函数发生错误的原因输出到标准设备(stderr)
 +
    exit(1)
  
 +
        }
  
一、千万记住调整椅背的角度。当你刚刚坐进驾驶室,还处在调整座椅的时候,你除了要将座椅距离调到你能够舒服地将离合器一脚踩到底,手肘微弯时手腕正好搁在方向盘顶端之外,你还要调整椅背的角度,让椅背可以在你坐直时贴着你的背并支撑住你的头。当“直线行驶”这个考试项目开始的时候:
 
二、车速一定要慢下来;
 
三、一定要往远处望;
 
四、你可以咬紧牙关、皱紧眉头,但小手臂和握方向盘的手一定要放松
 
;五、行进过程中一定要不断地左右微微地调方向盘,而且调一次就要回正一次。比如,你感觉车头往左边偏了,你就往右边微调一点,然后马上回正;反之,你感觉车头往右边偏了,你就往左边微调一点,然后马上回正;还有第三种情况,即你感觉车头是正的,你觉得此刻可以稳住不动方向盘了,错,这种时候你还是要微调方向盘,调整方法是往左(右)边微调——>回正——>往右(左)边微调——>回正。如果你感觉车头一直都是正的,那么你就一直重复上述动作,直到“直线行驶”结束。
 
我非常同意这里一位网友的话,即“直线行驶就是要你在一个长条形中像蛇一样蜿蜒前进”,而并非让你不动方向盘走所谓的直线。你也可以将“直线行驶”想象成你正驾车走在一条窄桥上,而这条窄桥的宽度就是你的车的左车轮往左再推出30厘米,右车轮往右再推出30厘米,试问在这条窄桥上你如何驾车前进?所以我认为这个考试项目具有非常现实的意义。如果你说望远你也判断不出有没有走歪,那你就买一个可以左右各调450度的游戏方向盘,下一些诸如“极品飞车”、“尘埃”这样的赛车游戏,练上3到5天即可在真实的路面上找到感觉。
 
 
</pre>
 
</pre>
  
== 看哪里==
+
 
 +
[https://www.cnblogs.com/cxy1616/p/6063463.html cp命令的编写最接受原书的了]
 +
 
 +
[https://blog.csdn.net/hejishan/article/details/2250995  Unix程序设计:实现cp命令]
 +
 
 +
[https://blog.csdn.net/XSL1990/article/details/8250039 linux自己编写的 cp 命令像os的那个了 ]
 +
 
 +
http://bbs.chinaunix.net/thread-247946-1-1.html
 +
 
 +
[https://blog.csdn.net/byxbai1989/article/details/17371197  linux cp命令源码]
 +
 
 +
=== ls===
 +
data/c/example/unixeg/ls/
 +
 
 +
 
 +
 
 +
 
 
<pre>
 
<pre>
 +
ls命令实现过程用到的函数
  
 +
函数原型:
  
看远看哪里 , 看远 车才会变小 路变大 如何发现车偏了 我发现时老是太晚了 老是方向盘控制不稳  以前这个有可能是没会背靠
+
1)int stat(const char *path, struct stat *buf);
  
1.目视前方最远处。 当然不是看风景,也不是看天,咱们飞不起来,是看路尽头看不到的地方,直线行驶路肯定是直的,专注的盯着路中间的最远处,用两眼余光自然能看到车道两边的最远处,这样就能感觉到车子跑的正不正了。
+
  stat函数 将path(文件)的属性信息保存在 buf结构体中
  
 +
2)struct passwd *getpwuid(uid_t uid);
  
 +
  getpwuid函数是通过用户的uid查找用户的passwd数据,其中包括username
  
你能感觉到你的右脚的延长线跟箭头差不多重合,这样你的车身基本就算是在车道中间行驶,不要太苛刻的去要求重合对齐,差不多就好,也可以结合以上技巧的情况下,偶尔撇一眼左右后视镜,瞄一下左右车身跟地面白线的距离,然后对应微调一下就好怎么微调方向,这个怎么说呢,你胳膊要放松,不要较劲,双手三九点握住方向盘,胳膊稍微动一点就可以让方向盘有几度的转动,车速快的话这一点转向可能就够了,车速慢的话需要更大幅度的转动养成良好的驾驶习惯,身体放松,肌肉不要紧绷,动作会更流畅自然,我考试的时候也是很紧张,科目二自己失误好几次,科目三也是,考完驾照到现在,因为自己没有车,目前为止也只开了累计不超过20小时,现在上路完全不会有紧张,只是对所在的城市不熟,不认路,心里会没底,除此之外基本上平时遇到的交通状况都可以应对,比如早高峰路况拥堵前面三车道并成两车道也能从容的打开转向灯,找到尽可能不影响后车行驶的时机插进去,再比如没有红绿灯的路口,如果有行人在等待过马路,我会挥手示意让他们先走,(表得瑟)哈哈
+
3)struct group *getgrgid(gid_t gid);
  
 +
  getgrgid函数通过用户组gid指定的组识别码逐一搜索组文件,找到时便将该组的数据以group结构返回。
  
https://www.zhihu.com/question/24708600/answer/29548878
+
4)struct tm *localtime(const time_t *timep);
  
 +
  localtime函数把从1970-1-1零点零分到当前时间系统所偏移的秒数时间转换为日历时间 。并且此函数获得的tm结构体的时间,是已经进行过时区转化为本地时间。
  
 +
5)  DIR *opendir(const char *name);
  
 +
  opendir()函数的作用是:打开目录句柄,返回一个文件描述符。
  
很多都技巧里都说需要看远,有参照物,对,道理我都懂,但是就是理解不了。后来慢慢开始领悟。看远就是你视线里这条路的最远方,但是不是看着这个点就行了,你需要在自己脑海里脑补一条线,就是路边两条白线的中间,你自己脑补出一条在直线,让你自己本人(注意不是车子中间)在这条你脑补的直线上,然后一直保持你自己在这条直线上,看的远就是你一直要看自己车子前方与最远处的点所连成的你脑补出的直线。在自己有所偏离时微微调整。
+
6)  struct dirent *readdir(DIR *dirp);
  
 +
  readdir()函数读取一个目录文件描述符的信息,将信息返回到dirent结构体中。
  
我是不明白是 人是在右边的,有人说是在人和方向盘中,有一种是说在路中间  ,以前的叶教是说右脚在路中,不过我没开好过
+
https://www.cnblogs.com/lr-ting/archive/2012/06/19/2555207.html
 +
</pre>
  
感觉自己对着中间线好些 反正不是说车一定要放在路中间线的中间 ,是吧 ,接下来是方向盘修 ,以前看太近,来不及,考试时感觉好像老是偏,不知是不是误觉 20191223
 
  
 +
====第二版本的参考 ====
 +
[https://www.cnblogs.com/ghostwu/p/8253623.html  linux系统编程:自己动手写一个ls命令 ]
  
盯着路远方的中心 是哪呢
+
https://cpp.hotexamples.com/examples/-/-/mode_to_letters/cpp-mode_to_letters-function-examples.html
  
https://www.zhihu.com/question/291084768
+
[https://www.cnblogs.com/wanghao-boke/p/11959330.html C语言实现Linux之ls]
盯着路远方的中心 是哪呢
 
  
选取参照物。目视证前远方,选取远方的摸一个点或线为参照物(或者左边车头压着左线行驶)。没有合适的参照物,车辆跑偏了却不自知。
+
[https://www.cnblogs.com/lr-ting/archive/2012/06/19/2555207.html ubuntu 编写自己的ls命令]
要学会寻找路上合适的参照物,辅助你把车辆长期保持直线行驶。例如路的中间标线、路边线、马路牙子和路边的大树。
 
  
3、往前方远处看
+
https://gitee.com/20145221/linux-besti-is-2016-2017-1-20145221/blob/master/src/week10/ls2.c
  
空间及视野过大,路边及标线上的参考会容易被弱化。要注意把视线往前方远处看,及时调回来。
 
  
车速较快,应看得远些;车速较慢,应适当看得近些;并用余光适时注意车辆周围的情况。
+
[https://blog.csdn.net/egg1996911/article/details/72235353  用c语言实现Linux命令ls操作]
  
坐在左边 所以要看远 ,不然 偏
+
[https://blog.csdn.net/zhangxb35/article/details/42222037?utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromBaidu%7Edefault-3.control&dist_request_id=1331645.10707.16183847242193639&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromBaidu%7Edefault-3.control Linux下的 ls 命令的简单实现]
  
[https://v.qq.com/x/page/q0908qud8jq.html 教你不用再直线行驶上挂科的妙招]
+
[https://www.cnblogs.com/ikaros-521/p/11254332.html 高仿linux下的ls -l命令——C语言实现]
  
  
 +
[http://www.doczj.com/doc/54bc4a27a5e9856a56126086.html 在linux下编写一个LS命令的小程序]
  
https://www.zhihu.com/question/291084768
+
[https://www.cnblogs.com/lularible/p/14386358.html  Linux系统编程【3.1】——编写ls命令 ]
  
靠着椅背 让自己看得非常远
+
[https://blog.csdn.net/lularible/article/details/113776163  Linux系统编程【3.2】——ls命令优化版和ls -l实现]
  
 +
[https://blog.nowcoder.net/n/9a48a7f697864e3bbdae2fe5bfcb0ef9 C 语言实现 Linux ls 命令]
  
不修方向盘的时候又看哪呢
+
[https://blog.csdn.net/weixin_38167363/article/details/101657613?utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-14.control&dist_request_id=1330144.34789.16182092511815325&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-14.control  Linux/UNIX编程:使用C语言实现ls命令,但不同于书的]
紧接着要立刻调节方向盘修方向,修方向盘时眼睛一定要看远一点,务必找一个远方的参照物,确保参照物在道路正中间
 
  
  
 +
https://m.linuxidc.com/Linux/2009-03/18778.htm
  
 +
====简单版本的参考 ====
 +
https://github.com/fupengfei058/ls
  
我当时模拟就是两把挂直线,总想动方向盘,老觉得走的不直。在进入直线行驶前你就把车调整好,进入之后眼睛要往远看,盯着路的末端,不要动方向盘,因为你微调的结果就是会挂
+
http://www.voidcn.com/article/p-bzocmlpx-bxd.html
  
坐直 ,看远 ,不是下看 ,
+
https://blog.csdn.net/qingshui23/article/details/53931555
https://www.zhihu.com/question/291084768
 
  
这个是为了调方舟盘用的,而一开始还是要看远的 
+
https://blog.csdn.net/aonaigayiximasi/article/details/54019964
另外讲一下在行进间如何判断车辆的位置。从仪表盘往前看,右雨刮器的节点与路面参照物的重叠处大约是车右轮距参照物25CM的距离,这个距离与驾驶员的身高有一定关系,需要自己做个测试,只是大约值哦。
 
  
[https://jingyan.baidu.com/article/19192ad8f3e72ce53e570704.html 汽车直线行驶的技巧和方法]
+
=C IDE=
  
 +
https://www.jetbrains.com/zh-cn/clion/
  
 +
[[Eclipse]]
  
转方向盘 左手为主右手为辅
+
[[Anjuta on linux]]
科目三直线行驶教练说看前面,看前面什么地方嘛
 
坐好之后,正视车道的正前方,看远点。去感觉你的车在两条白线中间行驶。用余光去看车前面的两角有没有离那一边白线太近或超出了就要赶快调。
 
  
 +
https://atom.io/
  
坐直,眼看正远前方,多余光照顾左右 两边,尽量在正前方找个点 用心感知与胸前某噗对上,一直追关正前方点前进,越看得远,车身体位置变化感知明显
+
=pre main =
 +
<pre>
 +
init main( int argc, char *argv[]);
 +
argc 是命令行参数的数目 也包括自身 没有后台的参数 那么 argc=1
  
因此,直线行驶时眼睛一定要尽量远视,至少要目视前方120米远的参照物,只要能看清楚,越远越好,不能只看眼前,也不要紧盯着两条边线
+
argv 指向参数的各个指针所构成的数组, argv[0]表示命令本身,argv[1] 表示第一个参数
  
说个小技巧,就是看准你所在车道左边那条线,保持好距离就好,不要试图找什么中线,更不要去看两边。你不可能有那么多精力的。
+
argc 是argument count的缩写表示传入main函数中的参数个数,包括这个程序本身
  
是不是左边一条边右边一条边?
+
argv 是 argument vector的缩写表示传入main函数中的参数列表,其中argv[0]表示这个程序的名字; *argv[] 其实是地址
  
这两条边向远处延伸是不是逐渐靠近、甚至汇成一点,就看那个点
+
第二个参数,char*型的argv[],为字符串数组,用来存放指向的字符串参数的指针数组,每一个元素指向一个参数。各成员含义如下:
 +
        argv[0]指向程序运行的全路径名
 +
        argv[1]指向在DOS命令行中执行程序名后的第一个字符串
  
总之就是目光要在这条路最远的地方
+
char  *argv[]是一个字符数组,其大小是int  argc,主要用于命令行参数  argv[]  参数,数组里每个元素代表一个参数;
  
跑直线的时候路上是有一条暗暗的黑线的,你就想象它是一把剑,要直直地插入你的胸口
+
看代码的时候我最先不理解的就是main函数的定义:
  
同时方向盘要左右微微摇晃,注意要微微,同时是很快速地摇晃。
+
int main(int argc, char *argv[]){}
  
注意要微微!幅度不能大!
+
经查阅得知,argc是用来表示在命令行下输入命令时的参数个数,包括指令本身;argv[]是用来取得你输入的参数。针对具体指令分析如下(每一步解释由注释形式给出)。
  
首先视线一定要远,能看多远看多远,如果实在觉得不确定,好多人都说看车盖子的左下角有没有跟道路上的线边缘重合,对于我这个喜欢偏右的人来说起了一定作用,但是还是看远是最靠谱的。其次轻微的摇我是真不会,我只能告诉自己就打方向幅度小点,看直微调就可以,有些人反而会摇偏,人要坐到路中间的感觉,直直看过去,越远越有感觉,希望能帮到你
+
由于main函数不能被其它函数调用, 因此不可能在程序内部取得实际值。那么,在何处把实参值赋予main函数的形参呢? 实际上,main函数的参数值是从操作系统命令行上获得的。当我们要运行一个可执行文件时,在DOS提示符下键入文件名,再输入实际参数即可把这些实参传送到main的形参中去。
  
技巧:自己想象一个条直线,盯着直线上的点,一定要看远,就会感觉到车子是否有偏差
+
ls1.c中的 就是这个了啦
 +
DOS提示符下命令行的一般形式为: C:\>可执行文件名 参数 参数……; 但是应该特别注意的是,main 的两个形参和命令行中的参数在位置上不是一一对应的。因为,main的形参只有二个,而命令行中的参数个数原则上未加限制。argc参数表示了命令行中参数的个数(注意:文件名本身也算一个参数),argc的值是在输入命令行时由系统按实际参数的个数自动赋予的。例如有命令行为: C:\>E6 24 BASIC dbase FORTRAN由于文件名E6 24本身也算一个参数,所以共有4个参数,因此argc取得的值为4。argv参数是字符串指针数组,其各元素值为命令行中各字符串(参数均按字符串处理)的首地址。 指针数组的长度即为参数个数。数组元素初值由系统自动赋予。其表示如图6.8所示:
  
不过我跑直线的时候没怎么摇晃,直接就看着黑线插入胸口,最多稍作调整
+
main(int argc,char *argv){
把你正常看车前方的头往上抬一点 然后目视远方 就这样开 调盘子微调 凭感觉调 这
+
while(argc-->1)
 +
printf("%s\n",*++argv);
 +
}
  
目视前方,人车合一,开出懵逼的状态,用余光感受平行
+
本例是显示命令行中输入的参数如果上例的可执行文件名为e24.exe,存放在A驱动器的盘内。
 +
因此输入的命令行为: C:\>a:e24 BASIC dBASE FORTRAN 
 +
则运行结果为:
 +
BASIC
 +
dBASE
 +
FORTRAN
 +
  该行共有4个参数,执行main时,argc的初值即为4。argv的4个元素分为4个字符串的首地址。执行while语句,每循环一次 argv值减1,当argv等于1时停止循环,共循环三次, 因此共可输出三个参数。在printf函数中,由于打印项*++argv是先加1再打印, 故第一次打印的是argv[1]所指的字符串BASIC。第二、 三次循环分别打印后二个字符串。而参数e24是文件名,不必输出。
  
当时我考的时候路中间有一条铺沥青留下的半隐藏的直线。。
+
另外一个例子
  
我问教练只要不出车道,不在车道中线上也没事吧,教练点了头。
 
  
我就让自己骑在那条线上走,然后一次过了。多找找多问问吧,很多时候科二科三的考场上一草一木甚至一条水泥缝都是考试的重点参考物。
+
</pre>
 +
[https://blog.csdn.net/zhaozhiyuan111/article/details/104050729  c语言中argc和argv[ <nowiki>]</nowiki>的作用及用法]
  
方向控制不稳
+
[https://blog.csdn.net/weixin_40539125/article/details/82585792 good和ls1.c差不多 C语言中 int main(int argc,char *argv[<nowiki>]</nowiki>)的两个参数详解]
  
身体坐直
+
https://zhuanlan.zhihu.com/p/267822985
看越远起好 
 
实线 和 虚线的中间,要找个参考物体  前方的什么东西都可以 
 
参照物在方向盘中间就可以
 
  
或者 前方目标必须与 眼睛看成一条直线 eg 马路最远处的中央
+
https://blog.csdn.net/LYJ_viviani/article/details/51873961
车头向左了 方向盘向右,车头过来后 然后再回平,微调 有调有回 手要轻
 
一感觉方向偏了就要调 ,我好像是调太多  余光瞄左右
 
  
还有是学科目二的方法  参车的什么3分之一 和线重合
+
[https://www.bilibili.com/video/av246420003/ c语言之argc和argv]
  
有人是用 两个中指顶哦 
+
=基础=
  
 +
==计算机为什么要用二进制==
 +
Everything over Binary 模拟路转换成为数字电路
  
以下几个问题是导致新手开不了直线。1、视线停留的范围太窄视距看到车头前方太短造成了车跑偏了自己还不知道。2、过于紧张导致打方向盘时幅度过大。3、开车时因为紧张,握方向盘握的太紧导致难以回正方向。
+
https://blog.csdn.net/weixin_44296862/article/details/95277924
  
往前方远处看更易开直线
+
https://blog.csdn.net/c46550/article/details/90951557
我发现很多新手在宽阔的路段上行驶时,最容易把车辆开偏。原因是空间及视野过大,路边及标线上的参考会容易被弱化。这时新手们就要注意把视线往前方远处看,这样你会更容易发现自己是否开偏,偏了可立即稍微修正,但方向盘不能大于2度。
 
  
 +
[https://wenku.baidu.com/view/77074002e009581b6ad9eb2c.html 一位全加器]
 +
=== signed char 类型的范围为 -128~127===
 +
<pre>
 +
按八位来算:
 +
在计算机里面是用补码表示的,128的二进制码是:10000000,这个东西在计算里面并不是128,因为最高位是符号,它是个负数,那么负数的原码是多少呢,我们知道如果补码的符号位为“1”,表示是一个负数,求原码的操作可以是:符号位为1,其余各位取反,然后再整个数加1。
 +
所以,10000000取反后就是11111111,把符号位去了就是01111111再加1就是10000000就是-128了。
 +
其实你看-127是10000001,这个很好理解,-128加1不就是-127
 +
[https://blog.csdn.net/zy986718042/article/details/71699079 浅谈char类型范围]
  
科目三直线行驶怎么选参照物
+
补码表示时,-0和+0补码相同都是0 000 0000,所义导致可以多表示一个负数,...这个负数是最小的那个..
 +
</pre>
 +
[https://blog.csdn.net/czg13548930186/article/details/52602279?ops_request_misc=&request_id=&biz_id=102&utm_term=%25E6%25B5%2585%25E6%259E%2590%25E4%25B8%25BA%25E4%25BB%2580%25E4%25B9%2588char%25E7%25B1%25BB%25E5%259E%258B%25E7%259A%2584%25E8%258C%2583%25E5%259B%25B4%25E6%2598%25AF%2520%25E2%2580%2594128~%2520127&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-1-52602279.pc_search_result_no_baidu_js  浅析为什么char类型的范围是 —128~+127]
  
作者:驾学导师
 
链接:https://www.zhihu.com/question/291084768/answer/550346094
 
来源:知乎
 
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
 
  
而且很多朋友坐后排的时候喜欢将头靠在靠枕上,这样的话,视线被迫平视出去,也就是说看的很远,自然就能判断车辆的行驶轨迹了。那好,我们直线行驶的第一个技巧就出来了:技巧:视线尽量平视,看得越远越好。大家仔细想想手电筒的光束吧:在光刚刚照射出来的时候,几乎就是一个点,但是随着照射距离的增加,照的越远,光圈就会越大,同理:当驾驶人的视线看的越远,那么车辆稍微有点偏移直线,就会被放的很大,驾驶人就可以提前微调方向盘,避免车子越跑越偏。难点:很多新手朋友在驾驶培训考试时,养成了视线向下看点的习惯导致上路行驶时,视线一直盯着车头前几米的地方。这是个驾驶的陋习,一定要强制性改正。可以通过主动和被动两个方面来纠正:方法:主动方面:当然是一定要强迫自己将视线平视看远,从安全驾驶角度出发,视线看的越远,驾驶人就能更早的发现前方的交通情况,如果有紧急情况发生也能提前处理,相当于加大了驾驶人安全反应距离,增长了驾驶人安全反应时间。被动方面:可以适当的将靠背向后倾斜一点角度,让头紧贴者靠枕,这样我们的视线就被迫平视,没办法向下看车头了。  第二个很重要的环节,就是我们的驾驶姿势了。双手在握方向的时候,不需要加力。因为每个人都只有一只习惯用手, 当你双手同时左右加力的话,方向肯定会向你习惯用手这边跑偏;另一种情况就是:发现方向往习惯用手偏移,一般都会故意反方向加力,那这样的话,方向又会反方向偏移。直线行驶的时候,方向一定要小动、少动、微调,甚至在确定直线的时候不动是最好的。    第三:在发现车辆没有保持直线行驶调整方向时,回方向的时机一定要把握好,很多朋友车辆一会儿靠左,一会儿靠右,就是回方向的时机没有把握好,绝大多数新手朋友都是等车头正对着道路中间才回方向,这个时候实际上已经晚了,驾驶讲究预见性,一定要比想象中回方向的时机提前一两秒。    第四:特殊情况处理:1.遇到凹凸不平路面,双手是可以加力的,但是加力的方向一定是垂直于方向盘的地方,而不是左右分别加力。2.有时候也会碰到方向机的问题,需要驾驶人注意观察,应该稍微向跑偏反方向加力。    第五:多观察,通过左右后视镜,看车身两边的距离,只要车身跟边线平行(没有夹角),车辆也是直线行驶的状态。
+
[https://wenwen.sogou.com/z/q871193299.htm?ch=fromnewwenwen.pc char 其数值表示 范围的计算]
  
找一个参照物,我是找了红绿灯,看路的尽头什么的范围太大了,而且万一考试的时候前面有车,就什么都看不到啦,所以看一些必然能看到的,比较小的东西比较好。我全程就是看着红绿灯跑完了直线,保持它在我的右眼正前方。
+
[https://www.bilibili.com/video/BV1Gt4y1D73z?from=search&seid=13506202580160943636 b站 C语言数据类型及数值范围]
  
 +
===原码 补码 反码 ===
 +
<pre>
 +
1.原码
 +
最高位表示符号位。剩下的位数,是这个数的绝对值的二进制
  
 +
就比方说 一个完整的int型变量在内存中占的是4个字节,32位的编译器中 那么这时候他的二进制表示是00000000 00000000 00000000 00000000
  
 +
所以
  
眼睛一定要看远处,我第一次就是盯着车子前面,你看的远,你自身带的感应力,能够感觉到你车子有没有偏
+
10的原码就是00000000 00000000 00000000 00001010
  
 +
那么负数的原码就是例如
  
车头某个位置对着地下的线,只要线是直的就不可能跑偏
+
-10的原码10000000 00000000 00000000 00001010
  
考试时目视着路尽头的中央
+
符号位是第一位 0为正数 1为负数
  
不然就凉了,慢慢调,等语音播报后就不要动方向盘了,行驶3~5秒后,看偏移情况适当微调,每次都是这样的其实很简单,一起练车的从没死过,他们还轻带点油门让车速快些(可能有些地方科三直线不让带油门),我也轻带油门,不然觉得这段路太长了,心里恐慌
+
2.反码
 +
    正数的反码就是其原码.
  
 +
    负数的反码就是在其原码的基础之上 符号位不变,其他位取反.
 +
   
 +
3.补码
  
视线沿着方向盘最高点看到路面正中间 看远点 不要看面前的路面 视线一直在路中间就不会偏 感觉偏了 微调方向盘 微调!!
+
    正数的补码就是其原码.
  
统报出直线行驶的指令后,不要大幅调整方向,如果车子跑歪了,及时小幅度调整方向(稍微带一点点方向车子就直了)是没有问题的,可以多次调整,但是调整幅度不能太大,直线行驶是100m还是200m来着,基本上调个一次就过了
+
    负数的补码就是在其反码的基础之上+1
 +
   
 +
</pre>
  
 +
[https://www.cnblogs.com/wangxiaoqi/p/6419676.html  C语言中的原码、反码和补码 ]
  
找个参照物,比如地上的白线,或者路牙之类,车头上找个点,开的过程中参照物和点之间的距离尽量一致,眼光远一点,方向偏了就慢慢的修方向,记住小车直行方向盘不需要大动的,适当控制车速。
+
[https://www.cnblogs.com/burningc/p/10741253.html  C语言之原码、反码和补码 ]
  
 +
[https://blog.csdn.net/liuyangsyouxiang/article/details/6050525  C语言——源码、反码、补码]
  
记得往远看。很多人都提到了往远看,但其实我一开始不明白往远看是看什么,看哪个点?到底是路中间的点还是驾驶位置平移出去的直线。后来在练习的时候发现可以找个静止的参照物,然后按照参照物走就可以。
+
[https://www.bilibili.com/video/BV1Wx411g7Jg/?spm_id_from=333.788.videocard.1 b站原码 反码 补码]
  
直线行驶对于有车感的人很简单。没有车感的人很多,新手感觉不到车正不正。最关键要找到自己开车是偏向那边,适当的往反方向去稍微偏点。动方向前要预判,在没有跑偏之前动方向。可以发现稍微有点偏,微调的时候给点油,感觉正了就不要给油了
+
=gdb=
 +
<pre>
  
首先你的车得是正着的,就是说车身和路边保持平行(当然不是绝对的,允许有细微误差,是细微!!!)然后盯着路远方的中心,然后是盯着!盯着!感觉有一条直线在你的眼睛 方向盘和你取的那个点中间!放心大胆的跑,不要受另外车道和同向行驶车的影响,我这边是要求100m所以会很快跑完(小县城双向两车道,不知道你们那边如何)教练是让我们摇车方向盘的当然是小幅度快速摇要摇匀(我看很多回答是不需要摇的看教练和地方吧亲身实践可行的!!!)这边3档车速是20到50之间都行看你们教练安排,摇不摇也看个人吧有的人不需要
 
  
  
 +
start  st 开始执行程序,在main函数的第一条语句前面停下来
 +
step      s  下一条语句,如果该语句为函数调用,则进入函数执行其中的第一条语句
 +
next    n  执行下一条语句,如果该语句为函数调用,不会进入函数内部执行(即不会一步步地调试函数内部语句)
  
教练的方法就是,学员不准看路边线,仪表盘只准用余光看。直线形式前,车子摆正,确保挡位在三档,姿势摆正,身体贴在座椅上(一是保障视角正确,二是确保踩油门时脚上有劲),语音提示直线行驶后,油门踩到底(踩快点,但是不要猛踩),眼睛正视前方(不要看路边线,千万别看,参考上面的解释,看了反而容易歪),能看多远看多远。我对看远方的理解是,直线形式的路段比较直,看到最远方,路尽头就是一个点,从这个点延时一条线,正好对上车子,这时候车子一定是正的。如果前方有遮挡,那也别看路边线,可以看前方的车子或者路中间的线,反正路边线不要看。油门踩到底后立即松开,之后刹车、油门、离合三不沾,双手轻微抖动方向盘,注意是轻微抖动,不然会盘点车子不稳,基本上油门刚放下几秒,直线形式就过掉了。然后还有一个细节,就是方向盘一定要轻轻握,实在不知道力道的话,就手指扶住就行,因为一旦握紧,方向盘会根据手的幅度变得异常灵敏,很多人也是挂在这上面的。
 
  
南墙角花园
 
  
这时候学学奥卡姆开车原则,如无必要,不做修正。
 
  
  
先从眼睛说吧,因为眼睛的问题导致了其他的问题。这是很多新手最容易出现的问题,就是,教练说看路,就真的看路面去了,视线焦点大概在车头五到十米以内,而且死盯在那里,根本不会动。视线集中在这里其实根本看不到左右,只看得到车在前进,然后不知不觉车偏了,等到两边白线都移动到焦点处了才反应过来,然后猛打方向,然后又偏了。如此反复。真正应该看的是路的远方,然后你在那里找一个参照物,再想象一条从车头延伸出去的直线,只要这条线能对准那个参照物,车就能直线行驶,而且一旦有轻微偏差,马上就能修正,修正的幅度也不需要太大,一个手指头就能搞定。
 
  
  
这个不行吧 
 
办法只有一个,眼睛往远看,不要找任何点。 跟骑自行车一个道理
 
  
  
,你可以在汽车上找一个定位点,例如引擎盖上的线或者其他的一些东西,甚至A柱的角和道路边缘线对齐,然后一直慢慢往前开,但是一定要注意,不要把车子放的太左或者太右,因为如果车子太左或者太右的话的话可能会压线直接挂科。
+
使用例子  结合他看C代码 爽到不行了
 +
184
 +
185gcc -g 11.2.c -o 11.2
 +
186gdb 11.2
 +
187
 +
188(gdb) start
 +
189(gdb) s  #一直用step命令(简写为s)进入函数中 ,n命令呢
 +
190
 +
191
 +
192step s  下一条语句,如果该语句为函数调用,则进入函数执行其中的第一条语句
 +
193next n  执行下一条语句,如果该语句为函数调用,不会进入函数内部执行(即不会一步步地调试函数内部语句)
  
先别练汽车了。
+
</pre>
捡起自行车,努力骑直线:
 
第一种,盯着自己的前轮闷头骑,看看最后是不是歪到姥姥家去了。
 
第二种,高瞻远瞩,看着前方几十米的地方骑车,看看是不是直线!
 
自行车如此,汽车也是一样的道理。
 
  
除了眼睛往远处看以外,开直线的时候你可以把左手食指中指并拢,轻轻搭在车灯控制杆上方,感受方向盘的偏移角度,进行轻微的微调,这样就既能保持直线,又能稍加微调,还不用担心幅度过大了。多练几次很快会掌握角度变化的,祝各位朋友早日拿到驾照。
+
=c=
 +
<pre>
  
说出来你可能不信,别碰方向盘,车绝对走地比你左右调整的要直
+
/*                                                                                                                                                                                         
 +
20答案是 Tuesday  因为列数定了是10                                                                                                                                                           
 +
21days[2] === days[2][10]                                                                                                                                                                   
 +
22                                                                                                                                                                                           
 +
23解说                                                                                                                                                                                       
 +
24days[2][0]=T                                                                                                                                                                               
 +
25days[2][1]=u                                                                                                                                                                               
 +
26days[2][2]=e                                                                                                                                                                               
 +
27days[2][3]=s                                                                                                                                                                               
 +
28days[2][4]=d                                                                                                                                                                               
 +
29days[2][5]=a                                                                                                                                                                               
 +
30days[2][6]=y                                                                                                                                                                               
 +
31days[2][7]=                                                                                                                                                                               
 +
32days[2][8]=                                                                                                                                                                               
 +
33days[2][9]=                                                                                                                                                                               
 +
34                                                                                                                                                                                           
 +
35               
 +
</pre>
 +
==eg ==
 +
=== 石头剪刀布===
 +
<pre>
 +
#include <stdio.h>
 +
#include <stdlib.h>
 +
#include <time.h>
  
直线行驶最重要的是看远方,尽量看远点。然后进入直线的检测区间之前先把车子走正,这点很关键! 在报请直线行驶之前就把车子调正,速度控制好。 在我这里直线有速度要求,所以第二点就是油门慢踩,速度提的太快容易紧张方向就把不稳。第三点手要轻! 把方向盘比做表盘的话,你的幅度不要超过十一点五十八和十二点零二这个区间。车子歪了别怕,轻点动,多动几下车子就回来了。
+
int main(void)
 +
{
 +
char gesture[3][10] = { "scissor", "stone", "cloth" };
 +
int man, computer, result, ret;
  
 +
srand(time(NULL));
 +
while (1) {
 +
computer = rand() % 3;
 +
  printf("\nInput your gesture (0-scissor 1-stone 2-cloth):\n");
 +
ret = scanf("%d", &man);
 +
  if (ret != 1 || man < 0 || man > 2) {
 +
printf("Invalid input! Please input 0, 1 or 2.\n");
 +
continue;
 +
}
 +
printf("Your gesture: %s\tComputer's gesture: %s\n",
 +
gesture[man], gesture[computer]);
  
如何回方向盘
+
result = (man - computer + 4) % 3 - 1;
母指贴在内侧 ,上 辈直
+
if (result > 0)
 +
printf("You win!\n");
 +
else if (result == 0)
 +
printf("Draw!\n");
 +
else
 +
printf("You lose!\n");
 +
}
 +
return 0;
 +
}
  
[https://www.bilibili.com/video/av19149232 科目三直线行驶]
 
  
 +
/*
 +
0、1、2三个整数分别是剪刀石头布在程序中的内部表示,用户也要求输入0、1或2,然后和计算机随机生成的0、1或2比胜负。这个程序的主体是一个死循环,需要按Ctrl-C退出程序。以往我们写的程序都只有打印输出,在这个程序中我们第一次碰到处理用户输入的情况。在这里只是简单解释一下,以后再细讲。scanf("%d", &man)这个调用的功能是等待用户输入一个整数并回车,这个整数会被scanf函数保存在man这个整型变量里。如果用户输入合法(输入的确实是整数而不是字符串),则scanf函数返回1,表示成功读入一个数据。但即使用户输入的是整数,我们还需要进一步检查是不是在0~2的范围内,写程序时对用户输入要格外小心,用户有可能输入任何数据,他才不管游戏规则是什么。
  
当快接近目标时,慢慢回正,以减缓视线靠近目标的趋势,否则,视线将越过目标,反方向偏离
+
和printf类似,scanf也可以用%c、%f、%s等转换说明。如果在传给scanf的第一个参数中用%d、%f或%c表示读入一个整数、浮点数或字符,则第二个参数的形式应该是&运算符加一个相应类型的变量名,表示读进来的数存到这个变量中;如果在第一个参数中用%s读入一个字符串,则第二个参数应该是数组名,数组名前面不加&,因为数组类型做右值时自动转换成指针类型,而scanf后面这个参数要的就是指针类型,在第 10 章 gdb有scanf读入字符串的例子。&运算符的作用也是得到一个指针类型,这个运算符以后再详细解释。
  
 +
留给读者的思考问题是:(man - computer + 4) % 3 - 1这个神奇的表达式是如何比较出0、1、2这三个数字在“剪刀石头布”意义上的大小的
 +
*/
  
修‘正’方向,首先,要有的放矢,使视线向目标慢慢靠近,当感觉将要对‘正’时,提前缓缓回方向,减缓视线靠近目标的趋势,并感觉,视线靠近越来慢,方向回‘正’越来越缓,直至方向停止,当方向停止时,视线恰好对正目标为最善,------再就是修‘正’时的用力,应以能推动方向盘为佳,稍稍大于方向盘的抵抗力即可,微调方向,只须有力的施加,不必有方向盘的转动,回‘正’时,将施加的力缓缓消除即可所以,握盘要轻,才能感受到修正的力,直线行驶途中,感觉方向盘因路面影响,产生的力的变化[即方向盘的抖动],此时,手上用相同的力与之相抗即可,以保持方向稳定 注:可以骑自行车或摩托在公路上练习“看正”,并通过控制方向体会怎么“正车”。这样练习及安全又能使自己快速掌握直线行驶的感觉。
 
 
</pre>
 
</pre>
[https://wenku.baidu.com/view/7f0803fc168884868762d693.html 解析直线行驶]
 
  
 +
[https://wenku.baidu.com/view/55e520da5022aaea998f0f5e.html 石头剪刀布_C语言]
  
[https://wenku.baidu.com/view/d5ae45e2c77da26925c5b0c3.html 新路考_科目三_直线行驶_详解]
+
https://blog.csdn.net/guoqingchun/article/details/8104197
  
  
 +
===Linux下C语言获取目录中的文件列表 ===
 +
<pre>
 +
/*
 +
* dir.c
 +
*
 +
Linux下C语言获取目录中的文件列表  https://www.cnblogs.com/dgwblog/p/12158373.html
 +
http://c.biancheng.net/cpp/html/1548.html  怎样使用C语言列出某个目录下的文件?
 +
*  Created on: 2020年11月2日
 +
*      Author: evan
 +
*/
 +
#include <sys/types.h>
 +
#include <dirent.h>
 +
#include <unistd.h>
 +
#include <stdio.h>
 +
int main(){
 +
DIR *dir;
 +
struct  dirent *ptr;
 +
dir = opendir("/home/evan/t1/");
 +
while((ptr = readdir(dir)) != NULL)
 +
printf("d_name:%s\n",ptr->d_name);
 +
closedir(dir);
 +
return 0;
 +
}
 +
 +
 +
/* 结果
 +
*
 +
d_name:.
 +
d_name:..
 +
d_name:1.py
 +
d_name:22.py
 +
 +
*/
 +
 +
 +
</pre>
 +
 +
=排序与查找=
 +
==插入排序 ==
 +
<pre>
 +
#include <stdio.h>
 +
#define LEN 5
 +
int a[LEN] = { 10, 5, 2, 4, 7 };
 +
void insertion_sort(void)
 +
{
 +
int i, j, key;
 +
for (j = 1; j < LEN; ++j) {
 +
printf("%d, %d, %d, %d, %d\n",
 +
      a[0], a[1], a[2], a[3], a[4]);
 +
key = a[j];  //key 标记为未排序的第一个元素
 +
i = j - 1;
 +
                // key  与已排序元素从大到小比较,寻找key应插入的元素 a[i+1]一般就是key 起初的值
 +
////采用顺序查找方式找到插入的位置,在查找的同时,将数组中的元素进行后移操作,给插入元素腾出空间 ?
  
 +
while (i >= 0 && a[i] > key) {
 +
a[i+1] = a[i];
 +
--i; //跳出while
 +
}
 +
a[i+1] = key; ////插入到正确位置
 +
}
 +
printf("%d, %d, %d, %d, %d\n",
 +
      a[0], a[1], a[2], a[3], a[4]);
 +
}
 +
int main(void)
 +
{
 +
insertion_sort();
 +
return 0;
 +
}
 +
/* 就是key 一直和前面排好的比,找到正确的位置
 +
10, 5, 2, 4, 7
 +
5, 10, 2, 4, 7
 +
2, 5, 10, 4, 7
 +
2, 4, 5, 10, 7
 +
2, 4, 5, 7, 10 */
 +
</pre>
  
  
 +
===算法的时间复杂度分析===
 +
则总的执行时间粗略估计是(n-1)*(c1+c2+c5+m*(c3+c4))。 #怎么来的呢  线性函数  不记得了 要补一下
  
 +
[https://blog.csdn.net/qq_25775935/article/details/88724130 插入排序算法及C语言实现]
  
  
 +
==11.4 归并排序==
 +
递归实现 归并排序
  
  
[https://v.youku.com/v_show/id_XMzc4MzIxMjE1Ng==.html?spm=a2h0k.11417342.soresults.dtitle 直线]
 
  
[https://www.zhihu.com/question/291084768 今天科三挂在直线行驶,应该怎么保持直线]
 
  
 +
===see also===
  
2019 me
 
  
科目三 头不要歪  两线之间找个参照物  找哪个呢    100M 只有 8S哦 时间
+
还有下一节 ?
  
 +
[https://www.bilibili.com/video/av73101599?from=search&seid=6748303640916868853 4-5 通过归并排序算法深入理解递归]
  
直线行驶就是要你在一个长条形中像蛇一样蜿蜒前进
 
千万记住调整椅背的角度。
 
  
到以上两点后,等开始这个科目,身体和头靠紧座椅,目视前方,握好方向盘,用身体感觉车辆出现水平位移后,(貌似水平
+
非递归
 +
https://blog.csdn.net/zjy900507/article/details/80530336
  
当你刚刚坐进驾驶室,还处在调整座椅的时候,你除了要将座椅距离调到你能够舒服地将离合器一脚踩到底 并有一定的弯曲哦,不然放离合就不好了,手肘微弯时手腕正好搁在方向盘顶端之外,你还要调整椅背的角度,让椅背可以在你坐直时贴着你的背并支撑住你的头。
+
=chapter 12 栈与队列=
 +
==堆栈==
 +
http://docs.linuxtone.org/ebooks/C&CPP/c/ch12s02.html
 +
==3. 深度优先搜索 ==
 +
未看
 +
http://akaedu.github.io/book/ch12s03.html
  
也有一个走直线的小方法,就是把前风窗左下角对准左边的白线走也可以,边走边瞄一下,随时调整方向。不过就考试用用就好,以后真的要开车,这样子肯定是不
 
  
直到最后一次教练告诉我说身体坐正靠在椅背上,我才终于跑了直线。目光放远,把车身当成一条线,与左右两边边线平行就可以。感觉车头靠近哪边就往相反方向微调点,不要大动方向。
+
=第 13 章 计算机中数的表示=
=== 一定要看得远  哪个是中间线===
+
==1. 为什么计算机用二进制计数==
  
而且还是要求看远一点,你能感觉到你的右脚的延长线跟箭头差不多重合,这样你的车身基本就算是在车道中间行驶,不要太苛刻的去要求重合对齐,差不多就好,
+
=第 14 章 计算机中数的表示=
  
也可以结合以上技巧的情况下,偶尔撇一眼左右后视镜,瞄一下左右车身跟地面白线的距离,然后对应微调一下就好怎么微调方向,这个怎么说呢,你胳膊要放松,不要较劲,双手三九点握住方向盘,胳膊稍微动一点就可以让方向盘有几度的转动,车速快的话这一点转向可能就够了,车速慢的话需要更大幅度的转动养成良好的驾驶习惯,身体放松,肌肉不要紧绷,动作会更流畅自然,我考试的时候也是很紧张
+
[http://c.biancheng.net/cpp/html/437.html c语言基本数据类型short、int、long、char、float、double]
  
,保持一定的速速,如果前面有车,就看前面的车开,如果没有车,就看自己行使的道路上的两条路边线,往前面看,保证您的方向盘在您视线100到150米处是在两条路边线正中间的就肯定可以走直线。 教练原话是只要您能保证方向盘在路的正中间,走的就肯定是直线。
+
[https://www.cnblogs.com/luofay/p/6070613.html  C语言的基本数据类型 ]
  
链接:https://www.zhihu.com/question/24708600/answer/29548878
 
  
==修方向盘==
+
[https://www.php.cn/csharp-article-443107.html c语言char是什么意思]
 +
== 二进制制转十进制==
 
<pre>
 
<pre>
虚握方向盘 夹一下胳膊 因为我老是 左偏,所以是右胳膊
+
  在 C 语言中, signed char 类型的范围为 -128~127,每本教科书上也这么写,但是没有哪一本书上(包括老师)也不会给你为什么是 -128~127,这个问题貌似看起来也很简单容易, 以至于不用去思考为什么,不是有一个整型范围的公式吗:  -2^(n-1)~2^(n-1)-1 (n为整型的内存占用位数),所以 int 类型 32 位那么就是 -(2^31) ~ 2^31-1 即 -2147483648~2147483647,但是为什么最小负数绝对值总比最大正数多 1 ,这个问题甚至有的工作几年的程序员都模棱两可,因为没有深入思考过,只知道书上这么写。于是,我不得不深入思考一下这个被许多人忽视的问题。
在微调方向盘更好把握(务必调一点就要打回点)可微调一两度,但要马上打回,如果感觉还偏,可以多次微调多次打回,千万别一次大角度调整 我以前应该是没有打回哦
 
比如,你感觉车头往左边偏了,你就往右边微调一点,然后马上回正;
 
</pre>
 
:一感觉有点歪了马上就修!马上就修!不要等明显了才修!修了就把方向回正,再歪了就再修,不要一直光顾着修方向不回正,一直朝一边修方向也是会死的!!就算你的运动轨迹像下图是波浪的也不会死,因为你修正了的!!
 
  
第一:看远处。能看多远看多远。越远走的越直。第二:留出足够的距离来加速,反正我是在路口等到直线行驶没车的时候才调头上直线行驶的。第三:方向盘可以微动,左右10°以内,大概就是1个指头的宽度。第四:提前预调方向,跟第一条对应的,看得远,预调方向就早,方向盘自然动的小。PS:在进入直线行驶前就调整好方向,直线行驶中基本上方向盘不用动了。
+
对于无符号整数,很简单,全部位都表示数值,比如 char 型,8位,用二进制表示为 0000 0000 ~ 1111 1111,1111 1111 最大即为十进制255,所以 unsigned char 的范围为 0~ 255,在这里普及一下 2 进制转十进制的方法, 二进制每一位的数值乘以它的位权(2^(n-1),n为自右向左的位),再相加,可得到十进制数,比如 :1111 1111 = 1*2^7 + 1*2^6 + 1*2^5 + 1*2^4 + 1*2^3 + 1*2^2 + 1*2^1 + 1*2^0 = 255 。
  
别紧张的死抓方向盘,5个指根挨着方向盘大拇指控制就可以,手掌不要死死握着方向盘,越放松越好呀
 
  
链接:https://www.zhihu.com/question/24708600/answer/49581530
+
但是对于有符号整数,二进制的最高位表示正负,不表示数值,最高位为 0 时表示正数,为 1 时表示负数,这样一来,能表示数值的就剩下( n-1 )位了,
 +
比如 char a = -1;  那么二进制表示就为 1 0000001,1 表示为 0 0000001,所以 signed char 型除去符号位剩下的 7 位最大为 1111 111 = 127,再把符号加上,0 1111111 = 127,1 1111111 = -127,范围应该为 -127~127 ,同理 int 类型也一样,但是问题出来了,教科书上是 -128~127 啊,下面就剖析一下这个惊人的奇葩。 加上反码 看到这里
  
  
上臂轻轻贴住自己的身体。保持方向盘平衡。端平方向,在进入直线之前,对准方向,进入这个方向之前一定不要多分的多动方向,轻轻的推方向再推回来,不然你越晃越大,看准前面小镜子和边线的位置,保持这个姿势,进入直线。进入直线后余光过5秒看下前面的小镜子和边线的距离,其余时间看远,感觉那边大,你手稍稍握紧这边的方向,车身就会微调,这个微调是规则内的。一定要放松托住方向,不要迷行自己那个5度,控制不好,加速后越来越大的
+
再普及一下计算机内部整数存储形式,大家都知道计算机内部是以二进制来存贮数值的,无符号整数会用全部为来存储,有符号的整数,最高位当做符号位 ,其余为表示数值。
 +
</pre>
  
作者:驾学导师 2020
+
=第 17 章=
链接:https://www.zhihu.com/question/291084768/answer/550346094
+
==3. 设备==
来源:知乎
+
http://akaedu.github.io/book/ch17s03.html
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
 
  
那好,我们直线行驶的第一个技巧就出来了:技巧:视线尽量平视,看得越远越好。大家仔细想想手电筒的光束吧:在光刚刚照射出来的时候,几乎就是一个点,但是随着照射距离的增加,照的越远,光圈就会越大,同理:当驾驶人的视线看的越远,那么车辆稍微有点偏移直线,就会被放的很大,驾驶人就可以提前微调方向盘,避免车子越跑越偏。难点:很多新手朋友在驾驶培训考试时,养成了视线向下看点的习惯导致上路行驶时,视线一直盯着车头前几米的地方。这是个驾驶的陋习,一定要强制性改正。可以通过主动和被动两个方面来纠正:方法:主动方面:当然是一定要强迫自己将视线平视看远,从安全驾驶角度出发,视线看的越远,驾驶人就能更早的发现前方的交通情况,如果有紧急情况发生也能提前处理,相当于加大了驾驶人安全反应距离,增长了驾驶人安全反应时间。被动方面:可以适当的将靠背向后倾斜一点角度,让头紧贴者靠枕,这样我们的视线就被迫平视,没办法向下看车头了。 第二个很重要的环节,就是我们的驾驶姿势了。双手在握方向的时候,不需要加力。因为每个人都只有一只习惯用手, 当你双手同时左右加力的话,方向肯定会向你习惯用手这边跑偏;另一种情况就是:发现方向往习惯用手偏移,一般都会故意反方向加力,那这样的话,方向又会反方向偏移。直线行驶的时候,方向一定要小动、少动、微调,甚至在确定直线的时候不动是最好的。    第三:在发现车辆没有保持直线行驶调整方向时,回方向的时机一定要把握好,很多朋友车辆一会儿靠左,一会儿靠右,就是回方向的时机没有把握好,绝大多数新手朋友都是等车头正对着道路中间才回方向,这个时候实际上已经晚了,驾驶讲究预见性,一定要比想象中回方向的时机提前一两秒。    第四:特殊情况处理:1.遇到凹凸不平路面,双手是可以加力的,但是加力的方向一定是垂直于方向盘的地方,而不是左右分别加力。2.有时候也会碰到方向机的问题,需要驾驶人注意观察,应该稍微向跑偏反方向加力。    第五:多观察,通过左右后视镜,看车身两边的距离,只要车身跟边线平行(没有夹角),车辆也是直线行驶的状态。    第六:以上环节都掌握了,但仍然还走不了直线,可以通过车身找参照物(此方法不推荐,仅做应付考试可以)。以左车头或者是挡风玻璃左下角作为固定参照点,去对准道路左侧的分界线,只要参照点不离开分界线,车辆就是直线行驶的状态。
+
=4. MMU=
 +
  按照离CPU由近到远的顺序依次是CPU寄存器、Cache、内存、硬盘,越靠近CPU的存储器容量越小但访问速度越快
 +
http://akaedu.github.io/book/ch17s04.html
  
一个手握着方向盘,另一个轻轻悬空握方向盘。可以试试握在表盘的8点和4点方向,这样更稳一些。然后放松看着前方开,反正我是这样握了以后,就有方向感了,一般我都是左手握着方向盘,右手悬空,如果感觉不太稳,左手轻微动一下然后回过来。右手不用摸到方向盘。有那种操控车的感觉了,而且也不用死命瞪着前方,我以前都瞪的出神了,眼泪都快流出来了,也不敢合眼。一直找不到办法的可以试一下。说不定就像我一样突然找到办法了。还有一点用来调正方向,就是变到后,用前方大玻璃的左下角压着中间黄线跑,就是在路中间的状态,也可以用来校对车有没有跑偏。
+
=Memory Hierarchy=
 +
http://akaedu.github.io/book/ch17s05.html
  
 +
=附录 A. 字符编码=
 +
20191112
 +
字符编码的高位 左边是也
  
诀窍是方向盘打一颗米的距离(因为路不平或者进入时没摆正车身,势必在路上会开斜,所以必须打方向盘调整),然后停顿三秒以上,不是车停,是方向盘停,车身如果还没正,就再打一颗米,不是回方向盘,是打方向盘,记住每次打方向盘一定要停顿三秒以上,那么红外线就不会叫,毕竟直线只有几百米,很快就可以过去了。并且只要车身没有超过一半在其他道,稍微歪一点压线,红外线是不会叫的,就看你的考官踩不睬刹车了。总之坚持半分钟,
+
=如何学习c=
  
 +
== mongoose 开源http库==
 +
有空学习这个作为C的入门例子
  
 +
Mongoose是一个用C编写的网络库。它为客户端和服务器模式实现TCP,UDP,HTTP,WebSocket,CoAP,MQTT的事件驱动的非阻塞API。
 +
[https://www.cnblogs.com/gardenofhu/p/6961343.html  mongoose 开源http库 ]
  
 +
[https://www.cnblogs.com/lifan3a/articles/7478295.html  Mongoose 利用实现HTTP服务 ]
 +
=funciton=
 +
== ==
 +
<pre>
 +
时间搞定
 +
头文件:#include <time.h>
  
想象出一条道,这条道是你的头和方向盘两点成一线而形成的30cm宽的小道。在你方向盘摆正后,自动想出这条道。千万不要看路道两边的边线,你以它为行驶标线,你的车也会不自觉的往这个方向偏,也就是不能保持直线行驶状态,不及格。
+
定义函数:char *ctime(const time_t *timep);
  
 +
函数说明:ctime()将参数timep 所指的time_t 结构中的信息转换成真实世界所使用的时间日期表示方法,然后将结果以字符串形态返回。此函数已经由时区转换成当地时间,字符串格式为"Wed Jun 30 21 :49 :08 1993\n"。
  
四直线行驶时,双手放松,尽量往远处看
+
注意:若再调用相关的时间日期函数,此字符串可能会被破坏。
  
头别歪 这是林教练发现我的错误
+
https://www.runoob.com/cprogramming/c-function-ctime.html
加油稳稳的匀加上去
+
</pre>
 +
==strcmp  ==
 +
<pre>
 +
C/C++函数,比较两个字符串
  
有的考生容易在跑直线时动方向盘,如果这样挂掉未免太可惜了。技巧:在听到语音提示直线行驶时,有几秒的时间供你调整车身,不要慌。打方向盘,把车身调正,加油,眼睛往道路远处看,手呢?这个时候,车处于加速过程中,你的双手大拇指只要轻轻的搭在方向盘上即可。我刚学车的时候,也容易动方向盘,教练说,你双手放开试试,我松开双手,车子照样直线往前走。所以在跑直线时,双手不要对方向盘施力。可能有人会问,如果车跑偏了怎么办?哪怕是跑偏了,也不要去动方向盘,因为这个时候直线行驶快结束了,车子压点虚线没关系,电脑只会判断你动没动方向盘。待结束后,再调整回来就行。
+
strcmp函数是string compare(字符串比较)的缩写,用于比较两个字符串并根据比较结果返回整数
  
 +
设这两个字符串为str1,str2,
  
一点也不用调的,教练也不行。1.目视前方最远处。 当然不是看风景,也不是看天,咱们飞不起来,是看路尽头看不到的地方,直线行驶路肯定是直的,专注的盯着路中间的最远处,用两眼余光自然能看到车道两边的最远处,这样就能感觉到车子跑的正不正了。2.微调方向。虽然说只有两度,但千万别不敢调,直线时候手一定不能握着方向盘,就轻微的扶在上面,感觉偏了,轻轻一碰,方向盘自然回正,然后在接下来的两三秒里,方向就慢慢回正了,看着又偏了,再轻微一碰,用我们教练的话说,像搀扶老人一样就行了。切忌来回动方向,方向盘来回摆动,只能说明你打的太多了,跟玩龙一样,也是教练说的。3.早发现早处理。这是对方向感与调方向盘能力的双重要求,十分重要。如果你看前方不够专注,跑了快一半才发现方向偏了,那时候再调就晚了。早发现,及时调方向太大,还是可以往回慢慢调的,所以这一点十分重要。4.感觉车速。这是为了避免你跑直线时候低头看转速表所需要锻炼的能力,低头看速度,必偏,方向是要全程专心感受的,速度就需要凭感觉来控制,这是需要多多练习与感受的。切忌一看直线跑的很直,想早点结束,脚上没数了,一直加到五十,那也挂了。
+
若str1==str2,则返回零;
  
 +
若str1<str2,则返回负数;
  
链接:https://www.zhihu.com/question/24708600/answer/114570688
+
若str1>str2,则返回正数。
 +
</pre>
 +
[https://baike.baidu.com/item/strcmp/5495571 strcmp]
  
 +
https://baike.so.com/doc/61175-64376.html
  
 +
==C library function - remove()==
 
<pre>
 
<pre>
朋友的建议
+
/*
 +
* remvoe.c
 +
*
 +
*  Created on: 2020年11月30日
 +
*      Author: evan
 +
*/
 +
#include <stdio.h>
 +
#include<string.h>
  
看远、车偏了,你就一点点就好了  其实直线的时候车偏一点没事,主要是你的手动方向盘不要过大
+
int main() {
你掉头过来时候你把车正人正看远了你不要动方向盘过大它不会去压线的
+
int ret;
你放松你感觉偏了一点你不管它,但是你一定要看远
+
FILE *fp;
 +
char filename[] = "file.txt";  // 这个是什么意思  定义一个 数组 ? 是的 
  
直线行驶前,应把方向调正,调到车道线的中间
+
fp = fopen(filename,"w");
  
3. 直线行驶时,眼睛一定要看着前方,看远顾近,注意两旁。
+
fprintf(fp,"%s", "THis is tutor \n");
 +
fprintf(fp,"%s", "ln2 THis is tutor");
 +
fclose(fp);
  
正确操纵方向盘,以左手为主,右手为辅,一手拉动,一手推送,配合紧密。
+
//ret = remove(filename);
 +
/*
 +
cat file.txt
 +
THis is tutor*/
  
控制好方向盘,使车辆保持直线运动状态。
+
if(ret == 0) {
 +
printf("file deleted successfully");
 +
}else {
 +
printf("Error: unable to delte the file");
 +
}
 +
return(0);
 +
 
 +
}
  
换挡时,不要低头看档。
 
  
 
</pre>
 
</pre>
  
 +
== C语言perror函数的作用 ==
 +
<pre>
 +
 不可以掉了这个头文件,perror是包含在这个文件里的//编辑本段perror表头文件完善版定义函数
 +
  void perror(const char *s); perror ("open_port");
 +
函数说明
 +
  perror ( )用 来 将 上 一 个 函 数 发 生 错 误 的 原 因 输 出 到 标 准 设备 (stderr) 。参数 s 所指的字符串会先打印出,后面再加上错误原因字符串。此错误原因依照全局变量errno 的值来决定要输出的字符串。   在库函数中有个errno变量,每个errno值对应着以字符串表示的错误类型。当你调用"某些"函数出错时,该函数已经重新设置了errno的值。perror函数只是将你输入的一些信息和现在的errno所对应的错误一起输出。
  
[https://v.youku.com/v_show/id_XMzY0Nzc1OTIwOA==.html?spm=a2h0j.11185381.listitem_page1.5~A 展贸南路video]
+
void perror(const char *str)
  
==直线视频==
+
参数
  
[https://v.youku.com/v_show/id_XMzI4NzE3NjAxNg==.html?spm=a2h0k.11417342.soresults.dtitle 科目三直线行驶很多学员挂科了, 资深教练教你实用操作技巧一把过]
+
    str -- 这是 C 字符串,包含了一个自定义消息,将显示在原本的错误消息之前
  
 +
#include <stdio.h>   
 +
int main(void)   
 +
{   
 +
FILE *fp ;   
 +
fp = fopen( "/root/noexitfile", "r+" );   
 +
if ( NULL == fp )  ?
 +
{   
 +
perror("/root/noexitfile");   //下面有这个输出
 +
}   
 +
return 0;   
 +
}
  
[https://v.youku.com/v_show/id_XNDMxMDIzMTIyMA==.html?spm=a2h0k.11417342.soresults.dtitle 科目三直线行驶技巧,做好这4点不跑偏]
+
运行结果
 +
[root@localhost io]# gcc perror.c   
 +
[root@localhost io]# ./a.out   
 +
/root/noexitfile: No such file or directory
  
https://v.youku.com/v_show/id_XNDQ3NDY0NTk3Ng==.html?spm=a2h0j.11185381.listitem_page1.5!4~A
+
</pre>
  
[https://v.youku.com/v_show/id_XMzY2MTcwNjQzMg==.html?spm=a2h0k.11417342.soresults.dtitle 科目三直线行驶不跑偏, 教练教你简单小技巧]
 
  
[https://www.cnblogs.com/zhoading/p/9345557.html 科目三直线行驶怎么才能不跑偏?看完你就明白]
 
  
=档位=
+
[https://blog.csdn.net/ypist/article/details/7886209  linux下 C语言perror函数的作用]
  
 +
https://www.cnblogs.com/yujianfei/p/8973867.html
  
[https://www.bilibili.com/video/av18016223/?spm_id_from=333.788.videocard.1 科目三档位操作]
+
https://www.runoob.com/cprogramming/c-function-perror.html
=消除紧张=
 
  
3.线路图要烂熟于心。上路之后心里要有底:前方是什么路段,系统会给出怎样的指令,不要大脑一片空白,掌控这辆车,成功完成整个考试的几率也会提高。4.一定一定要沉住气!!!(三个感叹号,还加粗了,足以说明这点有多重要了吧?)快到终点的时候不要急高兴,觉得自己好像已经过了一样,直到听到语音播报:“考试合格,考试结束。”这句话之后你才能松下这口气,还没听到,就把这口气憋着吧。太多人在要完成考试的时候因为各种差错挂掉了,不觉得非常可惜吗?只要再稳住那么十几秒,你就不用重来,不用挂掉,不用再漫长的等待了。科三不算是什么大考,但挂了确实让人糟心,不要太小看他。注意力集中,尽力了,结果一般不会太差的。
 
  
[https://www.zhihu.com/question/28532158 明天第三次考科目三,如何克服焦虑与紧张]
+
==c语言实现rm命令 or 删除==
 +
<pre>
 +
头文件:#include <stdio.h>
  
[http://news.jsyks.com/n_e8fcaa 科目三完过]
+
remove()函数用于删除指定的文件,其原型如下:
 +
    int remove(char * filename);
  
[https://zhidao.baidu.com/question/1900243809986202300.html 科目三路考时如何才不紧张]
+
【参数】filename为要删除的文件名,可以为一目录。如果参数filename 为一文件,则调用unlink()处理;若参数filename 为一目录,则调用rmdir()来处理。
  
https://wenku.baidu.com/view/78e14e9d650e52ea54189820.html
+
【返回值】成功则返回0,失败则返回-1,错误原因存于errno。
 +
</pre>
  
[https://wenku.baidu.com/view/c568e88a3186bceb18e8bb0f.html 广州驾考科目四考试技巧]
+
[https://blog.csdn.net/teleger/article/details/80537229?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.pc_relevant_is_cache&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.pc_relevant_is_cache  C语言remove()函数:删除文件或目录]
  
=see also=
+
[https://blog.csdn.net/piaoliangjinjin/article/details/80707139?utm_medium=distribute.pc_relevant.none-task-blog-title-7&spm=1001.2101.3001.4242  linux下实现rm()函数删除文件或目录]
  
 +
[https://blog.csdn.net/qq_38074673/article/details/98047329  c语言实现rm命令,删除指定文件或目录]
  
[https://v.youku.com/v_show/id_XODYwMTIzMTY0.html?spm=a2hzp.8253876.0.0&f=23283010 考驾照学开车高手之路]
+
==C语言access()函数:判断是否具有存取文件的权限==
  
  
[https://jingyan.baidu.com/article/9c69d48ffa923a13c9024e86.html 广州科目三考试经验分享2017]
+
[http://c.biancheng.net/cpp/html/303.html C语言access()函数:判断是否具有存取文件的权限]
  
 +
[https://blog.csdn.net/eager7/article/details/8131169  C语言中access函数]
  
[https://zhuanlan.zhihu.com/p/48331159 广州科目三展贸路(东&南)总结]
+
[https://www.runoob.com/cprogramming/c-arrays.html C 数组]
  
  
[https://zhuanlan.zhihu.com/p/38334450 2018年广州科目三番禺展贸东路最新考试技巧]
+
=进阶=
 +
==十个经典的C开源项目代码==
 +
[https://blog.51cto.com/chinalx1/2143904 十个经典的C开源项目代码]
  
[https://www.jianshu.com/p/56f5a957955f 驾考科目三广州展贸东路流程分享]
 
  
[https://www.jianshu.com/p/61c7d1ddd024?utm_campaign=maleskine&utm_content=note&utm_medium=seo_notes&utm_source=recommendation 广州市驾考科目三经验总结---广汕路]
+
=2021=
  
[https://v.qq.com/x/page/i0327pyii6u.html 广州化龙展贸东路科目三路考合格视频]
 
  
 +
[https://www.cnblogs.com/wucongzhou/p/12498740.html#%E4%B8%80%E3%80%81%E8%8E%B7%E5%8F%96%E5%BD%93%E5%89%8D%E5%B7%A5%E4%BD%9C%E7%9B%AE%E5%BD%95 C语言目录操作]
  
[https://wenku.baidu.com/view/68213d55e55c3b3567ec102de2bd960590c6d93f.html 2017年8月广州展贸南科目三满分通过心得+路线+自绘图]
+
[http://www.freecplus.net C语言技术网]
  
 +
[https://www.cnblogs.com/qigaohua/p/5838263.html      博客园  C语言中关于对目录的操作 ]
  
 +
=书=
 +
[https://www.codetd.com/article/2162329 《Linux环境C程序设计(第2版)徐诚》pdf 附下载链接]
  
[https://www.pcauto.com.cn/xueche/kmsan/ 太平洋汽车网 >  科目三]
+
http://www.txtepub.com/105693.html
  
[https://www.jianshu.com/p/53d3bc91da34 科目三考试技巧最全攻略详解]
+
=see also=
 +
[https://wiki.ubuntu.com.cn/C%E8%AF%AD%E8%A8%80%E7%AE%80%E8%A6%81%E8%AF%AD%E6%B3%95%E6%8C%87%E5%8D%97 C语言简要语法指南]
  
[http://www.jiakaobaodian.com/news/detail/966545.html 科目三考试内容及合格标准、流程、考试技巧口诀、视频、注意事项]
+
https://wiki.ubuntu.com.cn/Compiling_C
  
[https://www.zhihu.com/question/21037459 驾照科目三考试通过需要注意什么]
+
[https://wiki.ubuntu.com.cn/Gcchowto Gcc-howto]
  
 +
=c++=
  
 +
[https://zh.wikipedia.org/wiki/C%2B%2B c++ zh.wikipedia.org]
  
[[category:生活与情感]]
+
https://isocpp.org/
 +
[[category:c]]

2021年4月16日 (五) 03:30的版本



good http://akaedu.github.io/book/


C语言编程学习必备的一些网站,干货收藏!

带你学C带你飞》

如何学习C

学习C语言,如何看懂及掌握一个程序

2021学习C APUE

http://www.apuebook.com/

UNIX环境高级编程(书籍)笔记什么都 有呀

《UNIX环境高级编程》这本书怎么看?怎么学习


看法

第二章和第六章可以跳跳,回头看

7.中文版翻译有瑕疵,但是整体还是不错,不至于对阅读产生影响(信号量那章有细节问题,但是信号量那张和csapp第八章几乎重复)

首先,不要抱着一口气把这本书学完的心态去看。 尝试根据自己的兴趣,选择一个规模适当的开源项目,去阅读它的源代码。(例如我选择的就是一个小型的http服务器--Mongoose)当在某一方面发现自己有很多问题时,很希望去弄清楚时,这时候就可以去翻开手中的APUE,带着问题去阅读。这时候学习的效率必然比盲目地去看书更高,而且遗忘率也会降低。但是,仅仅读完是不够的。 很多时候,你看书的时候,会感觉自己看懂了,但是没过多久,又会发现自己忘了。或者,有时候你根本没看懂,而只是囫囵吞枣地看过去。所以,看完后,最好的方法就是写博客。尝试按照自己的理解以及逻辑,去将你学到的知识系统地阐述出来。这样,就算你以后忘了,再去翻翻博文,也能很快就捡起来。

十个最值得阅读学习的C开源项目代码

   Webbench
   Tinyhttpd
   cJSON
   CMockery
   Libev
   Memcached
   Lua
   SQLite
   UNIX v6
   NETBSD

建议先看 >> Unix/Linux编程实践教程

https://book.douban.com/subject/1219329/

http://item.kongfz.com/book/32040616.html?push_type=2&min_price=57.00&utm_source=101004009001

https://detail.tmall.com/item.htm?spm=a1z10.1-b.w9858442-8055933095.4.fH3HiL&id=19729431809

常用计算机书的下载

学习C语言,如何看懂及掌握一个程序!

十个经典的C开源项目代码

初学玩转C语言,这17个小项目收下不谢

https://zhuanlan.zhihu.com/p/83185476

tinyhttpd C 语言实现最简单的 HTTP 服务器 学习

tinyhttpd ------ C 语言实现最简单的 HTTP 服务器

https://github.com/nengm/Tinyhttpd

tinyhttpd源码详解

tinyhttp整理(一)

tinyhttp源码阅读(注释)

Tinyhttp源码分析及知识点总结

b站 C/C++ tinyHttp服务器小项目及源码讲解1

tinyhttpd深入解析与源码剖析

Tinyhttpd-master 源码学习笔记1

Tinyhttp源码分析

Tinyhttpd非官方镜像,Fork自sourceForge,仅供学习



tinyhttp源码分析

我把一些核心代码和相应的注释贴在这里,如果你感兴趣全部,可以移步我的github。 https://github.com/zhaozhengcoder/rebuild-the-wheel/tree/master/tinyhttpd


Tinyhttp 代码完全讲解

Mongoose-基于C的Web服务器代码学习

Mongoose-基于C的Web服务器 介绍和使用


Web服务器----mongoose

https://github.com/cesanta/mongoose

Mongoose源码剖析:外篇之web服务器

Mongoose-6.14源码剖析之基础篇

我的笔记

apue.3e/include/apue.h

chapter 1

APUE读书笔记-01UNIX系统概述

这是原文学不过是 Second Edition firefox 放大 就可以看 找一下 第三版本吧 Third Edition https://vaqeteart.gitee.io/file_bed/shared/books/APUE2/toc.html


?

C语言实现的ls命令源码分享-apue

C 语言实现 Linux ls 命令

understanding_unix_programming

chapter 2 who

/* 再看一下书 非常 好的啦  
who命令的实现过程是先打开一个系统文件UTMP_FILE,创建对应的格式struct utmpfd变量,读取数据到这个结构体中,作相应格式输出即可
*/
#include<stdio.h>
#include<utmp.h>
#include<fcntl.h>
#include <time.h>
#include<unistd.h>
#define SHOWHOST
void showtime(long);
void showtime(long timeval){
    char *cp;
    cp = ctime(&timeval);
    //cp[strlen(cp)-1]='\0';
    printf("%s",cp+4 ); //wed jun 21:40:09  +4是因为*cp所指的一串字符前4个字符表示为“星期”,可以忽略此信息
}
// 指向结构体 utmp 的指针 utbufp
void show_info(struct utmp *utbufp)
{
    printf("%-8.8s",utbufp->ut_name)	;
    printf(" ");
  printf("%-8.8s",utbufp->ut_line);
  printf("");
  printf("% 10ld",utbufp->ut_time );

  printf(" ");

  printf(" ");

}

int main()
{
   struct utmp current_record;
   int  utmpfd;
   int reclen = sizeof(current_record);

   if (( utmpfd = open (UTMP_FILE, O_RDONLY)) == -1) {
	   perror(UTMP_FILE);
	   return 1;
   }
   while ( read(utmpfd, &current_record, reclen) == reclen )
	   show_info(&current_record);
   close(utmpfd);
   return 0;

}
















C 库函数 void *memset(void *str, int c, size_t n) 复制字符 c(一个无符号字符)到参数 str 所指向的字符串的前 n 个字符。
memset(str,'$',7);

This is string.h library function
$$$$$$$ string.h library function

参考 和书 chapter 2 这个最接近原书的了

https://www.cnblogs.com/20145221GQ/p/6060420.html

who命令实现

unix/linux who命令的实现

https://www.runoob.com/cprogramming/c-function-memset.html

别人实现1

https://www.cnblogs.com/20145221GQ/p/6060420.html

https://gitee.com/20145221/linux-besti-is-2016-2017-1-20145221/blob/master/src/week09/who.c?dir=0&filepath=src%2Fweek09%2Fwho.c&oid=6ca54191e2a046c9de2e42cfc5eb895ff665b429&sha=6cd302d6cb4f0d36f667754e972ce63963483044#


#include <stdio.h>  
#include <utmp.h>
#include <fcntl.h>  
#include <unistd.h>  
#include <time.h>  
#include <string.h>
  
#define SHOWHOST  
  
void showtime(long timeval){  
    char* cp;  
    cp = ctime(&timeval);  
    cp[strlen(cp)-1] = '\0';
    printf("%s",cp+4);  
}  
  
void show_info(struct utmp* utbufp){  
    if(utbufp->ut_type != USER_PROCESS){  
        return ;  
    }  
  
    printf("%-8.8s",utbufp->ut_name);  
    printf(" ");  
    printf("%-8.8s",utbufp->ut_line);  
    printf(" ");  
    showtime(utbufp->ut_time);  
    printf(" ");  
  
#ifdef SHOWHOST  
    if(utbufp->ut_host[0] != '\0'){  
        printf("(%s)",utbufp->ut_host);  
    }  
#endif  
    printf("\n");  
}

int main(){  
    struct utmp current_record;  
    int utmpfd;  
    int reclen = sizeof(current_record);  
  
    if((utmpfd = open(UTMP_FILE,O_RDONLY)) == -1){  
        perror(UTMP_FILE);  
  
        return 1;  
    }  
  
    while( read(utmpfd,&current_record,reclen) == reclen ){  
        show_info(&current_record);  
    }  
  
    close(utmpfd);  
  
    return 0;  
}  

see also

who命令实现


cp


#include        <stdio.h>//标准输入输出
#include        <stdlib.h>//C标准函数库
#include        <unistd.h>//Unix类系统定义符号常量
#include        <fcntl.h>//定义了很多宏和open,fcntl函数原型

#define BUFFERSIZE      4096//定义存储器容量
#define COPYMODE        0644//定义复制的长度

void oops(char *, char *);
/*注意main函数的两个参数:
  argc记录了用户在运行程序的命令行中输入的参数的个数。
  arg[]指向的数组中至少有一个字符指针,即arg[0].它通常指向程序中的可执行文件的文件名。 */
main(int ac,char *av[])
{
    int in_fd, out_fd,n_chars;    //三个描述符值 in_fd为open返回的描述符 ,create out_fd为open返回的描述符  n_chars  读取的数据 function 见上个who  read的
    char buf[BUFFERSIZE]; //存储器位置
/*cp的参数有两个,分别是要复制的文件,和目的目录,这样一共应该是有三个操作数
  所以要先检查argc的值是否为三,如果不是,返回标准错误*/
        if(ac !=3) {
            fprintf(stderr, "usage:%s source destination\n",* av);
            exit(1);
        }
        /* open files 检查cp的第一个参数,要复制的文件,用open打开,in_fd为open返回的描述符 如果返回-1,代表打开失败,提示错误
           why CP 第一个参数是 av[1],  av[0] 是程序中的可执行的文件名也就是自己
        */
        if ((in_fd=open(av[1],O_RDONLY)) == -1)
            oops("Cannot open",av[1]);

/*检查cp的第二个参数,复制的目的地址,用create在目的地址创建新文件,out_fd为open返回的描述符
  如果返回-1,代表创建失败,提示错误 ; create 创建的位置就是av[2] 目标文件的位置是也
  为什么是 av[2]  就是 cp 命令的 第二个参数 也就是 目标文件 ,本来不存在 所以要create
*/
if(out_fd=creat(av[2],COPYMODE)== -1)
    oops("Cannot creat",argv[2])
}
/*copyfiles  cp指令的动作就是读取一个文件的内容到存储器,在新的地址创建空白文件,再从存储器将内容写入新文件。
  这里判断复制是否成功:
  如果能读取顺利,而读取的位数和写的位数不同,是写错误;
  如果读取失败,是读错误。
  why n_chars 是什么
  内核从utmpfd所指定的文件中读取了 reclen字节的数据,存放到 current_record所指定的内存空间中
  while ( read(utmpfd, &current_record, reclen) == reclen )

  write out_fd 文件描述符  buf 内存数据, n_chars 要写的字节数

循环的把源文件写入目标文件
*/
while ((n_chars= read(int __fd,buf,BUFFERSIZE))>0) {
    if(write(out_fd,buf,n_chars) != n_chars)
        oops("Write error to ", av[2]);
    if (n_chars== -1)

        oops("Read error from ",argv[1]);
/*这里执行的是关闭文件的动作,in_fd open的 和out_fd create的两个文件描述符
  所指向的文件只要有一个关闭错误,就提示关闭错误。*/
    if (close(in_fd) == -1 || close(out_fd)== -1)
        oops("Error closing files","");
}

/*不太明白为什么是指针了这里 evan  这个是用来输出错误信息的函数*/
void oops(char *s1, char *s2)
{
    fprintf(stderr, "Error:%s", s1);
    perror(s2); // 用来将上一个函数发生错误的原因输出到标准设备(stderr)
    exit(1)

        }


cp命令的编写最接受原书的了

Unix程序设计:实现cp命令

linux自己编写的 cp 命令像os的那个了

http://bbs.chinaunix.net/thread-247946-1-1.html

linux cp命令源码

ls

data/c/example/unixeg/ls/



ls命令实现过程用到的函数

函数原型:

1)int stat(const char *path, struct stat *buf);

  stat函数 将path(文件)的属性信息保存在 buf结构体中

2)struct passwd *getpwuid(uid_t uid);

  getpwuid函数是通过用户的uid查找用户的passwd数据,其中包括username

3)struct group *getgrgid(gid_t gid);

  getgrgid函数通过用户组gid指定的组识别码逐一搜索组文件,找到时便将该组的数据以group结构返回。

4)struct tm *localtime(const time_t *timep);

   localtime函数把从1970-1-1零点零分到当前时间系统所偏移的秒数时间转换为日历时间 。并且此函数获得的tm结构体的时间,是已经进行过时区转化为本地时间。

5)  DIR *opendir(const char *name);

  opendir()函数的作用是:打开目录句柄,返回一个文件描述符。

6)  struct dirent *readdir(DIR *dirp);

  readdir()函数读取一个目录文件描述符的信息,将信息返回到dirent结构体中。

https://www.cnblogs.com/lr-ting/archive/2012/06/19/2555207.html


第二版本的参考

linux系统编程:自己动手写一个ls命令

https://cpp.hotexamples.com/examples/-/-/mode_to_letters/cpp-mode_to_letters-function-examples.html

C语言实现Linux之ls

ubuntu 编写自己的ls命令

https://gitee.com/20145221/linux-besti-is-2016-2017-1-20145221/blob/master/src/week10/ls2.c


用c语言实现Linux命令ls操作

Linux下的 ls 命令的简单实现

高仿linux下的ls -l命令——C语言实现


在linux下编写一个LS命令的小程序

Linux系统编程【3.1】——编写ls命令

Linux系统编程【3.2】——ls命令优化版和ls -l实现

C 语言实现 Linux ls 命令

Linux/UNIX编程:使用C语言实现ls命令,但不同于书的


https://m.linuxidc.com/Linux/2009-03/18778.htm

简单版本的参考

https://github.com/fupengfei058/ls

http://www.voidcn.com/article/p-bzocmlpx-bxd.html

https://blog.csdn.net/qingshui23/article/details/53931555

https://blog.csdn.net/aonaigayiximasi/article/details/54019964

C IDE

https://www.jetbrains.com/zh-cn/clion/

Eclipse

Anjuta on linux

https://atom.io/

pre main

 init main( int argc, char *argv[]);
argc 是命令行参数的数目 也包括自身 没有后台的参数 那么 argc=1

argv 指向参数的各个指针所构成的数组, argv[0]表示命令本身,argv[1] 表示第一个参数

argc 是argument count的缩写表示传入main函数中的参数个数,包括这个程序本身

argv 是 argument vector的缩写表示传入main函数中的参数列表,其中argv[0]表示这个程序的名字; *argv[] 其实是地址 

第二个参数,char*型的argv[],为字符串数组,用来存放指向的字符串参数的指针数组,每一个元素指向一个参数。各成员含义如下:
        argv[0]指向程序运行的全路径名
        argv[1]指向在DOS命令行中执行程序名后的第一个字符串 

char   *argv[]是一个字符数组,其大小是int   argc,主要用于命令行参数   argv[]   参数,数组里每个元素代表一个参数;

看代码的时候我最先不理解的就是main函数的定义:

int main(int argc, char *argv[]){}

经查阅得知,argc是用来表示在命令行下输入命令时的参数个数,包括指令本身;argv[]是用来取得你输入的参数。针对具体指令分析如下(每一步解释由注释形式给出)。

由于main函数不能被其它函数调用, 因此不可能在程序内部取得实际值。那么,在何处把实参值赋予main函数的形参呢? 实际上,main函数的参数值是从操作系统命令行上获得的。当我们要运行一个可执行文件时,在DOS提示符下键入文件名,再输入实际参数即可把这些实参传送到main的形参中去。

ls1.c中的 就是这个了啦 
DOS提示符下命令行的一般形式为: C:\>可执行文件名 参数 参数……; 但是应该特别注意的是,main 的两个形参和命令行中的参数在位置上不是一一对应的。因为,main的形参只有二个,而命令行中的参数个数原则上未加限制。argc参数表示了命令行中参数的个数(注意:文件名本身也算一个参数),argc的值是在输入命令行时由系统按实际参数的个数自动赋予的。例如有命令行为: C:\>E6 24 BASIC dbase FORTRAN由于文件名E6 24本身也算一个参数,所以共有4个参数,因此argc取得的值为4。argv参数是字符串指针数组,其各元素值为命令行中各字符串(参数均按字符串处理)的首地址。 指针数组的长度即为参数个数。数组元素初值由系统自动赋予。其表示如图6.8所示:

main(int argc,char *argv){
while(argc-->1)
printf("%s\n",*++argv);
}

本例是显示命令行中输入的参数如果上例的可执行文件名为e24.exe,存放在A驱动器的盘内。
因此输入的命令行为: C:\>a:e24 BASIC dBASE FORTRAN  
则运行结果为:
BASIC
dBASE
FORTRAN
  该行共有4个参数,执行main时,argc的初值即为4。argv的4个元素分为4个字符串的首地址。执行while语句,每循环一次 argv值减1,当argv等于1时停止循环,共循环三次, 因此共可输出三个参数。在printf函数中,由于打印项*++argv是先加1再打印, 故第一次打印的是argv[1]所指的字符串BASIC。第二、 三次循环分别打印后二个字符串。而参数e24是文件名,不必输出。

另外一个例子


c语言中argc和argv[ ]的作用及用法

good和ls1.c差不多 C语言中 int main(int argc,char *argv[])的两个参数详解

https://zhuanlan.zhihu.com/p/267822985

https://blog.csdn.net/LYJ_viviani/article/details/51873961

c语言之argc和argv

基础

计算机为什么要用二进制

Everything over Binary 模拟路转换成为数字电路

https://blog.csdn.net/weixin_44296862/article/details/95277924

https://blog.csdn.net/c46550/article/details/90951557

一位全加器

signed char 类型的范围为 -128~127

 按八位来算:
在计算机里面是用补码表示的,128的二进制码是:10000000,这个东西在计算里面并不是128,因为最高位是符号,它是个负数,那么负数的原码是多少呢,我们知道如果补码的符号位为“1”,表示是一个负数,求原码的操作可以是:符号位为1,其余各位取反,然后再整个数加1。 
所以,10000000取反后就是11111111,把符号位去了就是01111111再加1就是10000000就是-128了。
其实你看-127是10000001,这个很好理解,-128加1不就是-127
[https://blog.csdn.net/zy986718042/article/details/71699079 浅谈char类型范围]

补码表示时,-0和+0补码相同都是0 000 0000,所义导致可以多表示一个负数,...这个负数是最小的那个..

浅析为什么char类型的范围是 —128~+127


char 其数值表示 范围的计算

b站 C语言数据类型及数值范围

原码 补码 反码

1.原码
最高位表示符号位。剩下的位数,是这个数的绝对值的二进制

就比方说 一个完整的int型变量在内存中占的是4个字节,32位的编译器中 那么这时候他的二进制表示是00000000 00000000 00000000 00000000

所以

10的原码就是00000000 00000000 00000000 00001010

那么负数的原码就是例如

-10的原码10000000 00000000 00000000 00001010

 符号位是第一位 0为正数 1为负数

2.反码
    正数的反码就是其原码.

    负数的反码就是在其原码的基础之上 符号位不变,其他位取反.
    
3.补码

    正数的补码就是其原码.

    负数的补码就是在其反码的基础之上+1
    

C语言中的原码、反码和补码

C语言之原码、反码和补码

C语言——源码、反码、补码

b站原码 反码 补码

gdb




start   st 开始执行程序,在main函数的第一条语句前面停下来
step       s   下一条语句,如果该语句为函数调用,则进入函数执行其中的第一条语句
 next    n  执行下一条语句,如果该语句为函数调用,不会进入函数内部执行(即不会一步步地调试函数内部语句)









使用例子  结合他看C代码 爽到不行了 
184
185gcc -g 11.2.c -o 11.2
186gdb 11.2
187
188(gdb) start
189(gdb) s   #一直用step命令(简写为s)进入函数中 ,n命令呢
190
191
192step s  下一条语句,如果该语句为函数调用,则进入函数执行其中的第一条语句
193next n  执行下一条语句,如果该语句为函数调用,不会进入函数内部执行(即不会一步步地调试函数内部语句)

c


/*                                                                                                                                                                                          
20答案是 Tuesday  因为列数定了是10                                                                                                                                                            
21days[2] === days[2][10]                                                                                                                                                                     
22                                                                                                                                                                                            
23解说                                                                                                                                                                                        
24days[2][0]=T                                                                                                                                                                                
25days[2][1]=u                                                                                                                                                                                
26days[2][2]=e                                                                                                                                                                                
27days[2][3]=s                                                                                                                                                                                
28days[2][4]=d                                                                                                                                                                                
29days[2][5]=a                                                                                                                                                                                
30days[2][6]=y                                                                                                                                                                                
31days[2][7]=                                                                                                                                                                                 
32days[2][8]=                                                                                                                                                                                 
33days[2][9]=                                                                                                                                                                                 
34                                                                                                                                                                                            
35                 

eg

石头剪刀布

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main(void)
{
	char gesture[3][10] = { "scissor", "stone", "cloth" };
	int man, computer, result, ret;

	srand(time(NULL));
	while (1) {
		computer = rand() % 3;
	  	printf("\nInput your gesture (0-scissor 1-stone 2-cloth):\n");
		ret = scanf("%d", &man);
	  	if (ret != 1 || man < 0 || man > 2) {
			printf("Invalid input! Please input 0, 1 or 2.\n");
			continue;
		}
		printf("Your gesture: %s\tComputer's gesture: %s\n", 
			gesture[man], gesture[computer]);

		result = (man - computer + 4) % 3 - 1;
		if (result > 0)
			printf("You win!\n");
		else if (result == 0)
			printf("Draw!\n");
		else
			printf("You lose!\n");
	}
	return 0;
}


/*
0、1、2三个整数分别是剪刀石头布在程序中的内部表示,用户也要求输入0、1或2,然后和计算机随机生成的0、1或2比胜负。这个程序的主体是一个死循环,需要按Ctrl-C退出程序。以往我们写的程序都只有打印输出,在这个程序中我们第一次碰到处理用户输入的情况。在这里只是简单解释一下,以后再细讲。scanf("%d", &man)这个调用的功能是等待用户输入一个整数并回车,这个整数会被scanf函数保存在man这个整型变量里。如果用户输入合法(输入的确实是整数而不是字符串),则scanf函数返回1,表示成功读入一个数据。但即使用户输入的是整数,我们还需要进一步检查是不是在0~2的范围内,写程序时对用户输入要格外小心,用户有可能输入任何数据,他才不管游戏规则是什么。

和printf类似,scanf也可以用%c、%f、%s等转换说明。如果在传给scanf的第一个参数中用%d、%f或%c表示读入一个整数、浮点数或字符,则第二个参数的形式应该是&运算符加一个相应类型的变量名,表示读进来的数存到这个变量中;如果在第一个参数中用%s读入一个字符串,则第二个参数应该是数组名,数组名前面不加&,因为数组类型做右值时自动转换成指针类型,而scanf后面这个参数要的就是指针类型,在第 10 章 gdb有scanf读入字符串的例子。&运算符的作用也是得到一个指针类型,这个运算符以后再详细解释。

留给读者的思考问题是:(man - computer + 4) % 3 - 1这个神奇的表达式是如何比较出0、1、2这三个数字在“剪刀石头布”意义上的大小的
*/

石头剪刀布_C语言

https://blog.csdn.net/guoqingchun/article/details/8104197


Linux下C语言获取目录中的文件列表

/*
 * dir.c
 *
Linux下C语言获取目录中的文件列表  https://www.cnblogs.com/dgwblog/p/12158373.html
http://c.biancheng.net/cpp/html/1548.html  怎样使用C语言列出某个目录下的文件?
 *  Created on: 2020年11月2日
 *      Author: evan
 */
#include <sys/types.h>
#include <dirent.h>
#include <unistd.h>
#include <stdio.h>
int main(){
	 DIR *dir;
	 struct  dirent *ptr;
	 dir = opendir("/home/evan/t1/");
	 while((ptr = readdir(dir)) != NULL)
		 printf("d_name:%s\n",ptr->d_name);
	 closedir(dir);
	 return 0;
}


/* 结果
 *
d_name:.
d_name:..
d_name:1.py
d_name:22.py

*/


排序与查找

插入排序

#include <stdio.h>
#define LEN 5
int a[LEN] = { 10, 5, 2, 4, 7 };
void insertion_sort(void)
{
	int i, j, key;
	for (j = 1; j < LEN; ++j) {
		printf("%d, %d, %d, %d, %d\n",
		       a[0], a[1], a[2], a[3], a[4]);
		key = a[j];  //key 标记为未排序的第一个元素
		i = j - 1;
                // key  与已排序元素从大到小比较,寻找key应插入的元素 a[i+1]一般就是key 起初的值
////采用顺序查找方式找到插入的位置,在查找的同时,将数组中的元素进行后移操作,给插入元素腾出空间 ?

		while (i >= 0 && a[i] > key) {
			a[i+1] = a[i];
			--i; //跳出while 
		}
		a[i+1] = key; ////插入到正确位置
	}
	printf("%d, %d, %d, %d, %d\n",
	       a[0], a[1], a[2], a[3], a[4]);
}
int main(void)
{
	insertion_sort();
	return 0;
}
/* 就是key 一直和前面排好的比,找到正确的位置 
10, 5, 2, 4, 7
5, 10, 2, 4, 7
2, 5, 10, 4, 7
2, 4, 5, 10, 7
2, 4, 5, 7, 10 */ 


算法的时间复杂度分析

则总的执行时间粗略估计是(n-1)*(c1+c2+c5+m*(c3+c4))。 #怎么来的呢  线性函数  不记得了 要补一下

插入排序算法及C语言实现


11.4 归并排序

递归实现 归并排序



see also

还有下一节 ?

4-5 通过归并排序算法深入理解递归


非递归 https://blog.csdn.net/zjy900507/article/details/80530336

chapter 12 栈与队列

堆栈

http://docs.linuxtone.org/ebooks/C&CPP/c/ch12s02.html

3. 深度优先搜索

未看 http://akaedu.github.io/book/ch12s03.html


第 13 章 计算机中数的表示

1. 为什么计算机用二进制计数

第 14 章 计算机中数的表示

c语言基本数据类型short、int、long、char、float、double

C语言的基本数据类型


c语言char是什么意思

二进制制转十进制

 在 C 语言中, signed char 类型的范围为 -128~127,每本教科书上也这么写,但是没有哪一本书上(包括老师)也不会给你为什么是 -128~127,这个问题貌似看起来也很简单容易, 以至于不用去思考为什么,不是有一个整型范围的公式吗:  -2^(n-1)~2^(n-1)-1 (n为整型的内存占用位数),所以 int 类型 32 位那么就是 -(2^31) ~ 2^31-1 即 -2147483648~2147483647,但是为什么最小负数绝对值总比最大正数多 1 ,这个问题甚至有的工作几年的程序员都模棱两可,因为没有深入思考过,只知道书上这么写。于是,我不得不深入思考一下这个被许多人忽视的问题。

对于无符号整数,很简单,全部位都表示数值,比如 char 型,8位,用二进制表示为 0000 0000 ~ 1111 1111,1111 1111 最大即为十进制255,所以 unsigned char 的范围为 0~ 255,在这里普及一下 2 进制转十进制的方法, 二进制每一位的数值乘以它的位权(2^(n-1),n为自右向左的位),再相加,可得到十进制数,比如 :1111 1111 = 1*2^7 + 1*2^6 + 1*2^5 + 1*2^4 + 1*2^3 + 1*2^2 + 1*2^1 + 1*2^0 = 255 。


但是对于有符号整数,二进制的最高位表示正负,不表示数值,最高位为 0 时表示正数,为 1 时表示负数,这样一来,能表示数值的就剩下( n-1 )位了,
比如 char a = -1;   那么二进制表示就为 1 0000001,1 表示为 0 0000001,所以 signed char 型除去符号位剩下的 7 位最大为 1111 111 = 127,再把符号加上,0 1111111 = 127,1 1111111 = -127,范围应该为 -127~127 ,同理 int 类型也一样,但是问题出来了,教科书上是 -128~127 啊,下面就剖析一下这个惊人的奇葩。 加上反码 看到这里 


再普及一下计算机内部整数存储形式,大家都知道计算机内部是以二进制来存贮数值的,无符号整数会用全部为来存储,有符号的整数,最高位当做符号位 ,其余为表示数值。

第 17 章

3. 设备

http://akaedu.github.io/book/ch17s03.html

4. MMU

按照离CPU由近到远的顺序依次是CPU寄存器、Cache、内存、硬盘,越靠近CPU的存储器容量越小但访问速度越快

http://akaedu.github.io/book/ch17s04.html

Memory Hierarchy

http://akaedu.github.io/book/ch17s05.html

附录 A. 字符编码

20191112

字符编码的高位 左边是也

如何学习c

mongoose 开源http库

有空学习这个作为C的入门例子

Mongoose是一个用C编写的网络库。它为客户端和服务器模式实现TCP,UDP,HTTP,WebSocket,CoAP,MQTT的事件驱动的非阻塞API。 mongoose 开源http库

Mongoose 利用实现HTTP服务

funciton

时间搞定 
头文件:#include <time.h>

定义函数:char *ctime(const time_t *timep);

函数说明:ctime()将参数timep 所指的time_t 结构中的信息转换成真实世界所使用的时间日期表示方法,然后将结果以字符串形态返回。此函数已经由时区转换成当地时间,字符串格式为"Wed Jun 30 21 :49 :08 1993\n"。

注意:若再调用相关的时间日期函数,此字符串可能会被破坏。

https://www.runoob.com/cprogramming/c-function-ctime.html

strcmp

C/C++函数,比较两个字符串

strcmp函数是string compare(字符串比较)的缩写,用于比较两个字符串并根据比较结果返回整数

设这两个字符串为str1,str2,

若str1==str2,则返回零;

若str1<str2,则返回负数;

若str1>str2,则返回正数。

strcmp

https://baike.so.com/doc/61175-64376.html

C library function - remove()

/*
 * remvoe.c
 *
 *  Created on: 2020年11月30日
 *      Author: evan
 */
#include <stdio.h>
#include<string.h>

int main() {
	int ret;
	FILE *fp;
	char filename[] = "file.txt";  // 这个是什么意思  定义一个 数组 ? 是的  

	fp = fopen(filename,"w");

	fprintf(fp,"%s", "THis is tutor \n");
	fprintf(fp,"%s", "ln2 THis is tutor");
	fclose(fp);

	//ret = remove(filename);
/*
	 cat file.txt
	THis is tutor*/

	if(ret == 0) {
		printf("file deleted successfully");
	}else {
		printf("Error: unable to delte the file");
	}
	return(0);

}


C语言perror函数的作用

 不可以掉了这个头文件,perror是包含在这个文件里的//编辑本段perror表头文件完善版定义函数
  void perror(const char *s); perror ("open_port");
函数说明
  perror ( )用 来 将 上 一 个 函 数 发 生 错 误 的 原 因 输 出 到 标 准 设备 (stderr) 。参数 s 所指的字符串会先打印出,后面再加上错误原因字符串。此错误原因依照全局变量errno 的值来决定要输出的字符串。   在库函数中有个errno变量,每个errno值对应着以字符串表示的错误类型。当你调用"某些"函数出错时,该函数已经重新设置了errno的值。perror函数只是将你输入的一些信息和现在的errno所对应的错误一起输出。

void perror(const char *str)

参数

    str -- 这是 C 字符串,包含了一个自定义消息,将显示在原本的错误消息之前

#include <stdio.h>   
int main(void)   
{   
	FILE *fp ;   
	fp = fopen( "/root/noexitfile", "r+" );   
	if ( NULL == fp )  ?
	{   
		perror("/root/noexitfile");   //下面有这个输出
	}   
	return 0;   
}

运行结果
[root@localhost io]# gcc perror.c   
[root@localhost io]# ./a.out   
/root/noexitfile: No such file or directory


linux下 C语言perror函数的作用

https://www.cnblogs.com/yujianfei/p/8973867.html

https://www.runoob.com/cprogramming/c-function-perror.html


c语言实现rm命令 or 删除

头文件:#include <stdio.h>

remove()函数用于删除指定的文件,其原型如下:
    int remove(char * filename);

【参数】filename为要删除的文件名,可以为一目录。如果参数filename 为一文件,则调用unlink()处理;若参数filename 为一目录,则调用rmdir()来处理。

【返回值】成功则返回0,失败则返回-1,错误原因存于errno。

C语言remove()函数:删除文件或目录

linux下实现rm()函数删除文件或目录

c语言实现rm命令,删除指定文件或目录

C语言access()函数:判断是否具有存取文件的权限

C语言access()函数:判断是否具有存取文件的权限

C语言中access函数

C 数组


进阶

十个经典的C开源项目代码

十个经典的C开源项目代码


2021

C语言目录操作

C语言技术网

博客园 C语言中关于对目录的操作

《Linux环境C程序设计(第2版)徐诚》pdf 附下载链接

http://www.txtepub.com/105693.html

see also

C语言简要语法指南

https://wiki.ubuntu.com.cn/Compiling_C

Gcc-howto

c++

c++ zh.wikipedia.org

https://isocpp.org/