思维改变一切

渐渐喜欢上了linux下的c，不过学习的有点急于求成了。
client
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <netdb.h>
#include <netinet/in.h>
#include <sys/socket.h>
#define PORT 3490
#define MAXDATESIZE 5000
int main(int argc, char ** argv)
{
    int sockfd,nbytes;
    char buf[1024];
    struct hostent *he;
    struct sockaddr_in srvaddr;
    if(argc!=2) {
        perror(”Usage:client host name”);
        exit(1);
    }
    if((he=gethostbyname(argv[1]))==NULL){
        perror(”get host by name is wrong”);
        exit(1);
    }
    if((sockfd=socket(AF_INET,SOCK_STREAM,0)) == -1) {
   
        perror(”create socket is wrong “);
        exit(1);
    }
    bzero(&srvaddr,sizeof(srvaddr));
    srvaddr.sin_family = AF_INET;
    srvaddr.sin_port = htons(PORT);
    srvaddr.sin_addr=*((struct in_addr *)he->h_addr);
    if(connect(sockfd,(struct sockaddr *)&srvaddr,sizeof(struct sockaddr)) ==-1) {
        perror(”connetc is wrong”);
        exit(1);
   
    }
    if((nbytes == read(sockfd,buf,MAXDATESIZE)) == -1) {
        perror(”read error”);
        exit(1);
    }
    buf[nbytes] =”0″;
    printf(”read : %s”,buf);
    close(sockfd);

}

#include <stdio.h>
#include <stdlib.h>
#include <error.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/wait.h>
#define MYPORT 3490
#define BACKLOG 5
main() {
    int sockfd ,new_fd;
    struct sockaddr_in srvaddr;
    struct sockaddr_in cliaddr;
    int sin_size;
    if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1) {
        perror(”socket error”);
        exit(1);
    }
    bzero(&srvaddr,sizeof(srvaddr));
    srvaddr.sin_family = AF_INET;
    srvaddr.sin_port = htons(MYPORT);
    if(bind(sockfd,(struct sockaddr *)&srvaddr,sizeof(struct sockaddr)) == -1) {
        perror(”bind error”);
        exit(1);
    }
    if(listen(sockfd,BACKLOG)==-1) {
        perror(”listen error”);
        exit(1);
    }
    for(;;) {
        sin_size = sizeof(struct sockaddr_in);
        if((new_fd=accept(sockfd,(struct sockaddr*)&cliaddr,&sin_size)) == -1) {
            perror(”accept error”);
            exit(1);
        }
        printf(”server : got connection from %s “,inet_ntoa(cliaddr.sin_addr));
        if(write(new_fd,”hello network”,14)==-1)
          perror(”write error”);
        close(new_fd);

    }
    close(sockfd);

}

　　什么是好的程序员？是不是懂得很多技术细节？还是懂底层编程？还是编程速度比较快？

　　我觉得都不是。对于一些技术细节来说和底层的技术，只要看帮助，查资料就能找到，对

　　于速度快，只要编得多也就熟能生巧了。

　　我认为好的程序员应该有以下几方面的素质：

　　1、有专研精神，勤学善问、举一反三。

　　2、积极向上的态度，有创造性思维。

　　3、与人积极交流沟通的能力，有团队精神。

　　4、谦虚谨慎，戒骄戒燥。

　　5、写出的代码质量高。包括：代码的稳定、易读、规范、易维护、专业。

　　这些都是程序员的修养，这里我想谈谈“编程修养”，也就是上述中的第5点。我觉得，如

　　果我要了解一个作者，我会看他所写的小说，如果我要了解一个画家，我会看他所画的图

　　画，如果我要了解一个工人，我会看他所做出来的产品，同样，如果我要了解一个程序员

　　，我想首先我最想看的就是他的程序代码，程序代码可以看出一个程序员的素质和修养，

　　程序就像一个作品，有素质有修养的程序员的作品必然是一图精美的图画，一首美妙的歌

　　曲，一本赏心悦目的小说。

　　我看过许多程序，没有注释，没有缩进，胡乱命名的变量名，等等，等等，我把这种人统

　　称为没有修养的程序，这种程序员，是在做创造性的工作吗？不，完全就是在搞破坏，他

　　们与其说是在编程，还不如说是在对源程序进行“加密”，这种程序员，见一个就应该开

　　除一个，因为他编的程序所创造的价值，远远小于需要在上面进行维护的价值。

　　程序员应该有程序员的修养，那怕再累，再没时间，也要对自己的程序负责。我宁可要那

　　种动作慢，技术一般，但有良好的写程序风格的程序员，也不要那种技术强、动作快的“

　　搞破坏”的程序员。有句话叫“字如其人”，我想从程序上也能看出一个程序员的优劣。

　　因为，程序是程序员的作品，作品的好坏直截关系到程序员的声誉和素质。而“修养”好

　　的程序员一定能做出好的程序和软件。

　　有个成语叫“独具匠心”，意思是做什么都要做得很专业，很用心，如果你要做一个“匠

　　”，也就是造诣高深的人，那么，从一件很简单的作品上就能看出你有没有“匠”的特性

