页面“Emacs入门”与“C基础”之间的差异

来自linux中国网wiki
(页面间的差异)
跳到导航 跳到搜索
 
 
第1行: 第1行:
  
  
==安装emacs==
 
[[How to Compile Emacs on Linux]]
 
  
[http://soft.dog/2018/07/23/emacs-lisp/ Emacs Lisp]
+
 +
good
 +
http://akaedu.github.io/book/
  
== 正文==
 
https://www.emacswiki.org/emacs?interface=zh-cn
 
  
[https://blog.csdn.net/wdkirchhoff/article/details/41623161  生活在Emacs中]
+
[https://zhuanlan.zhihu.com/p/90971489 C语言编程学习必备的一些网站,干货收藏!]
  
== 成为高手笔记==
+
[https://www.bilibili.com/video/BV17s411N78s/?spm_id_from=333.788.videocard.0 带你学C带你飞》]
<pre>即使你不打算使用 Emacs 默认快捷键, 这步也是必须的, 不要跳过!
+
=如何学习C=
  
最起码要知道以下命令,
+
[https://blog.csdn.net/qwe6620692/article/details/88107248  学习C语言,如何看懂及掌握一个程序]
  
M-x describe-variable, 快捷键 C-h v, 查看变量的文档
+
=2021学习C APUE=
M-x describe-function, 快捷键 C-h f, 查看命令的文档
+
http://www.apuebook.com/
M-x describe-key, 快捷键 C-h k, 查看快捷键的文档
 
  
 +
[https://www.zhihu.com/topic/19705459/hot UNIX环境高级编程(书籍)笔记什么都 有呀 ]
  
Emacs manual      C-h r        Browse manuals    C-h i
+
[https://www.zhihu.com/question/19939011 《UNIX环境高级编程》这本书怎么看?怎么学习]
Emacs tutorial    C-h t        Undo changes      C-x u
 
Buy manuals        C-h RET      Exit Emacs        C-x C-c
 
  
  
</pre>
 
  
 +
==看法  ==
 +
第二章和第六章可以跳跳,回头看
  
以实际问题作为切入点
+
7.中文版翻译有瑕疵,但是整体还是不错,不至于对阅读产生影响(信号量那章有细节问题,但是信号量那张和csapp第八章几乎重复)
  
努力能很快得到回报, 你会越学越有乐趣, 进入感情上的正反馈.
+
首先,不要抱着一口气把这本书学完的心态去看。      尝试根据自己的兴趣,选择一个规模适当的开源项目,去阅读它的源代码。(例如我选择的就是一个小型的http服务器--Mongoose)当在某一方面发现自己有很多问题时,很希望去弄清楚时,这时候就可以去翻开手中的APUE,带着问题去阅读。这时候学习的效率必然比盲目地去看书更高,而且遗忘率也会降低。但是,仅仅读完是不够的。      很多时候,你看书的时候,会感觉自己看懂了,但是没过多久,又会发现自己忘了。或者,有时候你根本没看懂,而只是囫囵吞枣地看过去。所以,看完后,最好的方法就是写博客。尝试按照自己的理解以及逻辑,去将你学到的知识系统地阐述出来。这样,就算你以后忘了,再去翻翻博文,也能很快就捡起来。
  
要成为高手, 兴趣是最重要的.
+
十个最值得阅读学习的C开源项目代码
  
以我为例, 我急需 GTD 的工具, 而 Emacs 的 Org-mode 是同类软件中最好的 (没有之一). 用 Org-mode 节省了时间后, 我对 Emacs 爱屋及乌, 兴趣高涨了 100 倍.
+
    Webbench
 +
    Tinyhttpd
 +
    cJSON
 +
    CMockery
 +
    Libev
 +
    Memcached
 +
    Lua
 +
    SQLite
 +
    UNIX v6
 +
    NETBSD
  
反面例子是啃Lisp教程开始Emacs之旅, 坚持下来的人寥寥无几.
+
建议先看 >> Unix/Linux编程实践教程
  
待解决的问题设定优先度 关键在于理性地考虑你最迫切需要解决的一个问题.以这个问题作为出发点, 除此之外都可以妥协.
+
https://book.douban.com/subject/1219329/
  
虽然 Emacs 无所不能, 但是饭也要一口一口吃. 有时退一步等于进两步.
+
http://item.kongfz.com/book/32040616.html?push_type=2&min_price=57.00&utm_source=101004009001
  
例如, 我一直以为 Emacs 的中文显示很完美, 搞不懂为什么有人在字体配置上花那么多时间.
+
https://detail.tmall.com/item.htm?spm=a1z10.1-b.w9858442-8055933095.4.fH3HiL&id=19729431809
  
在接到读者反馈后, 我才明白原来我一直在终端下使用Emacs, 终端软件可以完美显示中文字体, 所以就没 Emacs 什么事了. 需要配置字体的人用的是图形界面 Emacs.
+
[https://github.com/woai3c/recommended-books 常用计算机书的下载]
  
当初只在终端下使用 Emacs 是因为需连接到远程服务器. 我认为这是重点. 甚至为此放弃了漂亮的配色主题 (后来发觉此牺牲毫无必要). 塞翁失马, 由此也避免了图形界面版本的所有问题.
+
[https://blog.csdn.net/qwe6620692/article/details/88107248  学习C语言,如何看懂及掌握一个程序!]
  
https://github.com/redguardtoo/mastering-emacs-in-one-year-guide/blob/master/guide-zh.org
+
[https://blog.51cto.com/chinalx1/2143904 十个经典的C开源项目代码]
  
==后记==
+
[https://developer.51cto.com/art/201903/593703.htm 初学玩转C语言,这17个小项目收下不谢]
<span style="color:green;">后面要把常用的这些常用快捷键写成一个短小的总结卡</span>
 
=== 模式键定义===
 
  
四个模式键:C—-Ctrl;M—-Alt;s—-Super(Win);S—-Shift
+
https://zhuanlan.zhihu.com/p/83185476
  
比如:
+
== tinyhttpd C 语言实现最简单的 HTTP 服务器 学习 ==
  
C-x:表示按下ctrl键,然后按下x键。
+
[https://www.shuzhiduo.com/A/ZOJPY9Ge5v/ tinyhttpd ------ C 语言实现最简单的 HTTP 服务器]
  
C-x  C-c:表示按下ctrl,然后按下x键,松开后再按下c键。
+
https://github.com/nengm/Tinyhttpd
  
C-x k:表示按下ctrl,同时按下x和k键。
+
[https://blog.csdn.net/baiwfg2/article/details/45582723  tinyhttpd源码详解]
  
 +
[https://blog.csdn.net/konghhhhh/article/details/103752962  tinyhttp整理(一)]
  
=== 最常用命令 页开头或结尾===
+
[https://blog.csdn.net/weixin_30387663/article/details/99664160  tinyhttp源码阅读(注释)]
  
<span style="color:red;">M-f 与 M-b  </span> 在行内, 前后大步移动光标,步进单位对于英文而言是单词的长度,对于中文而言是两个标点符号的间距。
+
[https://juejin.cn/post/6870760453619122183  Tinyhttp源码分析及知识点总结 ]
  
<span style="color:red;">M-{ M-} </span> 段开头或结尾
+
[https://www.bilibili.com/video/BV1hy4y1C71M/?spm_id_from=333.788.videocard.1 b站 C/C++ tinyHttp服务器小项目及源码讲解1]
  
<span style="color:red;">C-x [  C-x ] or ESC <  ESC > </span>页开头或结尾 
+
[https://blog.csdn.net/wwxy1995/article/details/99362666  tinyhttpd深入解析与源码剖析]
  
<span style="color:red;">C-a 或 C-e </span> 对于英文文本,若将光标快速移到行首或行尾,标准按键是 C-a 或 C-e 但是对于中文而言,这对按键有着将光标被移到段首或段尾的奇异效果……如果偶尔忘记,用 Home或End 键也未尝不可。
+
[https://blog.csdn.net/qq_40677350/article/details/90201758  Tinyhttpd-master 源码学习笔记1]
  
<span style="color:red;">M-a 与 M-e </span> 则分别可将光标移动到句首或句尾。
+
[https://blog.csdn.net/yzhang6_10/article/details/51534409  Tinyhttp源码分析]
  
<span style="color:red;"> C-v 或 M-v <span> 如果文档很长,用可实现向下或向上翻屏
+
[https://github.com/EZLippi/Tinyhttpd Tinyhttpd非官方镜像,Fork自sourceForge,仅供学习]
  
M-< ,移到最开始。
 
  然后再按几次 C-v 回到这里。
 
  
M-> ,移到最末尾。
 
  然后再按几次 M-v 回到这里。
 
  
C-x 2 将屏幕划分成两个窗格。这两个窗格里显示的都是本篇快速指南,而光标则停留在上方的窗格里。
 
  
C-x o(“o”指的是“其它(other)”), 将光标转移到下方的窗格。
+
[https://www.jianshu.com/p/18cfd6019296 tinyhttp源码分析]
  
C-x 1  (在上方窗格里)输入 C-x 1 关掉下方窗格。
+
我把一些核心代码和相应的注释贴在这里,如果你感兴趣全部,可以移步我的github。
 +
https://github.com/zhaozhengcoder/rebuild-the-wheel/tree/master/tinyhttpd
  
C-x C-f        寻找文件。
 
C-x C-s        保存文件。
 
  
打开菜单 用F10或者M-` (就是键盘输入区左上角的那个键)就可以呼出菜单了
+
[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 代码完全讲解]
  
emacs-gtk 显示菜单 etc  option -->show/hide 这样在 emacs-gtk 就有菜单了 而em还是没有的 非常 好
+
==Mongoose-基于C的Web服务器代码学习 ==
  
==== 搜索 ====
+
[https://www.jianshu.com/p/745c03a8864a Mongoose-基于C的Web服务器 介绍和使用]
增量搜索
 
C-s 正向搜索
 
  
C-r 反向搜索
 
  
C-M-s使用正则表达式正向搜索
+
[https://blog.csdn.net/hnzwx888/article/details/84971205  Web服务器----mongoose]
  
C-M-r 使用正则表达式反向搜索
+
https://github.com/cesanta/mongoose
  
M-p 选择上一个搜索结果
+
[https://www.cnblogs.com/skynet/archive/2010/07/24/1784110.html  Mongoose源码剖析:外篇之web服务器 ]
  
M-n 选择下一个搜索结果
+
[https://blog.csdn.net/lixiaogang_theanswer/article/details/102753370  Mongoose-6.14源码剖析之基础篇]
  
RET 退出搜索并停留在当前搜索到的位置
+
== 我的笔记 ==
 +
apue.3e/include/apue.h
 +
=== chapter 1===
 +
[https://zhuanlan.zhihu.com/p/136700729 APUE读书笔记-01UNIX系统概述]
  
C-g 中止当前搜索
+
这是原文学不过是 Second Edition  firefox 放大 就可以看  找一下 第三版本吧 Third Edition
 +
https://vaqeteart.gitee.io/file_bed/shared/books/APUE2/toc.html
  
===save and exit ===
 
<pre>
 
C-x C-c:退出Emacs
 
  
C-x C-s:保存当前buffer
+
=== ?===
</pre>
 
  
===选中 复制 黏贴===
+
[https://www.jb51.net/article/55257.htm C语言实现的ls命令源码分享-apue]
<pre>
 
把光标移动到区域的首字符
 
键入C-@(即ctrl+shift+2),以设置标记 有时是ctrl+shife +@
 
把光标移动到区域的最后一个字符
 
键入M(alt)-w,拷贝这个选定区域到粘贴板(剪切是C-w)
 
用光标定位将要粘贴内容的地方,然后键入C-y ,拷贝成功。
 
  
C-@ mark --> c-f or c-n --> alt-w --> c-y
+
[https://blog.nowcoder.net/n/9a48a7f697864e3bbdae2fe5bfcb0ef9 C 语言实现 Linux ls 命令]
  
C-w 剪切标记到当前光标所在处的文本  ESC w 复制文本
+
=understanding_unix_programming =
  
C-d 删除一个字符
+
==chapter 2  who ==
ESC h 选中一个段落
 
  
C-x C-x 检查一下位置                                                               
 
C-w  删除文本块 
 
</pre>
 
 
===查找===
 
 
<pre>
 
<pre>
搜索/替换(Seach/Replace)
+
/* 再看一下书 非常 好的啦 
C-s 向后搜索
+
who命令的实现过程是先打开一个系统文件UTMP_FILE,创建对应的格式struct utmpfd变量,读取数据到这个结构体中,作相应格式输出即可
C-r 向前搜索</pre>
+
*/
 +
#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.zhihu.com/question/23456580 GNU emacs24 中如何剪切复制多行文本]
+
  printf(" ");
  
===替换===
+
  printf(" ");
<pre>
 
按M - %启动查找替换(M is alt on debian),输入要被替换的词,回车,然后输入要替换的词,再回车。
 
被替换的词会高亮起来,这时,输入y替换并跳到下一个,输入n忽略并跳到下一个,输入q结束,输入!替换剩下的全部。
 
  
一些常用的选项:
+
}
  C - g 中断查找替换过程。
 
  ^ 返回上一个替换点,按y继续下一个,如果不想替换上一个的话,用^返回到上一个,然后按 C - r 进入编辑,修改完后按C - M - c退出继续下一个。
 
  C - l 使当前匹配显示在文档中间。
 
  C - r 进入修改。
 
</pre>
 
[https://www.cnblogs.com/robertzml/archive/2010/03/03/1675870.html 学习Emacs系列教程(八):查找替换]
 
  
[https://www.cnblogs.com/skyhacker/archive/2012/01/03/2311437.html emacs查找替换]
+
int main()
 +
{
 +
  struct utmp current_record;
 +
  int  utmpfd;
 +
  int reclen = sizeof(current_record);
  
===DEL===
+
  if (( utmpfd = open (UTMP_FILE, O_RDONLY)) == -1) {
<pre>
+
  perror(UTMP_FILE);
 +
  return 1;
 +
  }
 +
  while ( read(utmpfd, &current_record, reclen) == reclen )
 +
  show_info(&current_record);
 +
  close(utmpfd);
 +
  return 0;
  
C-d  是对字符操作                                                 
+
}
ESC  d  对单词操作                                               
 
                                                                   
 
ESC D 删除光标后面的单词; ESC DEL                                 
 
C-k ;                                                             
 
ESC K 删除光标后面的句子;C-k del 删除光标前面的句子               
 
   
 
</pre>
 
===移动 ===
 
<pre>
 
  
M-< 到文件开头
 
M->  esc ->shift+> 到文件末尾
 
  
  
  
以下命令在翻页浏览时相当有用:
 
  
C-v    向前移动一屏
 
M-v    向后移动一屏
 
C-l    重绘屏幕,并将光标所在行置于屏幕的中央
 
(注意是 CONTROL-L,不是 CONTROL-1)
 
  
  
整屏的移动很有用,但是如何在文字中精确定位呢?
 
  
有几种方式可以选择。用方向键当然可以,不过更有效率的方法是保持双手位于
 
主键盘区,然后使用 C-p 、 C-b 、 C-f 和 C-n 这四个命令。它们的功能和方
 
向键是一样的,如下图所示:
 
  
                            上一行 C-p
 
                                  :
 
                                  :
 
            向左移 C-b .... 目前光标位置 .... 向右移 C-f
 
                                  :
 
                                  :
 
                            下一行 C-n
 
p-previous,n-next,b-backward,f-forward。
 
>> 用 C-n 或 C-p 将光标移到上图的中央。
 
  按 C-l,整幅图会被显示在屏幕的中央。
 
  
  
  
移动的单位            向后        向前
 
字符                  C-b          C-f
 
  
  
  
当前行开头或结尾      C-a          C-e
 
  
C-n
+
C 库函数 void *memset(void *str, int c, size_t n) 复制字符 c(一个无符号字符)到参数 str 所指向的字符串的前 n 个字符。
 +
memset(str,'$',7);
  
M-f 如果你嫌一个字符一个字符地挪光标太慢,你还可以一个词一个词地跳。M-f
+
This is string.h library function
(META-f) 可以将光标往前移动一个词,而 M-b 则是往后移。【这里的“词”指
+
$$$$$$$ string.h library function
英文单词,对中文来说,则是指移动到下一个标点符号。】
+
</pre>
  
类似的惯例在“行”与“句子”之间也同样适用:C-a 和 C-e 可以将光标移动到
+
参考 和书 chapter 2  这个最接近原书的了
“一行”的头部和尾部;而 M-a(和terminator冲突) 和 M-e 则将光标移动到“一句”的头部和尾部。
 
  
 +
https://www.cnblogs.com/20145221GQ/p/6060420.html
  
这里对简单的光标移动命令做一个总结,其中也包括了整词和整句的移动:
+
[https://blog.csdn.net/u010307522/article/details/72862589  who命令实现]
  
        C-f    向右移动一个字符
+
[https://blog.csdn.net/qq_33850438/article/details/60762519  unix/linux who命令的实现]
        C-b    向左移动一个字符
 
  
        M-f    向右移动一个词【对中文是移动到下一个标点符号】
+
https://www.runoob.com/cprogramming/c-function-memset.html
        M-b    向左移动一个词【对中文是移动到上一个标点符号】
+
===别人实现1===
 +
https://www.cnblogs.com/20145221GQ/p/6060420.html
  
        C-n    移动到下一行
+
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#
        C-p    移动到上一行
+
<pre>
  
         C-a     移动到行首
+
#include <stdio.h> 
         C-e     移动到行尾
+
#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"); 
 +
}
  
         M-a     移动到句首
+
int main(){ 
         M-e     移动到句尾
+
    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; 
 +
  
 +
</pre>
 +
===see also===
 +
[https://blog.csdn.net/u010307522/article/details/72862589  who命令实现]
  
  
这里还要介绍两个重要的光标移动命令:M-< (META 小于号)可以将光标移动到
+
===cp===
所有文字的最开头;M-> (META 大于号)可以将光标移动到所有文字的最末尾。
 
 
 
注意,在大部分键盘上,小于号(<)需要用上档键(Shift)来输入,所以在这
 
些键盘上你应该用 Shift 键来输入 M-<,如果不按 Shift 键,你输入的会是
 
M-comma(META 逗号)。
 
 
 
>> 试一试 M-< ,移到本快速指南的最开始。
 
  然后再按几次 C-v 回到这里。
 
 
 
>> 试一试 M-> ,移到本快速指南的最末尾。
 
  然后再按几次 M-v 回到这里。
 
 
 
 
 
如果你的键盘上有方向键的话,也可以用它们来移动光标。不过我们有三个理由
 
推荐你学习 C-b 、C-f 、C-n 、和 C-p:(1)它们在任何键盘上都能用。(2)
 
当你熟练使用 Emacs 之后,你会发现用这些组合键比用方向键要快得多,因为你
 
的手不需要离开打字区。(3)一旦你习惯了使用这些组合键,你也可以很容易地
 
适应其它更高级的光标移动命令。
 
 
 
大部分的 Emacs 命令接受数字参数,并且对于多数命令而言,这些数字参数的作
 
用是指定命令的重复次数。为一个命令指定数字参数(也就是重复次数)的方法
 
是:先输入 C-u,然后输入数字作为参数,最后再输入命令。如果你有META (或
 
EDIT 或 ALT)键,那么还有另一种办法:按住 META 键不放,然后输入数字。不
 
过我们还是建议你用 C-u,因为它在任何终端机上都能用。这种数字参数也称为
 
“前缀参数”,意思是说这个参数是先于使用它的命令而输入的。
 
 
 
举例来说, C-u 8 C-f 会向前移动 8 个字符。
 
</pre>
 
 
 
===缓冲区、窗口与窗框===
 
 
<pre>
 
<pre>
  
2018年 01月 23日 星期二 21:03:14 CST 学习这个
+
#include        <stdio.h>//标准输入输出
 +
#include        <stdlib.h>//C标准函数库
 +
#include        <unistd.h>//Unix类系统定义符号常量
 +
#include        <fcntl.h>//定义了很多宏和open,fcntl函数原型
  
Emacs 启动后,窗框中默认只有一个窗口,但是使用 C-x 1 或 C-x 2 可以将其水平或竖直一分为二,这个分割过程可以无限的进行下去。每次被分割的窗口都是输入光标所在的窗口(也称为被激活的窗口)。使用 C-x o 可以在多个窗口中跳转。
+
#define BUFFERSIZE      4096//定义存储器容量
 +
#define COPYMODE        0644//定义复制的长度
  
由于 Emacs 在拆分窗口时,默认是水平或竖直均分,所以如果你希望将某个窗口调的宽一些,可 C-x } ;要使之窄一些,可 C-x { ;要使之高一些,可 C-x ^,但是要使之矮一些,貌似只能是激活该窗口下方的窗口,然后让下方的窗口高一些。这些窗口大小的调整方法,每次只能使得窗口的尺寸增大或减小一个字符的宽度或高度。如果你不想多次输入像 C-x ^ 这样的命令,那么可以用 C-u n C-x ^ 这样的组合键,其中 n 表示你要重复执行 C-x ^ 这样的命令 n 次。例如,要将当前窗口的高度增加 5 个字符的高度,只需 C-u 5 C-x ^ 即可。
+
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]);
  
C-u 最好要牢记,它的职能就是给某个组合键所绑定的 Emacs Lisp 函数传递一个参数值。 C-u 5 C-x ^ 表示向 C-x ^ 所绑定的 Emacs Lisp 函数传递参数值 5 ,而这个函数接受这个参数值之后,就会将窗口的高度增加 5 个字符的高度。
+
/*检查cp的第二个参数,复制的目的地址,用create在目的地址创建新文件,out_fd为open返回的描述符
   要查看按键被绑定到了哪个 Emacs Lisp 函数,只需 C-h k <RET> 按下你要查询的键 。 <RET> 表示回车键
+
  如果返回-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 )
  
如果觉得窗口太多,想关掉一些,那么关闭被激活的窗口的组合键是 C-x 0 。如果是图形界面的 Emacs,只需要鼠标右键点击窗口的模式行即可将该窗口关闭。我的建议是:能用键盘就不要用鼠标。
+
  write out_fd 文件描述符  buf 内存数据, n_chars 要写的字节数
  
要在某个窗口中打开或新建一个文件,可 C-x C-f 文件路径。
+
循环的把源文件写入目标文件
 +
*/
 +
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)
  
为了节省内存占用,请尽量使用 Emacs 的多窗口模式,不要打开一个又一个 Emacs
+
        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","");
 +
}
  
</pre>
+
/*不太明白为什么是指针了这里 evan  这个是用来输出错误信息的函数*/
 +
void oops(char *s1, char *s2)
 +
{
 +
    fprintf(stderr, "Error:%s", s1);
 +
    perror(s2); // 用来将上一个函数发生错误的原因输出到标准设备(stderr)
 +
    exit(1)
  
=== 文本编辑的正确姿势===
+
        }
用 Emacs 的正确姿势应该是永远保持能不用鼠标就不用鼠标的姿势!因此,你需要学会用键盘来控制光标在窗口中的位置。
 
<pre>
 
最基本的光标位置控制键如下所示:
 
  
              上一行 C-p
 
                    :
 
                    :
 
向左移 C-b .... 目前光标位置 .... 向右移 C-f
 
                    :
 
                    :
 
              下一行 C-n</span>
 
要记忆这几个键并不困难。 p 就是 previous(在...之前), n 就是 next, b 就是 backward, f 就是 forward,而 C 就是 Control……美国人民真会玩!
 
 
</pre>
 
</pre>
  
  
上述按键虽然简单易懂,但它们只适合小范围移动光标。在行内,可以用 <span style="color:red;">M-f 与 M-b </span>前后大步移动光标,步进单位对于英文而言是单词的长度,对于中文而言是两个标点符号的间距。
+
[https://www.cnblogs.com/cxy1616/p/6063463.html cp命令的编写最接受原书的了]
  
对于英文文本,若将光标快速移到行首或行尾,标准按键是<span style="color:red;"> C-a 或 C-e </span>但是对于中文而言,这对按键有着将光标被移到段首或段尾的奇异效果……如果偶尔忘记了这对按键,用 Home 或 End 键也未尝不可。<span style="color:red;"> M-a 与 M-e </span>则分别可将光标移动到句首或句尾。
+
[https://blog.csdn.net/hejishan/article/details/2250995  Unix程序设计:实现cp命令]
  
如果文档很长,用 <span style="color:red;">C-v 或 M-v </span>可实现向下或向上翻屏。如果偶尔忘记了这对按键,用键盘上的 PgUp 与 PgDn 翻页键也可行。
+
[https://blog.csdn.net/XSL1990/article/details/8250039 linux自己编写的 cp 命令像os的那个了 ]
  
跨度最大的光标移动键是 M-< 与 M-> ,可分别将光标移动到缓冲区的首部与尾部。
+
http://bbs.chinaunix.net/thread-247946-1-1.html
  
一旦掌握了上述这几个控制光标位置的按键,在 Emacs 中鼠标基本上就变得不是那么不可或缺了,更重要的是,这些按键能够帮助你更快速的选择文本。对于文档中的待选文本区域,用上述按键将光标移动到该区域的起始位置,然后用<span style="color:red;"> C-@ </span>标定选区之首,然后继续用上述按键将光标移动到选区之尾,这样就完成了文本的选取。
+
[https://blog.csdn.net/byxbai1989/article/details/17371197  linux cp命令源码]
  
 +
=== ls===
 +
data/c/example/unixeg/ls/
  
 你可能不知道怎么产生 C-@ 按键序列。普通键盘上,应该是摁住 Ctrl 键,然后再摁住 Shift 键,最后摁下数字 2 键,然后松开手。因为 @ 在 2 上面,需要 Shift 切换……
 
  
对于选中的文本,随后的操作无非是剪切、复制或删除。剪切,请用 C-w;复制,请用 M-w;删除,请用 Backspace。对于剪切或复制的文本,要粘帖在光标所在位置,请用 C-y……或者你也可以试着看看 C-y 之后再 M-y 有什么效果!
 
  
对文本进行了一段时间的编辑之后,要反悔的话,就用 C-_ 键执行 Undo 操作。
 
  
  要产生 C-_ 的按键序列,请参考上文所讲的 C-@ 的做法。
+
<pre>
建议现在就立刻将上述提到的每个按键都反复试验六、七次,以后就一直坚持使用它们……用不了几天也许就变成手指的本能了。忘掉鼠标吧,键盘可以解放你的双手,可以让你从畸形的鼠标手解脱,然后变成键盘手……因为你很快就会觉得左手的小指会有点酸痛!我会在下一节中拯救你的手。
+
ls命令实现过程用到的函数
  
===拯救你的左手小拇指===
+
函数原型:
如果感到左手的小手指有点疼,就不要再去用左手去摁 C-x C-s 这样的键了,你完全可以用右手的小指去摁键盘右侧的 Ctrl 键,然后左手相应的手指去摁 x 与 s 键
 
  
===将一段代码向右推===
+
1)int stat(const char *path, struct stat *buf);
[https://segmentfault.com/a/1190000003811296 将一段代码向右推20180124pm到这里 后面的还没看完]
 
  
===显示行号===
+
  stat函数 将path(文件)的属性信息保存在 buf结构体中
====临时显示行号或者取消行号====
 
在Emacs下执行 M-x linum-mode 来显示或者取消行号
 
M-x : Alt + x
 
输入: linum-mode
 
  
===跳转到指定行 ===
+
2)struct passwd *getpwuid(uid_t uid);
====临时====
 
M-x goto-line 然后回车  <line_number>
 
  ESC x goto-line 然后回车  <line_number>
 
  ESC x goto-char 然后回车  char
 
  
====长期====
+
  getpwuid函数是通过用户的uid查找用户的passwd数据,其中包括username
以在.emacs文件中定制一下(添加以下一行):
 
  
(define-key ctl-x-map "l" 'goto-line)  
+
3)struct group *getgrgid(gid_t gid);
  
然后每次在emacs中按C-x再按l,输入指定的行号就可以了。
+
  getgrgid函数通过用户组gid指定的组识别码逐一搜索组文件,找到时便将该组的数据以group结构返回。
  
http://blog.csdn.net/grey_csdn/article/details/78905862
+
4)struct tm *localtime(const time_t *timep);
http://bbs.csdn.net/topics/60028785
 
  
 +
  localtime函数把从1970-1-1零点零分到当前时间系统所偏移的秒数时间转换为日历时间 。并且此函数获得的tm结构体的时间,是已经进行过时区转化为本地时间。
  
=== 常用插件===
+
5)  DIR *opendir(const char *name);
记笔记,安排日程,那么毫无疑问Org-Mode是首选
 
  
[https://elloop.github.io/tools/2016-03-01/emacs-accumulate-5-packages-extensions Markdown]
+
  opendir()函数的作用是:打开目录句柄,返回一个文件描述符。
  
 +
6)  struct dirent *readdir(DIR *dirp);
  
=== 快捷键===
+
  readdir()函数读取一个目录文件描述符的信息,将信息返回到dirent结构体中。
<pre>
 
M-s : 新建一个buffer(缓冲区)
 
  
C-x O : 注意是大写的O,不是零,所以需要按住shift键再按o键。用于在缓冲区之间切换
+
https://www.cnblogs.com/lr-ting/archive/2012/06/19/2555207.html
 +
</pre>
  
C-g : 取消当前操作
 
  
C-x u : 回到上一步,相当于Undo
+
====第二版本的参考 ====
 +
[https://www.cnblogs.com/ghostwu/p/8253623.html  linux系统编程:自己动手写一个ls命令 ]
  
C-x  C-x : 变大写
+
https://cpp.hotexamples.com/examples/-/-/mode_to_letters/cpp-mode_to_letters-function-examples.html
  
C-x 3 : 把缓冲区(buffer)分为左右两个,新的一个缓冲区是复制当前的缓冲区 (可以执行多次,来分割出很多小窗口)
+
[https://www.cnblogs.com/wanghao-boke/p/11959330.html C语言实现Linux之ls]
  
C-x 2 : 把缓冲区(buffer)分为上下两个,新的一个缓冲区是复制当前的缓冲区 (可以执行多次,来分割出很多小窗口)
+
[https://www.cnblogs.com/lr-ting/archive/2012/06/19/2555207.html ubuntu 编写自己的ls命令]
  
M-w : 选中文字的情况是复制文字,而如果没有选中文字则是复制当前的一行
+
https://gitee.com/20145221/linux-besti-is-2016-2017-1-20145221/blob/master/src/week10/ls2.c
  
C-w : 选中文字的情况是剪切文字,而如果没有选中文字则是剪切当前的一行
 
  
M-x : 调出命令输入,可以在后面接命令,比如man,svn-status,等
+
[https://blog.csdn.net/egg1996911/article/details/72235353  用c语言实现Linux命令ls操作]
  
C-y : 黏贴
+
[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 命令的简单实现]
  
C-x C-s : 保存文本
+
[https://www.cnblogs.com/ikaros-521/p/11254332.html 高仿linux下的ls -l命令——C语言实现]
  
C-x C-f : 打开文件,如果文件不存在,则新建文件
 
  
C-x C-v : 打开一个文件,取代当前缓冲区
+
[http://www.doczj.com/doc/54bc4a27a5e9856a56126086.html 在linux下编写一个LS命令的小程序]
  
C-x k : 关闭当前缓冲区(buffer)
+
[https://www.cnblogs.com/lularible/p/14386358.html  Linux系统编程【3.1】——编写ls命令 ]
  
C-s : 向前搜索
+
[https://blog.csdn.net/lularible/article/details/113776163  Linux系统编程【3.2】——ls命令优化版和ls -l实现]
  
C-r : 向后搜索
+
[https://blog.nowcoder.net/n/9a48a7f697864e3bbdae2fe5bfcb0ef9 C 语言实现 Linux ls 命令]
  
C-x h : 全选
+
[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命令,但不同于书的]
  
C-v : 向下翻页
 
  
M-v : 向上翻页
+
https://m.linuxidc.com/Linux/2009-03/18778.htm
  
C-f : 前进一个字符
+
====简单版本的参考 ====
 +
https://github.com/fupengfei058/ls
  
C-b : 后退一个字符
+
http://www.voidcn.com/article/p-bzocmlpx-bxd.html
  
M-f : 前进一个单词
+
https://blog.csdn.net/qingshui23/article/details/53931555
  
M-b : 后退一个单词
+
https://blog.csdn.net/aonaigayiximasi/article/details/54019964
  
C-@ : 标记开始区域
+
=C IDE=
  
C-a : 移到行首
+
https://www.jetbrains.com/zh-cn/clion/
  
C-e : 移到行尾
+
[[Eclipse]]
  
M-a : 移到句首
+
[[Anjuta on linux]]
  
M-e : 移到句尾
+
https://atom.io/
  
M-< : 缓冲区头部
+
=pre main =
 +
<pre>
 +
init main( int argc, char *argv[]);
 +
argc 是命令行参数的数目 也包括自身 没有后台的参数 那么 argc=1
  
M-> : 缓冲区尾部
+
argv 指向参数的各个指针所构成的数组, argv[0]表示命令本身,argv[1] 表示第一个参数
  
M-g M-g,再输入数字 : 跳转到文本的第几行
+
argc 是argument count的缩写表示传入main函数中的参数个数,包括这个程序本身
  
C-x 0 : 关闭当前缓冲区
+
argv 是 argument vector的缩写表示传入main函数中的参数列表,其中argv[0]表示这个程序的名字; *argv[] 其实是地址
  
C-x C-c : 退出Emacs
+
第二个参数,char*型的argv[],为字符串数组,用来存放指向的字符串参数的指针数组,每一个元素指向一个参数。各成员含义如下:
 +
        argv[0]指向程序运行的全路径名
 +
        argv[1]指向在DOS命令行中执行程序名后的第一个字符串
  
 +
char  *argv[]是一个字符数组,其大小是int  argc,主要用于命令行参数  argv[]  参数,数组里每个元素代表一个参数;
  
emacs buffer read only
+
看代码的时候我最先不理解的就是main函数的定义:
Ctrl-x Ctrl-q
 
  
</pre>
+
int main(int argc, char *argv[]){}
 
 
[https://aifreedom.com/technology/112 Emacs快捷键列表]
 
 
 
链接:https://www.jianshu.com/p/732157b02ecc
 
  
==多窗口 ==
+
经查阅得知,argc是用来表示在命令行下输入命令时的参数个数,包括指令本身;argv[]是用来取得你输入的参数。针对具体指令分析如下(每一步解释由注释形式给出)。
  
 首先先明确下Emacs窗口的概念,我们双击Emacs图标打开程序见到的Windows窗口叫做Frame,包含了标题栏,菜单栏,工具栏,最下面的Mode Line和回显区域,而中间一大块显示文本的区域则是Window,实际上每个窗口都有自己的Mode Line。下文中我将称Frame为框,Window为窗口,这里和我们平时理解的Windows窗口有点区别。
+
由于main函数不能被其它函数调用, 因此不可能在程序内部取得实际值。那么,在何处把实参值赋予main函数的形参呢? 实际上,main函数的参数值是从操作系统命令行上获得的。当我们要运行一个可执行文件时,在DOS提示符下键入文件名,再输入实际参数即可把这些实参传送到main的形参中去。
  
  在Emacs里面,一个框可以分割出多个窗口,多个窗口可以显示同一个或者不同Buffer,但是一个窗口只能属于一个Frame。一个窗口同时也只能显示一个Buffer,但是同时打开两个窗口也能显示一个Buffer的不同部分,这两个窗口是同步的,就是说如果在一个窗口中对Buffer做了修改,在另一个窗口中可以立即表现出来。但在一个窗口中移动光标之类的操作不会影响另一个窗口。多缓冲中有当前缓冲这个概念,同样对于多窗口也有当前窗口,对于当前选中的窗口其Mode Line相对于其它窗口颜色会深一些。
+
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)
<span style="color:red;">
+
printf("%s\n",*++argv);
 +
}
  
  命令<span style="color:red;">C-x 2 (split-window-vertically) </span>垂直拆分窗口,就是把一个窗口上下等分为两个,拆分出来的窗口默认是显示当前Buffer。可以多次使用这个命令,会把一个窗口不停的两等分。
+
本例是显示命令行中输入的参数如果上例的可执行文件名为e24.exe,存放在A驱动器的盘内。
        对应也有水平拆分窗口的命令C-x 3 (split-window-horizontally),这两个命令也可以混合使用,如果你屏幕够大画个迷宫出来也不是不可能的。拆分命令还可以加参数,比如M-5 C-x 2就是说上面那个窗口只占5行,其余的位置都给下面的窗口。
+
因此输入的命令行为: C:\>a:e24 BASIC dBASE FORTRAN  
<pre>
+
则运行结果为:
  C-x o (other-window) 可以在多个窗口中切换,从上到下一个一个的来。使用参数来控制选中下面第几个窗口,想往回选的话参数设为负数。
+
BASIC
 +
dBASE
 +
FORTRAN
 +
  该行共有4个参数,执行main时,argc的初值即为4。argv的4个元素分为4个字符串的首地址。执行while语句,每循环一次 argv值减1,当argv等于1时停止循环,共循环三次, 因此共可输出三个参数。在printf函数中,由于打印项*++argv是先加1再打印, 故第一次打印的是argv[1]所指的字符串BASIC。第二、 三次循环分别打印后二个字符串。而参数e24是文件名,不必输出。
  
  C-M-v (scroll-other-window),用来滚动下一个窗口。
+
另外一个例子
  
  上一章我们看到有些命令加了C-x 4这个前缀,这一类命令都是用来操作多窗口的。
 
  
  C-x 4 b bufname (switch-to-buffer-other-window) 在另一个窗口打开缓冲。
+
</pre>
 
+
[https://blog.csdn.net/zhaozhiyuan111/article/details/104050729  c语言中argc和argv[ <nowiki>]</nowiki>的作用及用法]
  C-x 4 C-o bufname (display-buffer) 在另一个窗口打开缓冲,但不选中那个窗口。
 
  
  C-x 4 f filename (find-file-other-window) 在另一个窗口打开文件。
+
[https://blog.csdn.net/weixin_40539125/article/details/82585792 good和ls1.c差不多 C语言中 int main(int argc,char *argv[<nowiki>]</nowiki>)的两个参数详解]
  
  C-x 4 d directory (dired-other-window) 在另一个窗口打开文件夹。
+
https://zhuanlan.zhihu.com/p/267822985
  
  C-x 4 m (mail-other-window) 在另一个窗口写邮件。
+
https://blog.csdn.net/LYJ_viviani/article/details/51873961
  
  C-x 4 r filename (find-file-read-only-other-window) 在另一个窗口以只读方式打开文件。
+
[https://www.bilibili.com/video/av246420003/ c语言之argc和argv]
  
  这一类的命令默认是垂直拆分窗口。</pre>
+
=基础=
  
===重排窗口===
+
==计算机为什么要用二进制==
 +
Everything over Binary 模拟路转换成为数字电路
  
  窗口排的密密麻麻看上去肯定不舒服,这时使用    <span style="color:red;">C-x 0 (delete-window) </span> 来关闭当前窗口,需要注意的是窗口和缓冲是两个概念,关闭一个窗口对缓冲,或者我们正在编辑的文件没有任何影响。也可以使用C-x 1 (delete-other-windows) 关闭其它所有窗口。如果想连窗口打开的缓冲一并关掉使用C-x 4 0 (kill-buffer-and-window)。
+
https://blog.csdn.net/weixin_44296862/article/details/95277924
<pre>
 
  我们还可以对窗口的大小做些改变:
 
        C-x ^ (enlarge-window)让窗口变得高点,
 
        C-x { (shrink-window-horizontally) 这个是把窗口变窄,变宽的话是C-x } (enlarge-window-horizontally) ,C-x - (shrink-window-if-larger-than-buffer)这个看字面意思就能理解,如果窗口比缓冲大就缩小点,C-x + (balance-windows)这个命令和前面那个没有任何关系是将所有窗口变得一样高。
 
  
  最后再说一个在窗口中切换的命令,有时候窗口开的太多自己也记不住顺序,使用C-x o就会很麻烦。有一类命令能让你在上下左右切换当前窗口,M-x windmove-right 就是移到右边那个窗口,对应的"left","up“, "down",向四个方向都能移。</pre>
+
https://blog.csdn.net/c46550/article/details/90951557
  
===小结 ===
+
[https://wenku.baidu.com/view/77074002e009581b6ad9eb2c.html 一位全加器]
 +
=== signed char 类型的范围为 -128~127===
 
<pre>
 
<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>
 
</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.cnblogs.com/robertzml/archive/2010/03/24/1692737.html学习Emacs系列教程(十):多窗口]
+
[https://wenwen.sogou.com/z/q871193299.htm?ch=fromnewwenwen.pc char 其数值表示 范围的计算]
  
==org mode==
+
[https://www.bilibili.com/video/BV1Gt4y1D73z?from=search&seid=13506202580160943636 b站 C语言数据类型及数值范围]
Emacs 的 Org-mode 在一定程度上可以替代 OneNote,有些方面甚至更好
 
[[Org-mode]]
 
  
==reload configfile==
+
===原码 补码 反码 ===
 
 
emacs 打开~/.emacs的时候执行命令M-x eval-buffer,就可以使配置文件立即生效。
 
 
 
===配置===
 
 
<pre>
 
<pre>
https://github.com/gabrielelanaro/emacs-for-python
+
1.原码
https://github.com/jorgenschaefer/elpy
+
最高位表示符号位。剩下的位数,是这个数的绝对值的二进制
http://www.jesshamrick.com/2012/09/18/emacs-as-a-python-ide/
 
https://realpython.com/blog/python/emacs-the-best-python-editor
 
  
*day1
+
就比方说 一个完整的int型变量在内存中占的是4个字节,32位的编译器中 那么这时候他的二进制表示是00000000 00000000 00000000 00000000
pass 20170610
 
有空再详细的再看
 
  
:
+
所以
记得要添加在公司作的相关的emacs 笔记
 
  
 +
10的原码就是00000000 00000000 00000000 00001010
  
=======
+
那么负数的原码就是例如
这几天常用的几个重要使命
 
 
 
  
 +
-10的原码10000000 00000000 00000000 00001010
  
 +
符号位是第一位 0为正数 1为负数
  
重要快捷键(Important)
+
2.反码
C-k 删除一行
+
    正数的反码就是其原码.
C-g 停止当前运行/输入的命令
 
C-x u 撤销前一个命令
 
  
c-j 下称整个文件内容
+
    负数的反码就是在其原码的基础之上 符号位不变,其他位取反.
 +
   
 +
3.补码
  
emacs 菜单 用F10或者M-`。
+
    正数的补码就是其原码.
  
ctrl+g  q 退出 快速说明
+
    负数的补码就是在其反码的基础之上+1
 +
   
 +
</pre>
  
编辑器内显示行号可使用 M-x linum-mode 来开启。
+
[https://www.cnblogs.com/wangxiaoqi/p/6419676.html  C语言中的原码、反码和补码 ]
M-x 然后在最下面 输入 linum-mode
 
not try
 
q
 
  
获取帮助
+
[https://www.cnblogs.com/burningc/p/10741253.html C语言之原码、反码和补码 ]
ctrl+h k  要查看的快捷键盘
 
  
 +
[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>
  
学习基础 Elisp
 
  
ctrl+x  ctrl +b
 
  
 +
start  st 开始执行程序,在main函数的第一条语句前面停下来
 +
step      s  下一条语句,如果该语句为函数调用,则进入函数执行其中的第一条语句
 +
next    n  执行下一条语句,如果该语句为函数调用,不会进入函数内部执行(即不会一步步地调试函数内部语句)
  
C-x o:把光标在屏幕上的窗口间进行切换。记忆方法:其它(Other)窗口。
 
  
然后选择 *scratch*
 
  
运算 C-X  c - E
 
  
插件管理
 
  
c-x  o  other window  install
 
  
company
 
f2 打开配置文件
 
  
org-mode
 
  
major mode and minor mode (C-h m)
 
  
 +
使用例子  结合他看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>
  
;;evan配置文件
+
/*                                                                                                                                                                                         
;; ~/.emacs  行号什么 的 我是加到这个文件生效的
+
20答案是 Tuesday 因为列数定了是10                                                                                                                                                           
;;  ~/.emacs.d/emacs
+
21days[2] === days[2][10]                                                                                                                                                                   
 
+
22                                                                                                                                                                                           
;; 关闭工具栏,tool-bar-mode 即为一个 Minor Mode
+
23解说                                                                                                                                                                                       
(tool-bar-mode -1)
+
24days[2][0]=T                                                                                                                                                                               
 
+
25days[2][1]=u                                                                                                                                                                               
;; 关闭文件滑动控件
+
26days[2][2]=e                                                                                                                                                                               
(scroll-bar-mode -1)
+
27days[2][3]=s                                                                                                                                                                               
 
+
28days[2][4]=d                                                                                                                                                                              
;; 显示行号 试过 这个一定有效果
+
29days[2][5]=a                                                                                                                                                                               
(global-linum-mode 1)
+
30days[2][6]=y                                                                                                                                                                              
 
+
31days[2][7]=                                                                                                                                                                               
;; 更改光标的样式(不能生效,解决方案见第二集)
+
32days[2][8]=                                                                                                                                                                               
(setq cursor-type 'bar)
+
33days[2][9]=                                                                                                                                                                               
 
+
34                                                                                                                                                                                           
;; 关闭启动帮助画面
+
35               
(setq inhibit-splash-screen 1)
 
 
 
;; 关闭缩进 (第二天中被去除)
 
;; (electric-indent-mode -1)
 
 
 
;; 更改显示字体大小 16pt
 
;; http://stackoverflow.com/questions/294664/how-to-set-the-font-size-in-emacs
 
(set-face-attribute 'default nil :height 160)
 
 
 
;; 快速打开配置文件
 
(defun open-init-file()
 
  (interactive)
 
  (find-file "~/.emacs.d/init.el"))
 
 
 
;; 这一行代码,将函数 open-init-file 绑定到 <f2> 键上
 
(global-set-key (kbd "<f2>") 'open-init-file)
 
 
 
; 开启全局 Company 补全
 
(global-company-mode 1)
 
 
 
;; 作者用的  是t
 
3(global-company-mode t)
 
 
 
 
 
;; ~/.emacs  生效的居然是这个 2018
 
;; 在 mode line 上显示行列号
 
(setq column-number-mode 1)
 
(setq line-number-mode 1)
 
 
 
;;显示列号
 
(setq column-number-mode t)
 
 
 
;; 显示行号
 
(global-linum-mode 1)
 
 
 
;; 取消滚动栏,工具栏
 
(tool-bar-mode 0)
 
(menu-bar-mode 0)
 
(scroll-bar-mode 0)
 
 
 
;; 关闭emacs启动时的页面
 
(setq inhibit-startup-message 1)
 
(setq gnus-inhibit-startup-message 1)
 
;; 以 y/n代表 yes/no
 
(fset 'yes-or-no-p 'y-or-n-p)
 
;;; 设置备份策略
 
(setq make-backup-files t)
 
(setq kept-old-versions 2)
 
(setq kept-new-versions 2)
 
(setq delete-old-versions t)
 
(setq backup-directory-alist '(("" . "~/.emacsbackup")))
 
 
 
;; 公共插件配置
 
;; 设置 package system,这里使用 MELPA,里面的包可以说是应有尽有
 
(require 'package)
 
(add-to-list 'package-archives
 
            '("melpa" . "http://melpa.milkbox.net/packages/") t)
 
(package-initialize)
 
 
 
;;内置的package管理,emacs24以上的版本有用
 
(require 'package)
 
;;将melpa仓库地址加入到package-archives这个列表变量里面
 
(add-to-list 'package-archives
 
    '("melpa" . "http://melpa.org/packages/") t)
 
;;这个是国内一个elpa仓库镜像,速度更快一些,你懂得
 
(add-to-list 'package-archives
 
    '("popkit" . "http://elpa.popkit.org/packages/") t)
 
;;初始化package
 
(package-initialize)
 
;;更新仓库里面的package
 
(when (not package-archive-contents)
 
  (package-refresh-contents))
 
(custom-set-variables
 
;; custom-set-variables was added by Custom.
 
;; If you edit it by hand, you could mess it up, so be careful.
 
;; Your init file should contain only one such instance.
 
;; If there is more than one, they won't work right.
 
'(package-selected-packages (quote (company auto-complete autopair))))
 
(custom-set-faces
 
;; custom-set-faces was added by Custom.
 
;; If you edit it by hand, you could mess it up, so be careful.
 
;; Your init file should contain only one such instance.
 
;; If there is more than one, they won't work right.
 
)
 
 
 
 
 
 
 
I. 显示时间
 
.emacs加上:
 
(display-time-mode 1) ;; 常显
 
(setq display-time-24hr-format t) ;;格式
 
(setq display-time-day-and-date t) ;;显示时间、星期、日期
 
 
 
II. 隐藏菜单栏工具栏滚动条
 
.emacs加上:
 
(tool-bar-mode 0)
 
(menu-bar-mode 0)
 
(scroll-bar-mode 0)
 
;;注: 新版改成使用0,旧版使用nil的做法已失效,但 (set-scroll-bar-mode nil) 仍可使用
 
 
 
III. 关闭启动画面
 
.emacs加上:
 
(setq inhibit-startup-message t)
 
 
 
IV. highlight当前行
 
.emacs加上:
 
(global-hl-line-mode 1)
 
;;;; c mode ;;;;
 
(defvar xgp-cfsi-left-PAREN-old nil
 
  "Command used to input \"(\"")
 
(make-variable-buffer-local 'xgp-cfsi-left-PAREN-old)
 
 
 
(defun xgp-cfsi-modify-alist (alist term new)
 
  (let ((tl (assq term (symbol-value alist))))
 
    (if tl
 
        (setcdr tl new)
 
      (add-to-list alist (cons term new)))))
 
 
 
(defun xgp-cfsi (style)
 
  "Deciding whether using CFSI."
 
  (interactive "Style: ")
 
  (c-set-style style)
 
  (setq indent-tabs-mode
 
        nil
 
        c-hanging-semi&comma-criteria
 
        (quote (c-semi&comma-inside-parenlist)))
 
 
 
  (xgp-cfsi-modify-alist 'c-hanging-braces-alist 'class-open nil)
 
  (xgp-cfsi-modify-alist 'c-hanging-braces-alist 'class-close nil)
 
  (local-set-key " " 'self-insert-command))
 
 
 
(defun xgp-cfsi-erase-blanks ()
 
  "Erase all trivial blanks for CFSI."
 
  (interactive)
 
  (save-excursion
 
    (goto-char (point-min))
 
    (while (re-search-forward "[ \t]+$" nil t)
 
      (replace-match "" nil nil))))
 
 
 
(defun linux-c-mode()
 
  (define-key c-mode-map [return] 'newline-and-indent)
 
  (setq imenu-sort-function 'imenu--sort-by-name)
 
  (interactive)
 
  (imenu-add-menubar-index)
 
  (which-function-mode)
 
  (c-toggle-auto-state)
 
  (c-toggle-hungry-state)
 
  (setq indent-tabs-mode nil)
 
  (xgp-cfsi "linux"))
 
(add-hook 'c-mode-common-hook 'linux-c-mode)
 
;; 代码补全
 
(add-hook 'c-mode-hook 'company-mode)
 
(add-hook 'c++-mode-hook 'company-mode)
 
 
 
 
 
# other
 
如果要一次移动若干个单位,可以给命令加上数值参数,通过C-u命令,如:C-u 8 C-n就表示往下移8行,C-u 10 M-e表示往后移10句。不过C-u的参数对C-v和M-v命令而言有特殊,它不表示上下翻多少页,而是表示上下滚动多少行。注意与C-n的区别,C-u 8 C-n表示光标下移8行,屏幕不一定会滚动,而C-u 8 C-v,表示屏幕滚动8行,如果光标没有滚到屏幕外的话,光标位置不变。
 
如果不给C-u带上数值,则默认的值是4。比如C-u C-n就表示下移4行。这一特性还可以重复使用C-u C-u C-p就表示上移16行,C-u C-u C-u C-f表示右移64个字符。
 
前面讲了用C-g可以中断当前的命令,这次再补充一点,有时候C-g不灵时,可以按三次<Esc>键达到相同的目的。
 
 
</pre>
 
</pre>
 
+
==eg ==
====kali本本配置====
+
=== 石头剪刀布===
 
<pre>
 
<pre>
;;cat ~/.emacs
+
#include <stdio.h>
 
+
#include <stdlib.h>
;; 关闭工具栏,tool-bar-mode 即为一个 Minor Mode
+
#include <time.h>
(tool-bar-mode 0)
 
(menu-bar-mode 0)
 
(scroll-bar-mode 0)
 
(tool-bar-mode -1)
 
 
 
 
 
 
 
(setq column-number-mode t)
 
(setq column-number-mode 1)
 
(setq line-number-mode 1)
 
;; 显示行号
 
(global-linum-mode 1)
 
;; 在 mode line 上显示行列号
 
(setq column-number-mode 1)
 
(setq line-number-mode 1)
 
 
 
;;显示列号
 
(setq column-number-mode t)
 
  
;; 显示行号
+
int main(void)
(global-linum-mode 1)
+
{
 +
char gesture[3][10] = { "scissor", "stone", "cloth" };
 +
int man, computer, result, ret;
  
;; 取消滚动栏,工具栏
+
srand(time(NULL));
(tool-bar-mode 0)
+
while (1) {
(menu-bar-mode 0)
+
computer = rand() % 3;
(scroll-bar-mode 0)
+
  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]);
  
;; 关闭emacs启动时的页面
+
result = (man - computer + 4) % 3 - 1;
(setq inhibit-startup-message 1)
+
if (result > 0)
(setq gnus-inhibit-startup-message 1)
+
printf("You win!\n");
;; 以 y/n代表 yes/no
+
else if (result == 0)
(fset 'yes-or-no-p 'y-or-n-p)
+
printf("Draw!\n");
;;; 设置备份策略
+
else
(setq make-backup-files t)
+
printf("You lose!\n");
(setq kept-old-versions 2)
+
}
(setq kept-new-versions 2)
+
return 0;
(setq delete-old-versions t)
+
}
(setq backup-directory-alist '(("" . "~/.emacsbackup")))
 
  
;; 公共插件配置
 
;; 设置 package system,这里使用 MELPA,里面的包可以说是应有尽有
 
(require 'package)
 
(add-to-list 'package-archives
 
            '("melpa" . "http://melpa.milkbox.net/packages/") t)
 
(package-initialize)
 
  
;;内置的package管理,emacs24以上的版本有用
+
/*
(require 'package)
+
0、1、2三个整数分别是剪刀石头布在程序中的内部表示,用户也要求输入0、1或2,然后和计算机随机生成的0、1或2比胜负。这个程序的主体是一个死循环,需要按Ctrl-C退出程序。以往我们写的程序都只有打印输出,在这个程序中我们第一次碰到处理用户输入的情况。在这里只是简单解释一下,以后再细讲。scanf("%d", &man)这个调用的功能是等待用户输入一个整数并回车,这个整数会被scanf函数保存在man这个整型变量里。如果用户输入合法(输入的确实是整数而不是字符串),则scanf函数返回1,表示成功读入一个数据。但即使用户输入的是整数,我们还需要进一步检查是不是在0~2的范围内,写程序时对用户输入要格外小心,用户有可能输入任何数据,他才不管游戏规则是什么。
;;将melpa仓库地址加入到package-archives这个列表变量里面
 
(add-to-list 'package-archives
 
    '("melpa" . "http://melpa.org/packages/") t)
 
;;这个是国内一个elpa仓库镜像,速度更快一些,你懂得
 
(add-to-list 'package-archives
 
    '("popkit" . "http://elpa.popkit.org/packages/") t)
 
;;初始化package
 
(package-initialize)
 
;;更新仓库里面的package
 
(when (not package-archive-contents)
 
  (package-refresh-contents))
 
(custom-set-variables
 
;; custom-set-variables was added by Custom.
 
;; If you edit it by hand, you could mess it up, so be careful.
 
;; Your init file should contain only one such instance.
 
;; If there is more than one, they won't work right.
 
'(package-selected-packages (quote (company auto-complete autopair))))
 
(custom-set-faces
 
;; custom-set-faces was added by Custom.
 
;; If you edit it by hand, you could mess it up, so be careful.
 
;; Your init file should contain only one such instance.
 
;; If there is more than one, they won't work right.
 
)
 
  
;;;; c mode ;;;;
+
和printf类似,scanf也可以用%c、%f、%s等转换说明。如果在传给scanf的第一个参数中用%d、%f或%c表示读入一个整数、浮点数或字符,则第二个参数的形式应该是&运算符加一个相应类型的变量名,表示读进来的数存到这个变量中;如果在第一个参数中用%s读入一个字符串,则第二个参数应该是数组名,数组名前面不加&,因为数组类型做右值时自动转换成指针类型,而scanf后面这个参数要的就是指针类型,在第 10 章 gdb有scanf读入字符串的例子。&运算符的作用也是得到一个指针类型,这个运算符以后再详细解释。
(defvar xgp-cfsi-left-PAREN-old nil
 
  "Command used to input \"(\"")
 
(make-variable-buffer-local 'xgp-cfsi-left-PAREN-old)
 
  
(defun xgp-cfsi-modify-alist (alist term new)
+
留给读者的思考问题是:(man - computer + 4) % 3 - 1这个神奇的表达式是如何比较出0、1、2这三个数字在“剪刀石头布”意义上的大小的
  (let ((tl (assq term (symbol-value alist))))
+
*/
    (if tl
 
        (setcdr tl new)
 
      (add-to-list alist (cons term new)))))
 
  
(defun xgp-cfsi (style)
 
  "Deciding whether using CFSI."
 
  (interactive "Style: ")
 
  (c-set-style style)
 
  (setq indent-tabs-mode
 
        nil
 
        c-hanging-semi&comma-criteria
 
        (quote (c-semi&comma-inside-parenlist)))
 
 
  (xgp-cfsi-modify-alist 'c-hanging-braces-alist 'class-open nil)
 
  (xgp-cfsi-modify-alist 'c-hanging-braces-alist 'class-close nil)
 
  (local-set-key " " 'self-insert-command))
 
 
(defun xgp-cfsi-erase-blanks ()
 
  "Erase all trivial blanks for CFSI."
 
  (interactive)
 
  (save-excursion
 
    (goto-char (point-min))
 
    (while (re-search-forward "[ \t]+$" nil t)
 
      (replace-match "" nil nil))))
 
 
(defun linux-c-mode()
 
  (define-key c-mode-map [return] 'newline-and-indent)
 
  (setq imenu-sort-function 'imenu--sort-by-name)
 
  (interactive)
 
  (imenu-add-menubar-index)
 
  (which-function-mode)
 
  (c-toggle-auto-state)
 
  (c-toggle-hungry-state)
 
  (setq indent-tabs-mode nil)
 
  (xgp-cfsi "linux"))
 
(add-hook 'c-mode-common-hook 'linux-c-mode)
 
;; 代码补全
 
(add-hook 'c-mode-hook 'company-mode)
 
(add-hook 'c++-mode-hook 'company-mode)
 
 
;; py
 
(setq tab-width 4)
 
(set-variable 'python-indent-offset 4)
 
;;(set-variable 'python-indent-guess-indent-offset nil)
 
 
</pre>
 
</pre>
  
 +
[https://wenku.baidu.com/view/55e520da5022aaea998f0f5e.html 石头剪刀布_C语言]
  
[https://blog.csdn.net/qq_40875035/article/details/82883325 emacs配置]
+
https://blog.csdn.net/guoqingchun/article/details/8104197
  
== 不错的配置 c什么都包括了==
 
<pre>
 
mv ~/.emacs.d ~/.emacs.d.bak
 
git clone --depth 1 https://github.com/seagle0128/.emacs.d.git ~/.emacs.d
 
</pre>
 
  
有空好好的看一下
+
===Linux下C语言获取目录中的文件列表 ===
https://github.com/seagle0128/.emacs.d
 
 
 
 
 
 
 
=== c 常用命令===
 
emacs中很多命令都对C语言格式支持,补充几个命令M-x c-mode  当无法识别C语法格式的文件,可以强制打开C mode语法高亮C-M-p  跳转到}或)匹配的括号C-M-n  跳转到(或{匹配的括号M-x indent-region 自动缩进选定的区域C-c C-c 注释掉整个区域C-u C-c C-c 取消注释C-c C-u  跳转到前面的一个#ifdef C-c C-n  跳转到宏的开头或结尾C-c C-e 扩展宏编译排错:C-x ` (出错信息中)下一个错误,一个窗口显示错误信息,另一个显示源码的出错位置C-c C-c 转到出错位置调试:启动gdb调试器后,光标在源码文件缓冲区中时:C-x SPC 在当前行设置断点gdb在emacs中调用调试并不完美,有时候会出一些异常的情况。工作中如果emacs作为IDE用的话,一般在远程终端字符环境下更合适,如果作为专业的图形化IDE,codeblock等更合适,eclipse+CDT也是一种选择。
 
 
 
=== c 配置文件===
 
 
<pre>
 
<pre>
;; 配置文件 for or c ++
+
/*
;; cat ~/.emacs
+
  * dir.c
 
+
  *
;; 在 mode line 上显示行列号
+
Linux下C语言获取目录中的文件列表  https://www.cnblogs.com/dgwblog/p/12158373.html
(setq column-number-mode 1)
+
http://c.biancheng.net/cpp/html/1548.html  怎样使用C语言列出某个目录下的文件?
(setq line-number-mode 1)
+
*  Created on: 2020年11月2日
 
+
*      Author: evan
;;显示列号
+
*/
(setq column-number-mode t)
+
#include <sys/types.h>
 
+
#include <dirent.h>
;; 显示行号
+
#include <unistd.h>
(global-linum-mode 1)
+
#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;
 +
}
  
;; 取消滚动栏,工具栏
 
;;(tool-bar-mode 0)
 
;;(menu-bar-mode 0)
 
;;(scroll-bar-mode 0)
 
  
;; 关闭emacs启动时的页面
+
/* 结果
(setq inhibit-startup-message 1)
+
*
(setq gnus-inhibit-startup-message 1)
+
d_name:.
;; 以 y/n代表 yes/no
+
d_name:..
(fset 'yes-or-no-p 'y-or-n-p)
+
d_name:1.py
;;; 设置备份策略
+
d_name:22.py
(setq make-backup-files t)
 
(setq kept-old-versions 2)
 
(setq kept-new-versions 2)
 
(setq delete-old-versions t)
 
(setq backup-directory-alist '(("" . "~/.emacsbackup")))
 
  
;; 公共插件配置
+
*/
;; 设置 package system,这里使用 MELPA,里面的包可以说是应有尽有
 
(require 'package)
 
(add-to-list 'package-archives
 
            '("melpa" . "http://melpa.milkbox.net/packages/") t)
 
(package-initialize)
 
  
  
 
</pre>
 
</pre>
  
[https://segmentfault.com/a/1190000003878553 Emacs 中 C/C++ 编程基本环境配置2018]
+
=排序与查找=
 
+
==插入排序 ==
[https://blog.csdn.net/cuijianzhongswust/article/details/10313865 将Emacs配置成一个C/C++的IDE编程环境]
 
 
 
==from tour ==
 
 
<pre>
 
<pre>
#这些笔记完全作到wiki么 会不会太多 而没有重点的感觉 
+
#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 起初的值
 +
////采用顺序查找方式找到插入的位置,在查找的同时,将数组中的元素进行后移操作,给插入元素腾出空间 ?
  
* 如果 EMACS 失去响应(IF EMACS STOPS RESPONDING)
+
while (i >= 0 && a[i] > key) {
-----------------------------------------------
+
a[i+1] = a[i];
如果 Emacs 对你的命令失去响应,你可以用 C-g 来安全地终止这条命令。C-g
+
--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>
  
C-g 还可以取消数字参数和只输入到一半的命令。
 
  
>> 输入 C-u 100 设定一个值为 100 的数字参数,然后按 C-g。
+
===算法的时间复杂度分析===
  现在再按 C-f,光标应该只会移动一个字符,因为你已经用 C-g 取消了参数。
+
则总的执行时间粗略估计是(n-1)*(c1+c2+c5+m*(c3+c4))。 #怎么来的呢  线性函数  不记得了 要补一下
  
如果你不小心按了一下 <ESC>,你也可以用 C-g 来取消它。
+
[https://blog.csdn.net/qq_25775935/article/details/88724130 插入排序算法及C语言实现]
【这个说法似乎有问题,因为按照这个按键顺序输入的应该是 C-M-g。
 
取消 <ESC> 的正确做法是再连按两次 <ESC>。】
 
  
  
* 插入与删除(INSERTING AND DELETING)
+
==11.4 归并排序==
--------------------------------------
+
递归实现 归并排序
  
,大部分的 Emacs 命令都可以指定重复次数,这其中也包括输入字符的
 
命令。重复执行输入字符的命令实际上就是输入多个相同的字符。
 
  
>>  试试 C-u 8 *,这将会插入 ********。
 
  
好,现在你应该已经掌握了最基本的的文本插入和修改功能,其实删除还可以
 
“以词为单位”进行,下面是一个关于“删除”操作的小结:
 
  
        <DEL>        删除光标前的一个字符
+
===see also===
        C-d          删除光标后的一个字符
 
  
M-<DEL>      移除光标前的一个词
 
        M-d          移除光标后的一个词
 
  
        C-k          移除从光标到“行尾”间的字符
+
还有下一节 ?
        M-k          移除从光标到“句尾”间的字符
 
  
【可能你已经注意到了“删除(delete)”和“移除(kill)”的用词区别,后
+
[https://www.bilibili.com/video/av73101599?from=search&seid=6748303640916868853 4-5 通过归并排序算法深入理解递归]
文会有详细说明。】
 
  
注意“<DEL> 和 C-d”还有“M-<DEL> 和 M-d”是根据前述惯例从 C-f和 M-f 衍生的
 
出来的(其实<DEL>不是控制字符,我们先忽略这一点)。C-k和 M-k 的关系在
 
某种程度上与 C-e 和 M-e 一样――如果把“一行”和“一句”作一个类比的话。
 
  
 +
非递归
 +
https://blog.csdn.net/zjy900507/article/details/80530336
  
你也可以用一种通用的办法来移除缓冲区里的任何一部分:首先把光标移动到你
+
=chapter 12 栈与队列=
想要移除的区域的一端,然后按 C-<SPC>(<SPC>指空格)【注意,C-<SPC> 往
+
==堆栈==
往被中文用户设定成输入法热键,如果这样,C-<SPC> 就被系统拦截而无法传递
+
http://docs.linuxtone.org/ebooks/C&CPP/c/ch12s02.html
给 Emacs 了,在这种情况下可以使用C-@。】,然后将光标移动到你准备移除的
+
==3. 深度优先搜索 ==
文字的另一端。这个时候, Emacs 会高亮光标和你按下 C-<SPC> 之间的文本。
+
未看
最后,按下 C-w 。这样就可以把位于这两点之间的所有文字移除了。
+
http://akaedu.github.io/book/ch12s03.html
  
  
注意,“移除(kill)”和“删除(delete)”的不同在于被移除的东西可以被重新
+
=第 13 章 计算机中数的表示=
插入(在任何位置),而被删除的就不能使用相同的方法重新插入了(不过可以
+
==1. 为什么计算机用二进制计数==
通过撤销一个删除命令来做到,后文会提到)。
 
  
 +
=第 14 章 计算机中数的表示=
  
重新插入被移除的文字称为“召回(yank)
+
[http://c.biancheng.net/cpp/html/437.html c语言基本数据类型short、int、long、char、float、double]
  
 +
[https://www.cnblogs.com/luofay/p/6070613.html  C语言的基本数据类型 ]
  
召回的命令是 C-y。它会在光标所在处插入你最后移除的文字。
 
  
 +
[https://www.php.cn/csharp-article-443107.html c语言char是什么意思]
 +
== 二进制制转十进制==
 +
<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 ,这个问题甚至有的工作几年的程序员都模棱两可,因为没有深入思考过,只知道书上这么写。于是,我不得不深入思考一下这个被许多人忽视的问题。
  
C-y 可以召回最近一次移除的内容,那如何召回前几次移除的内容呢?它们当然
+
对于无符号整数,很简单,全部位都表示数值,比如 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 。
没有丢,你可以用 M-y 来召回它们。在用 C-y 召回最近移除的文字之后,紧接
 
着再按 M-y 就可以召回再前一次被移除的内容,再按一次 M-y 又可以召回再上
 
一次的……连续使用 M-y 直到找到你想要召回的东西,然后什么也不用做,继续
 
编辑就行了。
 
  
如果连续按 M-y 很多次,你可能会回到起始点,也就是最近移除的文字。
 
【看得出这实际上是一个环。】
 
  
>> 移除一行,移动一下光标,然后再移除另外一行。
+
但是对于有符号整数,二进制的最高位表示正负,不表示数值,最高位为 0 时表示正数,为 1 时表示负数,这样一来,能表示数值的就剩下( n-1 )位了,
  按 C-y 将第二次移除的那行召回来。
+
比如 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 啊,下面就剖析一下这个惊人的奇葩。 加上反码 看到这里
  紧接着再按 M-y,它将会被第一次移除的那行取代。
 
  试着再按几下 M-y 看看会发生什么。
 
  再继续,直到第二行被召回来,然后再做个几次。
 
  如果感兴趣,你可以试着给 M-y 指定一个正的或负的参数。
 
  
  
* 撤销(UNDO)
+
再普及一下计算机内部整数存储形式,大家都知道计算机内部是以二进制来存贮数值的,无符号整数会用全部为来存储,有符号的整数,最高位当做符号位 ,其余为表示数值。
--------------
+
</pre>
如果你修改了一段文字,又觉得改得不好,可以用 undo 命令进行撤销:C-/。
 
另外, C-x u 和 C-/ 完全一样,但是按起来有些麻烦。
 
  
* 文件(FILE)
+
=第 17 章=
--------------
+
==3. 设备==
 +
http://akaedu.github.io/book/ch17s03.html
  
 +
=4. MMU=
 +
按照离CPU由近到远的顺序依次是CPU寄存器、Cache、内存、硬盘,越靠近CPU的存储器容量越小但访问速度越快
 +
http://akaedu.github.io/book/ch17s04.html
  
* 缓冲区(BUFFER)
+
=Memory Hierarchy=
------------------
+
http://akaedu.github.io/book/ch17s05.html
  
你可以用 C-x C-f 找到并打开第二个文件,但第一个文件仍然在 Emacs 中。要
+
=附录 A. 字符编码=
切回第一个文件,一种办法是再用一次 C-x C-f。这样,你就可以在 Emacs 中同
+
20191112
时打开多个文件。
+
字符编码的高位 左边是也
不过还有一个更简单的办法,那就是用 C-x b。用这条命
 
令,你必须输入缓冲区的名称。(如果是返回默认的第一个不用名称)
 
  
 +
=如何学习c=
  
>> 通过输入 C-x C-f foo <Return> 创建一个名为“foo”的文件。
+
== mongoose 开源http库==
  然后输入 C-x b TUTORIAL.cn <Return> 回到这里。
+
有空学习这个作为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>
  
C-x s  保存多个缓冲区
+
定义函数:char *ctime(const time_t *timep);
  
 +
函数说明:ctime()将参数timep 所指的time_t 结构中的信息转换成真实世界所使用的时间日期表示方法,然后将结果以字符串形态返回。此函数已经由时区转换成当地时间,字符串格式为"Wed Jun 30 21 :49 :08 1993\n"。
  
输入 C-x 1 离开缓冲区列表
+
注意:若再调用相关的时间日期函数,此字符串可能会被破坏。
 
 
 
* 命令集扩展(EXTENDING THE COMMAND SET)
 
-----------------------------------------
 
        C-x    字符扩展。  C-x 之后输入另一个字符或者组合键。
 
        M-x    命令名扩展。M-x 之后输入一个命令名。
 
  
C-z 可以暂时离开 Emacs――当然,你还可以再回来。
+
https://www.runoob.com/cprogramming/c-function-ctime.html
 
C-x 的扩展命令有很多,下面列出的是你已经学过的:
 
 
 
        C-x C-f        寻找文件。
 
C-x C-s        保存文件。
 
        C-x C-b        列出缓冲区。
 
        C-x C-c        离开 Emacs。
 
C-x 1          关掉其它所有窗格,只保留一个。
 
        C-x u          撤销。
 
 
 
 
 
 
 
* 自动保存(AUTO SAVE)
 
-----------------------
 
 
 
所以,假如不幸真的发生了,你大可以从容地打开原来的文件(注意不是自动保
 
存文件)然后输入 M-x recover file <Return> 来恢复你的自动保存文件。在
 
提示确认的时候,输入 yes<Return>。
 
 
 
 
 
* 状态栏(MODE LINE)
 
---------------------
 
 
 
“L” 和其后的数字给出了光标所在行的行号。
 
 
 
最开头的星号(*)表示你已经对文字做过改动。刚刚打开的文件肯定没有被改动
 
过,所以状态栏上显示的不是星号而是短线(-)。
 
 
 
状态栏上小括号里的内容告诉你当前正在使用的编辑模式。缺省的模式是
 
Fundamental,就是你现在正在使用的这个。它是一种“主模式”。
 
 
 
 
 
用 C-l C-l 将本行带到屏幕的最上方。
 
 
 
 
 
 
 
* 搜索(SEARCHING)
 
-------------------
 
 
 
C-s 是向前搜索,C-r 是向后搜索。不过手别这么快!别着急试。
 
 
 
在按下 C-s 之后,回显区里会有“I-search”字样出现,表明目前 Emacs 正处
 
于“渐进搜索”状态,并等待你输入搜索字串。按 <Return> 可以结束搜索。
 
 
 
>> 输入 C-s 开始一个搜索。注意敲慢一点,一次输入一个字符。
 
  慢慢输入“ccusor”这个词,每敲一个字都停顿一下并观察光标。
 
  现在你应该已曾经找到“ccusor”这个词了。
 
>> 再按一次 C-s,搜索下一个“ccusor”出现的位置。
 
>> 现在按四次 <DEL> ,看看光标是如何移动的。
 
>> 敲 <Return> 结束搜索。
 
 
 
看仔细了么?在一次渐进式搜索中,Emacs 会尝试跳到搜索目标出现的位置。要
 
跳到下一个命中位置,就再按一次 C-s。如果找不到目标,Emacs 会发出“哔”
 
的一声,告诉你搜索失败。在整个过程中,都可以用 C-g 来终止搜索。【你会发
 
现 C-g 会让光标回到搜索开始的位置,而 <Return> 则让光标留在搜索结果上,
 
这是很有用的功能。】
 
 
 
在渐进式搜索中,按 <DEL> 会“撤回”到最近一次搜索的命中位置。如果之前没
 
有一个命中, <DEL> 会抹去搜索字符串中的最后一个字符。比如你已经输入了
 
“c”,光标就停在“c”第一次出现的位置,再输入“u”,光标停在“cu”第一次出现
 
的位置,这时再按 <DEL> ,“u”就从搜索字串中消失了,然后光标会回到“c”第
 
一次出现的位置。
 
 
 
 
 
* 多窗格(MULTIPLE WINDOWS)
 
----------------------------
 
 
 
> 移动光标到这一行,然后输入 C-l C-l。
 
 
 
>> 现在输入 C-x 2,它会将屏幕划分成两个窗格。
 
  这两个窗格里显示的都是本篇快速指南,而光标则停留在上方的窗格里。
 
 
 
>> 试试用 C-M-v 滚动下方的窗格。
 
  (如果你并没有 META 键,用 ESC C-v 也可以。)
 
  【向上滚动是 C-M-S-v,也就是同时按住 CONTROL、META 和 SHIFT 再按 v】
 
 
 
>> 输入 C-x o(“o”指的是“其它(other)”),
 
  将光标转移到下方的窗格。
 
 
 
>> 在下方的窗格中,用 C-v 和 M-v 来滚动。
 
  同时继续在上方的窗格里阅读这些指导。
 
 
 
 
 
C-M-v 是一个 CONTROL-META 组合键。如果你有 META (或 Alt)键的话,可以
 
同时按住CONTROL 和 META 键并输入 v。CONTROL 和 META 键先按哪个都可以,
 
因为它们只是用来“修饰(modify)”你输入的字符的。
 
 
 
 
 
>> (在上方窗格里)输入 C-x 1 关掉下方窗格。
 
 
 
(如果你在下方的窗格里输入 C-x 1,那么就会关掉上方的窗格。你可以把这个
 
命令看成是“只保留一个窗格”――就是我们正在编辑的这个。)
 
 
 
不同的窗格可以显示不同的缓冲区。如果你在一个窗格里用 C-x C-f 打开了一个
 
文件,另一个窗格并不会发生什么变化。任何一个窗格里都可以用来打开文件。
 
 
 
 
 
* 多窗口(MULTIPLE FRAMES)
 
------------------
 
 
 
 
 
* 更多精彩(MORE FEATURES)
 
---------------------------
 
 
 
想学习更多的使用技巧,Emacs 使用手册(manual)值得一读。你可以读纸版的
 
书,也可以在 Emacs 中读(可以从 Help 菜单进入或者按 C-h r)。提两个你
 
可能会很感兴趣的功能吧,一个是可以帮你少敲键盘的 completion(自动补全),
 
另一个是方便文件处理的 dired(目录编辑)。
 
 
 
Completion 可以替你节省不必要的键盘输入。比如说你想切换到 *Message* 缓
 
冲区,你就可以用 C-x b *M<Tab> 来完成。只要 Emacs 能够根据你已经输入的
 
文字确定你想要输入的内容,它就会自动帮你补齐。Completion 也可用于命令
 
名和文件名。有关 Completion 的详细说明可以在 Emacs Info 中的
 
“Completion”一节里找到。
 
 
 
Dired 能够在一个缓冲区里列出一个目录下的所有文件(可以选择是否也列出子
 
目录),然后你可以在这个文件列表上完成对文件的移动、访问、重命名或删除
 
等等操作。Dired 也在 Emacs 使用手册中有详细介绍,参见“Dired”一节。
 
 
 
 
 
下面列出主要术语的译词对照,并给出注释说明:
 
 
 
    command              命令
 
    cursor                光标
 
    scrolling            滚动
 
    numeric argument      数字参数
 
    window                窗格 [1]
 
    insert                插入
 
    delete                删除 [2]
 
    kill                  移除 [2]
 
    yank                  召回 [2]
 
    undo                  撤销
 
    file                  文件
 
    buffer                缓冲区
 
    minibuffer            小缓冲
 
    echo area            回显区
 
    mode line            状态栏
 
    search                搜索
 
    incremental search    渐进式搜索 [3]
 
 
 
 
 
20180313 ln 792
 
here
 
 
 
 
 
M-x replace-string ENTER search-string ENTER 替换
 
 
 
 
 
 
用 <Return> 结束文件名的输入
 
Return 这里是什么意思呢  回车么 
 
 
 
 
 
Alt + x
 
输入: linum-mode
 
 
 
 
 
 
 
emacs中如何跳到指定行
 
 
 
M-x goto-line 然后回车  <line_number>
 
 
 
以在.emacs文件中定制一下(添加以下一行):
 
 
 
(define-key ctl-x-map "l" 'goto-line)
 
 
 
 
 
然后每次在emacs中按C-x再按l,输入指定的行号就可以了。
 
 
 
http://blog.csdn.net/grey_csdn/article/details/78905862
 
http://bbs.csdn.net/topics/60028785
 
 
</pre>
 
</pre>
==package ==
+
==strcmp  ==
 
<pre>
 
<pre>
 +
C/C++函数,比较两个字符串
  
也可以使用命令M-x list-packages获取插件列表,使用C-s找到 软件名    i  - 选择要安装的包  例如叫 elpy 来安装
+
strcmp函数是string compare(字符串比较)的缩写,用于比较两个字符串并根据比较结果返回整数
  
 +
设这两个字符串为str1,str2,
  
;内置的package管理,emacs24以上的版本有用
+
若str1==str2,则返回零;
(require 'package)
 
;;将melpa仓库地址加入到package-archives这个列表变量里面
 
(add-to-list 'package-archives
 
    '("melpa" . "http://melpa.org/packages/") t)
 
;;这个是国内一个elpa仓库镜像,速度更快一些,你懂得
 
(add-to-list 'package-archives
 
    '("popkit" . "http://elpa.popkit.org/packages/") t)
 
;;初始化package
 
(package-initialize)
 
;;更新仓库里面的package
 
(when (not package-archive-contents)
 
  (package-refresh-contents))
 
</pre>
 
  
===常用操作===
+
若str1<str2,则返回负数;
<pre>
 
#软件包安装
 
Alt+x list-packages
 
  
可以先用C-s向下搜索  autopair
+
若str1>str2,则返回正数。
找到后 回来后 按i再按x就下载到本地了。然后打开emacs的配置文件init.el,在里面添加下面:
 
 
 
常用快捷键
 
i  - 选择要安装的包
 
d - 选择要删除的包
 
U - 升级已安装的包
 
x  - 执行操作
 
d - 选择要删除的包
 
 
</pre>
 
</pre>
 +
[https://baike.baidu.com/item/strcmp/5495571 strcmp]
  
[http://longlycode.github.io/2016/02/02/emacs%E5%AE%8C%E5%85%A8%E8%A1%A5%E5%AE%8C%E8%AE%A1%E5%88%92-%E4%B8%89/ emacs完全补完计划(三)——package的引入和管理]
+
https://baike.so.com/doc/61175-64376.html
 
 
  
==emacs-gtk==
+
==C library function - remove()==
 
<pre>
 
<pre>
让选中可以高亮
+
/*
自己打开随便看下 居然就看到了 不错
+
* remvoe.c
emacs-gtk --> Options --> customize emacs  --> custom themes  -->  个人感觉 adwaita 还不错
+
*
save theme settings
+
*  Created on: 2020年11月30日
</pre>
+
  *      Author: evan
== 高级==
+
*/
 +
#include <stdio.h>
 +
#include<string.h>
  
 +
int main() {
 +
int ret;
 +
FILE *fp;
 +
char filename[] = "file.txt";  // 这个是什么意思  定义一个 数组 ? 是的 
  
[https://panqiincs.me/2015/06/15/edit-markdown-with-emacs/ 用Emacs编辑Markdown ]
+
fp = fopen(filename,"w");
  
 +
fprintf(fp,"%s", "THis is tutor \n");
 +
fprintf(fp,"%s", "ln2 THis is tutor");
 +
fclose(fp);
  
[https://www.jianshu.com/p/e4e015096fb4 Emacs有这些配置足矣]
+
//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);
  
===Edit mediawiki sites from emacs ===
+
}
[https://github.com/hexmode/mediawiki-el mediawiki.el -- Edit mediawiki sites from emacs]
 
  
==emacs 学习==
 
  
https://link.zhihu.com/?target=https%3A//github.com/emacs-tw/awesome-emacs
+
</pre>
0.我雖然是看man過來的,但是這份名單,如果早知道應該會輕鬆很多。--- update1.從starter-kit入手把,爬梯子出去看redguardtoo的獨立博客,你會發現吊爆了。當然他的一年的文章一定要看。而且可以git下來,revert到剛開始的commit,一個個commit看。2. 還有就是各種折騰。各種動手把,拒絕其他一切的編輯器。3.改鍵位,乾脆去買了HHKB也可以,如你很土豪。4.看書呀,學elisp,這個階段你要看田春冰河的,李殺的博客了。學着寫個插件把。PS.學習emacs會改變你編程思維的,包括你軟件開發的工作流。lisp系各種優雅.上面編號不分先後。
 
  
[https://www.zhihu.com/question/19783016 怎样学习 Emacs]
+
== C语言perror函数的作用 ==
 +
<pre>
 +
 不可以掉了这个头文件,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 字符串,包含了一个自定义消息,将显示在原本的错误消息之前
  
[https://www.cnblogs.com/holbrook/archive/2012/02/15/2357336.html Emacs学习笔记(1):初学者的学习计划]
+
#include <stdio.h>   
 +
int main(void)   
 +
{   
 +
FILE *fp ;   
 +
fp = fopen( "/root/noexitfile", "r+" );   
 +
if ( NULL == fp )  ?
 +
{   
 +
perror("/root/noexitfile");   //下面有这个输出
 +
}   
 +
return 0;   
 +
}
  
[https://www.cnblogs.com/holbrook/archive/2012/03/06/2381636.html Emacs学习笔记(7):简单的配置]
+
运行结果
 +
[root@localhost io]# gcc perror.c   
 +
[root@localhost io]# ./a.out   
 +
/root/noexitfile: No such file or directory
  
[https://www.cnblogs.com/holbrook/archive/2012/02/15/2357335.html Emacs学习笔记(2): 初识Emacs]
+
</pre>
  
[https://www.cnblogs.com/holbrook/tag/emacs/ emacs 学习标签 ]
 
  
  
[https://zklhp.github.io/2016/06/18/What-I-do-with-Emacs/ 我用Emacs干什么?为什么用Emacs?]
+
[https://blog.csdn.net/ypist/article/details/7886209  linux下 C语言perror函数的作用]
  
== 参考==
+
https://www.cnblogs.com/yujianfei/p/8973867.html
[https://my.oschina.net/alphajay/blog/7737 Emacs快捷键的总结]
 
  
[https://segmentfault.com/a/1190000003811296 走近emacs 201801]
+
https://www.runoob.com/cprogramming/c-function-perror.html
  
[http://blog.csdn.net/cherylnatsu/article/details/6536959  Emacs常用命令快速参考]
 
  
[https://www.ibm.com/developerworks/cn/education/aix/emacs1-1/index.html 学习 Emacs 的基础知识]
+
==c语言实现rm命令 or 删除==
 +
<pre>
 +
头文件:#include <stdio.h>
  
[https://github.com/redguardtoo/mastering-emacs-in-one-year-guide 一年成为 Emacs 高手 ]
+
remove()函数用于删除指定的文件,其原型如下:
 +
    int remove(char * filename);
  
http://emacser.com/
+
【参数】filename为要删除的文件名,可以为一目录。如果参数filename 为一文件,则调用unlink()处理;若参数filename 为一目录,则调用rmdir()来处理。
 
 
[https://linux265.com/soft/3857.html  Emacs - 代码编辑神器之一]
 
 
 
 
 
Emacs 入门
 
https://i.linuxtoy.org/docs/guide/ch25.html
 
 
 
[https://www.emacswiki.org/emacs/%E9%A6%96%E9%A1%B5 emacswiki]
 
 
 
[https://www.jianshu.com/p/732157b02ecc Emacs,最强编辑器,没有之一]
 
 
 
Emacs org mode
 
https://i.linuxtoy.org/docs/guide/ch32s03.html#id3155525
 
 
 
 
 
https://www.emacswiki.org/emacs?interface=zh-cn
 
 
 
https://www.cnblogs.com/blfshiye/p/4566900.html
 
  
 +
【返回值】成功则返回0,失败则返回-1,错误原因存于errno。
 +
</pre>
  
https://www.gnu.org/software/emacs/manual/html_node/efaq/Installing-Emacs.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()函数:删除文件或目录]
  
[https://www.gnu.org/software/emacs/tour/index.html A Guided Tour of Emacs]
+
[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()函数删除文件或目录]
  
Emacs - the Best Python Editor https://realpython.com/blog/python/emacs-the-best-python-editor/
+
[https://blog.csdn.net/qq_38074673/article/details/98047329  c语言实现rm命令,删除指定文件或目录]
  
Emacs:最好的Python编辑器  http://codingpy.com/article/emacs-the-best-python-editor/
+
==C语言access()函数:判断是否具有存取文件的权限==
  
[https://wiki.archlinux.org/index.php/Emacs_(%E7%AE%80%E4%BD%93%E4%B8%AD%E6%96%87)#.E8.BF.90.E8.A1.8CEmacs Emacs (简体中文)]
 
  
[http://ergoemacs.org/emacs/emacs_package_system.html How to Install Packages Using ELPA, MELPA]
+
[http://c.biancheng.net/cpp/html/303.html C语言access()函数:判断是否具有存取文件的权限]
  
[http://www.cnblogs.com/xiaosha/p/3366422.html emacs python 配置]
+
[https://blog.csdn.net/eager7/article/details/8131169  C语言中access函数]
  
[https://maskray.me/blog/2015-09-18-conversion-to-emacs 皈依Emacs]
+
[https://www.runoob.com/cprogramming/c-arrays.html C 数组]
  
[https://elloop.github.io/tools/2016-03-01/emacs-accumulate-5-packages-extensions  【积水成渊-逐步定制自己的Emacs神器】3:为Emacs安装扩展]
 
  
===wiki ===
+
=进阶=
Wiki编辑器, 通过 Yaoddmuse 几乎能支持所有的Wiki格式, 实时语法高亮, 你不用担心保存以后确发现格式错了
+
==十个经典的C开源项目代码==
 +
[https://blog.51cto.com/chinalx1/2143904 十个经典的C开源项目代码]
  
https://www.emacswiki.org/emacs/Yaoddmuse
 
  
[https://blog.csdn.net/freexploit/article/details/572224 用Emacs Wiki帮你写Blog]
+
=2021=
  
===2019===
 
  
[https://www.cnblogs.com/robertzml/archive/2009/09/10/1564108.html 学习Emacs系列教程(一):基本使用]
+
[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语言目录操作]
  
[http://longlycode.github.io/2016/01/28/emacs%E5%AE%8C%E5%85%A8%E8%A1%A5%E5%AE%8C%E8%AE%A1%E5%88%92-%E4%B8%80-1/ emacs完全补完计划(一)——嘴炮和入门]
+
[http://www.freecplus.net C语言技术网]
  
[http://jixiuf.github.io/blog/emacs-%E8%87%AA%E5%B8%A6%E7%9A%84%E7%AE%80%E5%8D%95%E5%85%A5%E9%97%A8%E6%95%99%E7%A8%8B%28tutorial%29/ emacs 自带的简单入门教程(TUTORIAL)]
+
[https://www.cnblogs.com/qigaohua/p/5838263.html      博客园  C语言中关于对目录的操作 ]
  
[http://www.cnblogs.com/Open_Source/archive/2011/07/17/2108747.html Org-mode 简明手册]
+
=书=
 +
[https://www.codetd.com/article/2162329 《Linux环境C程序设计(第2版)徐诚》pdf 附下载链接]
  
[http://blog.csdn.net/grey_csdn/article/category/7131378/5 小灰笔记 emacs]
+
http://www.txtepub.com/105693.html
  
[https://www.jianshu.com/p/b4cf683c25f3 从零开始——Emacs 安装配置使用教程 2015]
+
=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语言简要语法指南]
  
[https://zhuanlan.zhihu.com/p/87527003 编辑器终结者:vim与emacs双剑合璧]
+
https://wiki.ubuntu.com.cn/Compiling_C
  
[https://www.zhihu.com/question/30955165 Emacs有什么优点,用Emacs写程序真的比IDE更方便吗]
+
[https://wiki.ubuntu.com.cn/Gcchowto Gcc-howto]
  
=== 参考 for python===
+
=c++=
[http://codingpy.com/article/emacs-the-best-python-editor/ Emacs:最好的Python编辑器]
 
=== 参考 for c===
 
[https://segmentfault.com/a/1190000003878553 Emacs 中 C/C++ 编程基本环境配置]
 
  
[http://txgcwm.github.io/blog/2013/07/20/jiang-emacspei-zhi-cheng-%5B%3F%5D-ge-c-slash-c-plus-plus-de-idebian-cheng-huan-jing/#top 将Emacs配置成一个C/C++的IDE编程环境]
+
[https://zh.wikipedia.org/wiki/C%2B%2B c++ zh.wikipedia.org]
  
[http://blog.guorongfei.com/2014/09/16/emacs-c-cpp-python-config/ Emacs C、C++、Python 编程的简单配置]
+
https://isocpp.org/
[[category:ops]] [[category:emacs]]
+
[[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/