　　，我觉得做一个程序员不难，但要做一个“程序匠”就不简单了。编程序很简单，但编出

　　有质量的程序就难了。

　　我在这里不讨论过深的技术，我只想在一些容易让人忽略的东西上说一说，虽然这些东西

　　可能很细微，但如果你不注意这些细微之处的话，那么他将会极大的影响你的整个软件质

　　量，以及整个软件程的实施，所谓“千里之堤，毁于蚁穴”。

　　“细微之处见真功”，真正能体现一个程序的功底恰恰在这些细微之处。

　　这就是程序员的——编程修养。我总结了在用C/C++语言（主要是C语言）进行程序写作上

　　的三十二个“修养”，通过这些，你可以写出质量高的程序，同时也会让看你程序的人渍

　　渍称道，那些看过你程序的人一定会说：“这个人的编程修养不错”。

　　————————————————————————

　　01、版权和版本

　　02、缩进、空格、换行、空行、对齐

　　03、程序注释

　　04、函数的[in][out]参数

　　05、对系统调用的返回进行判断

　　06、if 语句对出错的处理

　　07、头文件中的#ifndef

　　08、在堆上分配内存

　　09、变量的初始化

　　10、h和c文件的使用

　　11、出错信息的处理

　　12、常用函数和循环语句中的被计算量

　　13、函数名和变量名的命名

　　14、函数的传值和传指针

　　15、修改别人程序的修养

　　16、把相同或近乎相同的代码形成函数和宏

　　17、表达式中的括号

　　18、函数参数中的const

　　19、函数的参数个数

　　20、函数的返回类型，不要省略

　　21、goto语句的使用

　　22、宏的使用

　　23、static的使用

　　24、函数中的代码尺寸

　　25、typedef的使用

　　26、为常量声明宏

　　27、不要为宏定义加分号

　　28、||和&&的语句执行顺序

　　29、尽量用for而不是while做循环

　　30、请sizeof类型而不是变量

　　31、不要忽略Warning

　　32、书写Debug版和Release版的程序

　　21、goto语究 使劲

　　22、宏的使用

　　23、static的使用

　　24、函数中的代码尺寸

　　25、typedef的使用

　　26、为常量声明宏

　　27、不要为宏定义加分号

　　28、||和&&的语句执行顺序

　　29、尽量用for而不是while做循环

　　30、请sizeof类型而不是变量

　　31、不要忽略Warning

　　32、书写Debug版和Release版的程序

　　————————————————————————

　　1、版权和版本

　　———————

　　好的程序员会给自己的每个函数，每个文件，都注上版权和版本。

　　对于C/C++的文件，文件头应该有类似这样的注释：

　　/************************************************************************

　　*

　　* 文件名：network.c

　　*

　　* 文件描述：网络通讯函数集

　　*

　　* 创建人： Hao Chen, 2003年2月3日

　　*

　　* 版本号：1.0

　　*

　　* 修改记录：

　　*

　　*

　　************************************************************************/

　　而对于函数来说，应该也有类似于这样的注释：

　　/*================================================================

　　*

　　* 函 数 名：XXX

　　*

　　* 参 数：

　　*

　　* type name [IN] : descripts

　　*

　　* 功能描述:

　　*

　　* …………..

　　*

　　* 返 回 值：成功TRUE，失败FALSE

　　*

　　* 抛出异常：

　　*

　　* 作 者：ChenHao 2003/4/2

　　*

　　*

　　================================================================*/

　　这样的描述可以让人对一个函数，一个文件有一个总体的认识，对代码的易读性和易维护

　　性有很大的好处。这是好的作品产生的开始。

　　2、缩进、空格、换行、空行、对齐

　　————————————————

　　i) 缩进应该是每个程序都会做的，只要学程序过程序就应该知道这个，但是我仍然看过不

　　缩进的程序，或是乱缩进的程序，如果你的公司还有写程序不缩进的程序员，请毫不犹豫

　　的开除他吧，并以破坏源码罪起诉他，还要他赔偿读过他程序的人的精神损失费。缩进，

　　这是不成文规矩，我再重提一下吧，一个缩进一般是一个TAB键或是4个空格。（最好用TAB

　　键）

　　ii) 空格。空格能给程序代来什么损失吗？没有，有效的利用空格可以让你的程序读进来

　　更加赏心悦目。而不一堆表达式挤在一起。看看下面的代码：

　　ha=(ha*128+*key++)%tabPtr->size;

　　ha = ( ha * 128 + *key++ ) % tabPtr->size;

　　有空格和没有空格的感觉不一样吧。一般来说，语句中要在各个操作符间加空格，函

　　数调用时，要以各个参数间加空格。如下面这种加空格的和不加的：

　　if ((hProc=OpenProcess(PROCESS_ALL_ACCESS,FALSE,pid))==NULL){

　　}

　　if ( ( hProc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid) ) == NULL ){

　　}

　　iii) 换行。不要把语句都写在一行上，这样很不好。如：

　　for(i=0;i<len;i++) if((a[i]<’0′||a[i]>’9′)&&(a[i]<’a'||a[i]>’z')) break;

　　我拷，这种即无空格，又无换行的程序在写什么啊？加上空格和换行吧。

　　for ( i=0; i<len; i++) {

　　if ( ( a[i] < ‘0′ || a[i] > ‘9′ ) &&

　　( a[i] < ‘a’ || a[i] > ‘z’ ) ) {

　　break;

　　}

　　}

　　好多了吧？有时候，函数参数多的时候，最好也换行，如：

　　CreateProcess(

　　NULL,

　　cmdbuf,

　　NULL,

　　NULL,

　　bInhH,

　　dwCrtFlags,

　　envbuf,

　　NULL,

　　&siStartInfo,

　　&prInfo

　　);

　　条件语句也应该在必要时换行：

　　if ( ch >= ‘0′ || ch <= ‘9′ ||

　　ch >= ‘a’ || ch <= ‘z’ ||

　　ch >= ‘A’ || ch <= ‘Z’ )

　　iv) 空行。不要不加空行，空行可以区分不同的程序块，程序块间，最好加上空行。如：

　　HANDLE hProcess;

　　PROCESS_T procInfo;

　　/* open the process handle */

　　if((hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid)) == NULL)

　　{

　　return LSE_MISC_SYS;

　　}

　　memset(&procInfo, 0, sizeof(procInfo));

　　procInfo.idProc = pid;

　　procInfo.hdProc = hProcess;

　　procInfo.misc |= MSCAVA_PROC;

　　return(0);

　　v) 对齐。用TAB键对齐你的一些变量的声明或注释，一样会让你的程序好看一些。如：

　　typedef struct _pt_man_t_ {

　　int numProc; /* Number of processes */

　　int maxProc; /* Max Number of processes */

　　int maxProc; /* Max Number of processes */

　　int numEvnt; /* Number of events */

　　int maxEvnt; /* Max Number of events */

　　HANDLE* pHndEvnt; /* Array of events */

　　DWORD timeout; /* Time out interval */

　　HANDLE hPipe; /* Namedpipe */

　　TCHAR usr[MAXUSR];/* User name of the process */

　　int numMsg; /* Number of Message */

　　int Msg[MAXMSG];/* Space for intro process communicate */

　　} PT_MAN_T;

　　怎么样？感觉不错吧。

　　这里主要讲述了如果写出让人赏心悦目的代码，好看的代码会让人的心情愉快，读起代码

　　也就不累，工整、整洁的程序代码，通常更让人欢迎，也更让人称道。现在的硬盘空间这

　　么大，不要让你的代码挤在一起，这样它们会抱怨你虐待它们的。好了，用“缩进、空格

　　、换行、空行、对齐”装饰你的代码吧，让他们从没有秩序的土匪中变成一排排整齐有秩

　　序的正规部队吧。

　　3、程序注释

　　3、程序注释

　　——————

　　养成写程序注释的习惯，这是每个程序员所必须要做的工作。我看过那种几千行，却居然

　　没有一行注释的程序。这就如同在公路上驾车却没有路标一样。用不了多久，连自己都不

　　知道自己的意图了，还要花上几倍的时间才看明白，这种浪费别人和自己的时间的人，是

　　最为可耻的人。

　　是的，你也许会说，你会写注释，真的吗？注释的书写也能看出一个程序员的功底。一般

　　来说你需要至少写这些地方的注释：文件的注释、函数的注释、变量的注释、算法的注释

　　、功能块的程序注释。主要就是记录你这段程序是干什么的？你的意图是什么？你这个变

　　量是用来做什么的？等等。

　　不要以为注释好写，有一些算法是很难说或写出来的，只能意会，我承认有这种情况的时

　　候，但你也要写出来，正好可以训练一下自己的表达能力。而表达能力正是那种闷头搞技

　　术的技术人员最缺的，你有再高的技术，如果你表达能力不行，你的技术将不能得到充分

　　的发挥。因为，这是一个团队的时代。

　　好了，说几个注释的技术细节：

　　i) 对于行注释（“//”）比块注释（“/* */”）要好的说法，我并不是很同意。因为一

　　些老版本的C编译器并不支持行注释，所以为了你的程序的移植性，请你还是尽量使用块注

　　释。

　　ii) 你也许会为块注释的不能嵌套而不爽，那么你可以用预编译来完成这个功能。使用“#

　　if 0”和“#endif”括起来的代码，将不被编译，而且还可以嵌套。

　　4、函数的[in][out]参数

　　———————————

　　我经常看到这样的程序：

　　FuncName(char* str)

　　{

　　int len = strlen(str);

　　…..

　　}

　　char*

　　GetUserName(struct user* pUser)

　　{

　　return pUser->name;

　　}

　　不！请不要这样做。

　　你应该先判断一下传进来的那个指针是不是为空。如果传进来的指针为空的话，那么，你

　　的一个大的系统就会因为这一个小的函数而崩溃。一种更好的技术是使用断言（assert）

　　，这里我就不多说这些技术细节了。当然，如果是在C++中，引用要比指针好得多，但你也

　　需要对各个参数进行检查。

　　写有参数的函数时，首要工作，就是要对传进来的所有参数进行合法性检查。而对于传出

　　的参数也应该进行检查，这个动作当然应该在函数的外部，也就是说，调用完一个函数后

　　，应该对其传出的值进行检查。

　　当然，检查会浪费一点时间，但为了整个系统不至于出现“非法操作”或是“Core Dump”

　　的系统级的错误，多花这点时间还是很值得的。

　　5、对系统调用的返回进行判断

　　——————————————

　　继续上一条，对于一些系统调用，比如打开文件，我经常看到，许多程序员对fopen返回的

　　指针不做任何判断，就直接使用了。然后发现文件的内容怎么也读出不，或是怎么也写不

　　进去。还是判断一下吧：

　　fp = fopen(”log.txt”, “a”);

　　if ( fp == NULL ){

　　printf(”Error: open file error”);

　　return FALSE;

　　}

　　其它还有许多啦，比如：socket返回的socket号，malloc返回的内存。请对这些系统调用

　　返回的东西进行判断。

　　6、if 语句对出错的处理

　　———————————

　　我看见你说了，这有什么好说的。还是先看一段程序代码吧。

　　if ( ch >= ‘0′ && ch <= ‘9′ ){

　　/* 正常处理代码 */

　　}else{

　　/* 输出错误信息 */

　　printf(”error ……”);

　　return ( FALSE );

　　}

　　这种结构很不好，特别是如果“正常处理代码”很长时，对于这种情况，最好不要用else

　　。先判断错误，如：

　　if ( ch < ‘0′ || ch > ‘9′ ){

　　/* 输出错误信息 */

　　printf(”error ……”);

　　return ( FALSE );

　　}

　　/* 正常处理代码 */

　　……

　　这样的结构，不是很清楚吗？突出了错误的条件，让别人在使用你的函数的时候，第一眼

　　就能看到不合法的条件，于是就会更下意识的避免。

　　7、头文件中的#ifndef

　　——————————

　　千万不要忽略了头件的中的#ifndef，这是一个很关键的东西。比如你有两个C文件，这两

　　个C文件都include了同一个头文件。而编译时，这两个C文件要一同编译成一个可运行文件

　　，于是问题来了，大量的声明冲突。

　　还是把头文件的内容都放在#ifndef和#endif中吧。不管你的头文件会不会被多个文件引用

　　管你的头文件会不会被多个文件引用

　　，你都要加上这个。一般格式是这样的：

　　#ifndef <标识>

　　#define <标识>

　　……

　　……

　　#endif

　　<标识>在理论上来说可以是自由命名的，但每个头文件的这个“标识”都应该是唯一的。

　　标识的命名规则一般是头文件名全大写，前后加下划线，并把文件名中的“.”也变成下划

　　线，如：stdio.h

　　#ifndef _STDIO_H_

　　#define _STDIO_H_

　　……

　　#endif

　　（BTW：预编译有多很有用的功能。你会用预编译吗？）

　　（BTW：预编译有多很有用的功能。你会用预编译吗？）

　　8、在堆上分配内存

　　—————————

　　可能许多人对内存分配上的“栈 stack”和“堆 heap”还不是很明白。包括一些科班出身

　　的人也不明白这两个概念。我不想过多的说这两个东西。简单的来讲，stack上分配的内存

　　系统自动释放，heap上分配的内存，系统不释放，哪怕程序退出，那一块内存还是在那里

　　。stack一般是静态分配内存，heap上一般是动态分配内存。

　　由malloc系统函数分配的内存就是从堆上分配内存。从堆上分配的内存一定要自己释放。

　　用free释放，不然就是术语——“内存泄露”（或是“内存漏洞”）—— Memory Leak。

　　于是，系统的可分配内存会随malloc越来越少，直到系统崩溃。还是来看看“栈内存”和

　　“堆内存”的差别吧。

　　栈内存分配

　　—————

　　char*

　　AllocStrFromStack()

　　{

　　char pstr[100];

　　return pstr;

　　}

　　堆内存分配

　　—————

　　char*

　　AllocStrFromHeap(int len)

　　{

　　char *pstr;

　　if ( len <= 0 ) return NULL;

　　return ( char* ) malloc( len );

　　}

　　对于第一个函数，那块pstr的内存在函数返回时就被系统释放了。于是所返回的char*什么

　　也没有。而对于第二个函数，是从堆上分配内存，所以哪怕是程序退出时，也不释放，所

　　以第二个函数的返回的内存没有问题，可以被使用。但一定要调用free释放，不然就是Mem

　　ory Leak！

　　在堆上分配内存很容易造成内存泄漏，这是C/C++的最大的“克星”，如果你的程序要稳定

　　，那么就不要出现Memory Leak。所以，我还是要在这里千叮咛万嘱付，在使用malloc系统

　　蛑龈叮谑褂胢alloc系统

　　函数（包括calloc，realloc）时千万要小心。

　　记得有一个UNIX上的服务应用程序，大约有几百的C文件编译而成，运行测试良好，等使用

　　时，每隔三个月系统就是down一次，搞得许多人焦头烂额，查不出问题所在。只好，每隔

　　两个月人工手动重启系统一次。出现这种问题就是Memery Leak在做怪了，在C/C++中这种

　　问题总是会发生，所以你一定要小心。一个Rational的检测工作——Purify，可以帮你测

　　试你的程序有没有内存泄漏。

　　我保证，做过许多C/C++的工程的程序员，都会对malloc或是new有些感冒。当你什么时候

　　在使用malloc和new时，有一种轻度的紧张和惶恐的感觉时，你就具备了这方面的修养了。

　　对于malloc和free的操作有以下规则：

　　1) 配对使用，有一个malloc，就应该有一个free。（C++中对应为new和delete）

　　2) 尽量在同一层上使用，不要像上面那种，malloc在函数中，而free在函数外。最好在同

　　一调用层上使用这两个函数。

　　3) malloc分配的内存一定要初始化。free后的指针一定要设置为NULL。

　　注：虽然现在的操作系统（如：UNIX和Win2k/NT）都有进程内存跟踪机制，也就是如果你

　　有没有释放的内存，操作系统会帮你释放。但操作系统依然不会释放你程序中所有产生了M

　　emory Leak的内存，所以，最好还是你自己来做这个工作。（有的时候不知不觉就出现Mem

　　ory Leak了，而且在几百万行的代码中找无异于海底捞针，Rational有一个工具叫Purify

　　蛐械拇胫姓椅抟煊诤５桌陶耄琑ational有一个工具叫Purify

　　，可能很好的帮你检查程序中的Memory Leak）

　　9、变量的初始化

　　————————

　　接上一条，变量一定要被初始化再使用。C/C++编译器在这个方面不会像JAVA一样帮你初始

　　化，这一切都需要你自己来，如果你使用了没有初始化的变量，结果未知。好的程序员从

　　来都会在使用变量前初始化变量的。如：

　　1) 对malloc分配的内存进行memset清零操作。（可以使用calloc分配一块全零的内存

　　）

　　2) 对一些栈上分配的struct或数组进行初始化。（最好也是清零）

　　不过话又说回来了，初始化也会造成系统运行时间有一定的开销，所以，也不要对所有的

　　变量做初始化，这个也没有意义。好的程序员知道哪些变量需要初始化，哪些则不需要。

　　如：以下这种情况，则不需要。

　　char *pstr; /* 一个字符串 */

　　pstr = ( char* ) malloc( 50 );

　　if ( pstr == NULL ) exit(0);

　　strcpy( pstr, “Hello Wrold” );

　　strcpy( pstr, “Hello Wrold” );

　　但如果是下面一种情况，最好进行内存初始化。（指针是一个危险的东西，一定要初始化

　　）

　　char **pstr; /* 一个字符串数组 */

　　pstr = ( char** ) malloc( 50 );

　　if ( pstr == NULL ) exit(0);

　　/* 让数组中的指针都指向NULL */

　　memset( pstr, 0, 50*sizeof(char*) );

　　而对于全局变量，和静态变量，一定要声明时就初始化。因为你不知道它第一次会在哪里

　　被使用。所以使用前初始这些变量是比较不现实的，一定要在声明时就初始化它们。如：

　　Links *plnk = NULL; /* 对于全局变量plnk初始化为NULL */

　　10、h和c文件的使用

　　—————————

　　—————————

　　H文件和C文件怎么用呢？一般来说，H文件中是declare（声明），C文件中是define（定义

　　）。因为C文件要编译成库文件（Windows下是.obj/.lib，UNIX下是.o/.a），如果别人要

　　使用你的函数，那么就要引用你的H文件，所以，H文件中一般是变量、宏定义、枚举、结

　　构和函数接口的声明，就像一个接口说明文件一样。而C文件则是实现细节。

　　H文件和C文件最大的用处就是声明和实现分开。这个特性应该是公认的了，但我仍然看到

　　有些人喜欢把函数写在H文件中，这种习惯很不好。（如果是C++话，对于其模板函数，在V

　　C中只有把实现和声明都写在一个文件中，因为VC不支持export关键字）。而且，如果在H

　　文件中写上函数的实现，你还得在makefile中把头文件的依赖关系也加上去，这个就会让

　　你的makefile很不规范。

　　最后，有一个最需要注意的地方就是：带初始化的全局变量不要放在H文件中！

　　例如有一个处理错误信息的结构：

　　char* errmsg[] = {

　　/* 0 */ “No error”,

　　/* 1 */ “Open file error”,

　　/* 2 */ “Failed in sending/receiving a message”,

　　/* 3 */ …

复制

#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#define BUFFER_SIZE 1024
int main(int argc,char **argv)
{
  int from_fd,to_fd;
  int bytes_read,bytes_write;
  char buffer[BUFFER_SIZE];
  char *ptr;
  if(argc!=3)
  {
    fprintf(stderr,”Usage:%s fromfile tofilea”,argv[0]);
    exit(1);
  }
  /* 打开源文件 */
  if((from_fd=open(argv[1],O_RDONLY))==-1)
  {
    fprintf(stderr,”Open %s Error:%s”,argv[1],strerror(errno));
    exit(1);
  }
  /* 创建目的文件 */
  if((to_fd=open(argv[2],O_WRONLY|O_CREAT,S_IRUSR|S_IWUSR))==-1)
  {
    fprintf(stderr,”Open %s Error:%s”,argv[2],strerror(errno));
    exit(1);
  }
  /* 以下代码是一个经典的拷贝文件的代码 */
  while(bytes_read=read(from_fd,buffer,BUFFER_SIZE))
  {
    /* 一个致命的错误发生了 */
    if((bytes_read==-1)&&(errno!=EINTR)) break;
    else if(bytes_read>0)
    {
      ptr=buffer;
      while(bytes_write=write(to_fd,ptr,bytes_read))
      {
        /* 一个致命错误发生了 */
        if((bytes_write==-1)&&(errno!=EINTR))break;
        /* 写完了所有读的字节 */
        else if(bytes_write==bytes_read) break;
        /* 只写了一部分,继续写 */
        else if(bytes_write>0)
        {
          ptr+=bytes_write;
          bytes_read-=bytes_write;
        }
      }
      /* 写的时候发生的致命错误 */
      if(bytes_write==-1)break;
    }
  }
  close(from_fd);
  close(to_fd);
  exit(0);
}
目录查看

#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <time.h>
static int get_file_size_time(const char *filename)
{
  struct stat statbuf;
  if(stat(filename,&statbuf)==-1)
  {
    printf(”Get stat on %s Error:%s”,
        filename,strerror(errno));
    return(-1);
  }
  if(S_ISDIR(statbuf.st_mode))return(1);
  if(S_ISREG(statbuf.st_mode))
    printf(”%s size:%ld bytestmodified at %s”,
        filename,statbuf.st_size,ctime(&statbuf.st_mtime));

  return(0);
}
int main(int argc,char **argv)
{
  DIR *dirp;
  struct dirent *direntp;
  int stats;
  if(argc!=2)
  {
    printf(”Usage:%s filenamea”,argv[0]);
    exit(1);
  }
  if(((stats=get_file_size_time(argv[1]))==0)||(stats==-1))exit(1);
  if((dirp=opendir(argv[1]))==NULL)
  {
    printf(”Open Directory %s Error:%s”,
        argv[1],strerror(errno));
    exit(1);
  }
  while((direntp=readdir(dirp))!=NULL)
    if(get_file_size_time(direntp->d_name)==-1)break;
  closedir(dirp);
  exit(1);
}
管道
include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/wait.h>
#define BUFFER 255
int main(int argc,char **argv)
{
  char buffer[BUFFER+1];
  int fd[2];
  if(argc!=2)
  {
    fprintf(stderr,”Usage:%s stringa”,argv[0]);
    exit(1);
  }
  if(pipe(fd)!=0)
  {
    fprintf(stderr,”Pipe Error:%sa”,strerror(errno));
    exit(1);
  }
  if(fork()==0)
  {
    close(fd[0]);
    printf(”Child[%d] Write to pipea”,getpid());
    snprintf(buffer,BUFFER,”%s”,argv[1]);
    write(fd[1],buffer,strlen(buffer));
    printf(”Child[%d] Quita”,getpid());
    exit(0);
  }
  else
  {
    close(fd[1]);
    printf(”Parent[%d] Read from pipea”,getpid());
    memset(buffer,’0′,BUFFER+1);
    read(fd[0],buffer,BUFFER);
    printf(”Parent[%d] Read:%s”,getpid(),buffer);
    exit(1);
  }
}

#include <stdio.h>
#include <stdlib.h>
#define N 13
typedef struct node {
  int code;
  struct node *next;

}NODE,*LinkList;
LinkList create_list(int n) {
  LinkList head,p;
  int i;
  head = (NODE *)malloc(sizeof(NODE));
  if(!head) {
    printf(”memor allocation is fail”);
    exit(1);
  }
  head->code = 1;
  head->next = head;
  for(i =n ;i > 1; i++) {
    p = (NODE *)malloc(sizeof(NODE));
    if(!p) {

      printf(”memor allocation is fail”);

      exit(1);
    }
    p->code = i;
    p->next = head->next;
    head->next = p;

  }
  return head;
}

void output(LinkList head) {
  LinkList p;
  p = head;
  do {
    printf(”%4d”,p->code);
    p = p->next;
  }while(p != head);

  printf(”");

}
void play(LinkList head, int n) {
  LinkList p,q;
  int c = 0,k;
  p = head;c=1;k=n;
  while(k > 1) {
    if(c == 2) {
      q = p->next;
      p->next = q->next;
      printf(”%4d”,q->code);
      free(q);
      c = 0;
      k–;

    }else {
      c++;p=p->next;
    }

  }

  printf(”%4dwas the winer”,p->code);

}
int main() {
  LinkList head;
  int n;
  printf(”please input your number”);
  scanf(”%d”,&n);
  output(head);
  play(head,n);

  return 0;
}

背景

    最近一段时间在linux下用C做一些学习和开发，但是由于经验不足，问题多多。而段错误就是让我非常头痛的一个问题。不过，目前写一个一千行左右的代码，也很少出现段错误，或者是即使出现了，也很容易找出来，并且处理掉。

    那什么是段错误？段错误为什么是个麻烦事？以及怎么发现程序中的段错误以及如何避免发生段错误呢？

   一方面为了给自己的学习做个总结，另一方面由于至今没有找到一个比较全面介绍这个虽然是“FREQUENTLY ASKEDQUESTIONS”的问题，所以我来做个抛砖引玉吧。下面就从上面的几个问题出发来探讨一下“Segmentation faults”吧。

目录

1。什么是段错误？
2。为什么段错误这么“麻烦”？
3。编程中通常碰到段错误的地方有哪些？
4。如何发现程序中的段错误并处理掉？

正文

1。什么是段错误？

下面是来自Answers.com的定义：

另外，这里有个基本上对照的中文解释，来自http://www.linux999.org/html_sql/3/132559.htm

通过上面的解释，段错误应该就是访问了不可访问的内存，这个内存区要么是不存在的，要么是受到系统保护的。

2。为什么段错误这么麻烦？

中国linux论坛有一篇精华帖子《Segment fault 之永远的痛》(http://www.linuxforum.net/forum/gshowflat.php?Cat=&Board=program&Number=193239&page=2&view=collapsed&sb=5&o=all&fpart=1&vc=1)
在主题帖子里头，作者这么写道：

    后面有好多网友都跟帖了，讨论了Segmentation faults为什么这么“痛”，尤其是对于服务器程序来说，是非常头痛的，为了提高效率，要尽量减少一些不必要的段错误的“判断和处理”，但是不检查又可能会存在段错误的隐患。

    那么如何处理这个“麻烦”呢？
    就像人不可能“完美”一样，由人创造的“计算机语言“同样没有“完美”的解决办法。
    我们更好的解决办法也许是：

    通过学习前人的经验和开发的工具，不断的尝试和研究，找出更恰当的方法来避免、发现并处理它。对于一些常见的地方，我们可以避免，对于一些“隐藏”的地方，我们要发现它，发现以后就要及时处理，避免留下隐患。

    下面我们可以通过具体的实验来举出一些经常出现段错误的地方，然后再举例子来发现和找出这类错误藏身之处，最后处理掉。

3。编程中通常碰到段错误的地方有哪些？

为了进行下面的实验，我们需要准备两个工具，一个是gcc，一个是gdb
我是在ubuntu下做的实验，安装这两个东西是比较简单的

好了，开始进入我们的实验，我们粗略的分一下类

1）往受到系统保护的内存地址写数据

    有些内存是内核占用的或者是其他程序正在使用，为了保证系统正常工作，所以会受到系统的保护，而不能任意访问。

例子1：

Code:
#include <stdio.h>intmain(){        int i = 0;        scanf (”%d”, i);  /* should have used &i */        printf (”%d”, i);        return 0;}
[Ctrl+A Select All]
    编译和执行一下

    咋一看，好像没有问题哦，不就是读取一个数据然后给输出来吗？

下面我们来调试一下，看看是什么原因？

果然
我们“不小心”把&i写成了i
而我们刚开始初始化了i为0,这样我们不是试图向内存地址0存放一个值吗？实际上很多情况下，你即使没有初始化为零，默认也可能是0，所以要特别注意。

补充：
可以通过man 7 signal查看SIGSEGV的信息。

例子2：

Code:
#include <stdio.h>intmain(){        char *p;        p = NULL;        *p = ‘x’;        printf(”%c”, *p);        return 0;}
[Ctrl+A Select All]
很容易发现，这个例子也是试图往内存地址0处写东西。

这里我们通过gdb来查看段错误所在的行

2）内存越界(数组越界，变量类型不一致等)

例子3：
Code:
#include <stdio.h>intmain(){        char test[1];        printf(”%c”, test[1000000000]);        return 0;}
[Ctrl+A Select All]
这里是比较极端的例子，但是有时候可能是会出现的，是个明显的数组越界的问题
或者是这个地址是根本就不存在的

例子4：
Code:
#include <stdio.h>intmain(){        int b = 10;        printf(”%s”, b);        return 0;}
[Ctrl+A Select All]
我们试图把一个整数按照字符串的方式输出出去，这是什么问题呢？
由于还不熟悉调试动态链接库，所以
我只是找到了printf的源代码的这里

仔细看看，发现了这样一个问题，在打印字符串的时候，实际上是打印某个地址开始的所有字符，但是当你想把整数当字符串打印的时候，这个整数被当成了一个地址，然后printf从这个地址开始去打印字符，直到某个位置上的值为0。所以，如果这个整数代表的地址不存在或者不可访问，自然也是访问了不该访问的内存——segmentation fault。

类似的，还有诸如：sprintf等的格式控制问题
比如，试图把char型或者是int的按照%s输出或存放起来，如：
Code:
#include <stdio.h> #include <string.h>char c=’c';int i=10;char buf[100];printf(”%s”, c);        //试图把char型按照字符串格式输出，这里的字符会解释成整数，再解释成地址，所以原因同上面那个例子printf(”%s”, i);            //试图把int型按照字符串输出memset(buf, 0, 100);sprintf(buf, “%s”, c);    //试图把char型按照字符串格式转换memset(buf, 0, 100);sprintf(buf, “%s”, i);   //试图把int型按照字符串转换
[Ctrl+A Select All]

3）其他

其实大概的原因都是一样的，就是段错误的定义。但是更多的容易出错的地方就要自己不断积累，不段发现，或者吸纳前人已经积累的经验，并且注意避免再次发生。

例如：

<1>定义了指针后记得初始化，在使用的时候记得判断是否为NULL
<2>在使用数组的时候是否被初始化，数组下标是否越界，数组元素是否存在等
<3>在变量处理的时候变量的格式控制是否合理等

再举一个比较不错的例子：

我在进行一个多线程编程的例子里头，定义了一个线程数组
#define THREAD_MAX_NUM
pthread_t thread[THREAD_MAX_NUM];
用pthread_create创建了各个线程，然后用pthread_join来等待线程的结束

刚开始我就直接等待，在创建线程都成功的时候，pthread_join能够顺利等待各个线程结束，但是一旦创建线程失败，那用pthread_join来等待那个本不存在的线程时自然会存在访问不能访问的内存的情况，从而导致段错误的发生，后来，通过不断调试和思考，并且得到网络上资料的帮助，找到了上面的原因和解决办法：

在创建线程之前，先初始化我们的线程数组，在等待线程的结束的时候，判断线程是否为我们的初始值
如果是的话，说明我们的线程并没有创建成功，所以就不能等拉。否则就会存在释放那些并不存在或者不可访问的内存空间。

上面给出了很常见的几种出现段错误的地方，这样在遇到它们的时候就容易避免拉。但是人有时候肯定也会有疏忽的，甚至可能还是会经常出现上面的问题或者其他常见的问题，所以对于一些大型一点的程序，如何跟踪并找到程序中的段错误位置就是需要掌握的一门技巧拉。

4。如何发现程序中的段错误？

有个网友对这个做了比较全面的总结，除了感谢他外，我把地址弄了过来。文章名字叫《段错误bug的调试》(http://www.cublog.cn/u/5251/showart.php?id=173718),应该说是很全面的。

而我常用的调试方法有：

1）在程序内部的关键部位输出(printf)信息，那样可以跟踪 段错误 在代码中可能的位置

为了方便使用这种调试方法，可以用条件编译指令#ifdef DEBUG和#endif把printf函数给包含起来，编译的时候加上-DDEBUG参数就可以查看调试信息。反之，不加上该参数进行调试就可以。

2）用gdb来调试，在运行到段错误的地方，会自动停下来并显示出错的行和行号

这个应该是很常用的，如果需要用gdb调试，记得在编译的时候加上-g参数，用来显示调试信息,对于这个，网友在《段错误bug的调试》文章里创造性的使用这样的方法，使得我们在执行程序的时候就可以动态扑获段错误可能出现的位置：通过扑获SIGSEGV信号来触发系统调用gdb来输出调试信息。如果加上上面提到的条件编译，那我们就可以非常方便的进行段错误的调试拉。

3）还有一个catchsegv命令
通过查看帮助信息，可以看到

这个东西就是用来扑获段错误的，它通过动态加载器（ld-linux.so）的预加载机制（PRELOAD）把一个事先写好的库（/lib/libSegFault.so）加载上，用于捕捉断错误的出错信息。

到这里，“初级总结篇”算是差不多完成拉。欢迎指出其中表达不当甚至错误的地方，先谢过!

参考资料[具体地址在上面的文章中都已经给出拉]：

1。段错误的定义
Ansers.com
http://www.answers.com
Definition of “Segmentation fault”
http://www.faqs.org/qa/qa-673.html
2。《什么是段错误》
http://www.linux999.org/html_sql/3/132559.htm
3。《Segment fault 之永远的痛》
http://www.linuxforum.net/forum/gshowflat.php?Cat=&Board=program&Number=193239&page=2&view=collapsed&sb=5&o=all&fpart=
4。《段错误bug的调试》
http://www.cublog.cn/u/5251/showart.php?id=173718

后记

虽然感觉没有写什么东西,但是包括查找资料和打字，也花了好些几个小时，不过总结一下也是值得的，欢迎和我一起交流和讨论，也欢迎对文章中表达不当甚至是错误的地方指正一下。

我们在用C/C++语言写程序的时侯，内存管理的绝大部分工作都是需要我们来做的。实际上，内存管理是一个比较繁琐的工作，无论你多高明，经验多丰富，难免会在此处犯些小错误，而通常这些错误又是那么的浅显而易于消除。但是手工“除虫”（debug），往往是效率低下且让人厌烦的，本文将就”段错误”这个内存访问越界的错误谈谈如何快速定位这些”段错误”的语句。
下面将就以下的一个存在段错误的程序介绍几种调试方法：

sed -i '/'$name'/s//sbin/nologin//bin/sh/' usersfilesed -i "/$name/s//sbin/nologin//bin/sh/" usersfile

    struct list *listp, *nextp;    for(listp = base; listp != NULL; listp = nextp) {        nextp = listp->next;        free(listp);    }