《编写高质量代码:改善c程序代码的125个建议》—— 导读

前  言
为什么写作本书
众所周知,C语言是一门既具有高级语言特点,又有汇编语言特点的通用计算机编程语言,无论是操作系统(如Microsoft Windows、Mac OS X、Linux和UNIX等)、嵌入式系统与普通应用软件,还是目前流行的移动智能设备开发,随处都可以看见它依然矫健的身影。它能够轻松地应用于各类层次的开发中,从设备驱动程序和操作系统组件到大规模应用程序,它都能够很好地胜任。毋庸置疑,它是二十几年来使用最为广泛、生命力最强的编程语言,它的设计思想也影响了众多后来的编程语言,例如C++、Objective-C、Java、C#等。
尽管C语言有着悠久的历史和广泛的使用场景,但它依旧让大部分计算机编程人员望而生畏,相信绝大多数读者也还停留在“入门者”这个阶段。所谓“入门者”指的是已经可以简单使用C语言编写普通应用程序,但是却不明白如何编写高质量代码的人。面对这样的实际情况,在准备编写本书之前,一连串的问题深深地映入笔者的脑海:到底什么样的编程书籍才能够帮助“入门者”快速进阶?面对市面上众多的优秀C语言编程书籍,编写本书的价值何在?怎样的内容才能够与众不同?
带着这一连串的问题,笔者开始回顾自己这些年的开发生涯,发现如下几类问题经常困扰“入门者”:
基础数据类型问题:如数据取值范围、整数溢出与回绕、浮点数精度、数据类型转换的范围检查等。
数组与指针问题:指针与地址、野指针、空(null)指针、NULL指针、void指针、多级指针、指针函数与函数指针,以及数组越界与缓冲区溢出等。
内存管理问题:内存分配、内存释放、内存越界与内存泄漏等。
字符与字符串问题:串拷贝与内存拷贝,内存重叠与溢出,字符串查找等。
高效设计问题:表达式设计、算法设计与函数设计,内联函数与宏的取舍等。
其他杂项问题:信号处理、文件系统、断言与异常处理、内嵌汇编的使用等。
目  录
前 言
第1章 数据,程序设计之根本
建议1:认识ANSI C
建议2:防止整数类型产生回绕与溢出
建议2-1:char类型变量的值应该限制在signed char与unsigned char的交集范围内
建议2-2:使用显式声明为signed char或unsigned char的类型来执行算术运算
建议2-3:使用rsize_t或size_t类型来表示一个对象所占用空间的整数值单位
建议2-4:禁止把size_t类型和它所代表的真实类型混用
建议2-5:小心使用无符号类型带来的陷阱
建议2-6:防止无符号整数回绕
建议2-7:防止有符号整数溢出
建议3:尽量少使用浮点类型
建议3-1:了解IEEE 754浮点数
建议3-2:避免使用浮点数进行精确计算
建议3-3:使用分数来精确表达浮点数
建议3-4:避免直接在浮点数中使用“==”操作符做相等判断
建议3-5:避免使用浮点数作为循环计数器
建议3-6:尽量将浮点运算中的整数转换为浮点数
建议4:数据类型转换必须做范围检查
建议4-1:整数转换为新类型时必须做范围检查
建议4-2:浮点数转换为新类型时必须做范围检查
建议5:使用有严格定义的数据类型
建议6:使用typedef来定义类型的新别名
建议6-1:掌握typedef的4种应用形式
建议6-2:小心使用typedef带来的陷阱
建议6-3:typedef不同于#define
建议7:变量声明应该力求简洁
建议7-1:尽量不要在一个声明中声明超过一个的变量
建议7-2:避免在嵌套的代码块之间使用相同的变量名
建议8:正确地选择变量的存储类型
建议8-1:定义局部变量时应该省略auto关键字
建议8-2:慎用extern声明外部变量
建议8-3:不要混淆static变量的作用
建议8-4:尽量少使用register变量
建议9:尽量不要在可重入函数中使用静态(或全局)变量
建议10:尽量少使用全局变量
建议11:尽量使用const声明值不会改变的变量
第2章 保持严谨的程序设计,一切从表达式开始做起
建议12:尽量减少使用除法运算与求模运算
建议12-1:用倒数相乘来实现除法运算
建议12-2:使用牛顿迭代法求除数的倒数
建议12-3:用减法运算来实现整数除法运算
建议12-4:用移位运算实现乘除法运算
建议12-5:尽量将浮点除法转化为相应的整数除法运算
建议13:保证除法和求模运算不会导致除零错误
建议14:适当地使用位操作来提高计算效率
建议14-1:尽量避免对未知的有符号数执行位操作
建议14-2:在右移中合理地选择0或符号位来填充空出的位
建议14-3:移位的数量必须大于等于0且小于操作数的位数
建议14-4:尽量避免在同一个数据上执行位操作与算术运算
建议15:避免操作符混淆
建议15-1:避免“=”与“==”混淆
建议15-2:避免“|”与“||”混淆
建议15-3:避免“&”与“&&”混淆
建议16:表达式的设计应该兼顾效率与可读性
建议16-1:尽量使用复合赋值运算符
建议16-2:尽量避免编写多用途的、太复杂的复合表达式
建议16-3:尽量避免在表达式中使用默认的优先级
第3章 程序控制语句应该保持简洁高效
建议17:if语句应该尽量保持简洁,减少嵌套的层数
建议17-1:先处理正常情况,再处理异常情况
建议17-2:避免“悬挂”的else
建议17-3:避免在if/else语句后面添加分号“;”
建议17-4:对深层嵌套的if语句进行重构
建议18:谨慎0值比较
建议18-1:避免布尔型与0或1进行比较
建议18-2:整型变量应该直接与0进行比较
建议18-3:避免浮点变量用“==”或“!=”与0进行比较
建议18-4:指针变量应该用“==”或“!=”与NULL进行比较
建议19:避免使用嵌套的“?:”
建议20:正确使用for循环
建议20-1:尽量使循环控制变量的取值采用半开半闭区间写法
建议20-2:尽量使循环体内工作量达到最小化
建议20-3:避免在循环体内修改循环变量
建议20-4:尽量使逻辑判断语句置于循环语句外层
建议20-5:尽量将多重循环中最长的循环放在最内层,最短的循环放在最外层
建议20-6:尽量将循环嵌套控制在3 层以内
建议21:适当地使用并行代码来优化for循环
建议22:谨慎使用do/while与while循环
建议22-1:无限循环优先选用for( ; ; ),而不是while(1)
建议22-2:优先使用for循环替代do/while与while循环
建议23:正确地使用switch语句
建议23-1:不要忘记在case 语句的结尾添加break语句
建议23-2:不要忘记在switch语句的结尾添加default语句
建议23-3:不要为了使用case 语句而刻意构造一个变量
建议23-4:尽量将长的switch语句转换为嵌套的switch语句
建议24:选择合理的case语句排序方法
建议24-1:尽量按照字母或数字顺序来排列各条case 语句
建议24-2:尽量将情况正常的case 语句排在最前面
建议24-3:尽量根据发生频率来排列各条case 语句
建议25:尽量避免使用goto语句
建议26:区别continue与break语句
第4章 函数同样需要保持简洁高效
建议27:理解函数声明
建议28:理解函数原型
建议29:尽量使函数的功能单一
建议30:避免把没有关联的语句放在一个函数中
建议31:函数的抽象级别应该在同一层次
建议32:尽可能为简单功能编写函数
建议33:避免多段代码重复做同一件事情
建议34:尽量避免编写不可重入函数
建议34-1:避免在函数中使用static 局部变量
建议34-2:避免函数返回指向静态数据的指针
建议34-3:避免调用任何不可重入函数
建议34-4:对于全局变量,应通过互斥信号量(即P、V操作)或者中断机制等方法来保证函数的线程安全
建议34-5:理解可重入函数与线程安全函数之间的关系
建议35:尽量避免设计多参数函数
建议35-1:没有参数的函数必须使用void填充
建议35-2:尽量避免在非调度函数中使用控制参数
建议35-3:避免将函数的参数作为工作变量
建议35-4:使用const防止指针类型的输入参数在函数体内被意外修改
建议36:没有返回值的函数应声明为void类型
建议37:确保函数体的“入口”与“出口”安全性
建议37-1:尽量在函数体入口处对参数做有效性检查
建议37-2:尽量在函数体出口处对return语句做安全性检查
建议38:在调用函数时,必须对返回值进行判断,同时对错误的返回值还要有相应的错误处理
建议39:尽量减少函数本身或者函数间的递归调用
建议40:尽量使用inline内联函数来替代#define宏
第5章 不会使用指针的程序员是不合格的
建议41:理解指针变量的存储实质
建议42:指针变量必须初始化
建议43:区别“int p = NULL” 和“p = NULL”
建议44:理解空(null)指针与NULL指针
建议44-1:区别空(null)指针与NULL指针的概念
建议44-2:用NULL指针终止对递归数据结构的间接引用
建议44-3:用NULL指针作函数调用失败时的返回值
建议44-4:用NULL指针作警戒值
建议44-5:避免对NULL指针进行解引用
建议45:谨慎使用void指针
建议45-1:避免对void指针进行算术操作
建议45-2:如果函数的参数可以是任意类型指针,应该将其参数声明为void
建议46:避免使用指针的长度确定它所指向类型的长度
建议47:避免把指针转换为对齐要求更严格的指针类型
建议48:避免将一种类型的操作符应用于另一种不兼容的类型
建议49:谨慎指针与整数之间的转换
建议50:区别“const int
p”与“int *const p”
建议51:深入理解函数参数的传递方式
建议51-1:理解函数参数的传递过程
建议51-2:掌握函数的参数传递方式
建议51-3:如果函数的参数是指针,避免用该指针去申请动态内存
建议51-4:尽量避免使用可变参数
第6章 数组并非指针
建议52:理解数组的存储实质
建议52-1:理解数组的存储布局
建议52-2:理解&a[0]和&a的区别
建议52-3:理解数组名a作为右值和左值的区别
建议53:避免数组越界
建议53-1:尽量显式地指定数组的边界
建议53-2:对数组做越界检查,确保索引值位于合法的范围之内
建议53-3:获取数组的长度时不要对指针应用sizeof操作符
建议54:数组并非指针
建议55:理解数组与指针的可交换性
建议56:禁止将一个指向非数组对象的指针加上或减去一个整数
建议57:禁止对两个并不指向同一个数组的指针进行相减或比较
建议58:若结果值并不引用合法的数组元素,不要将指针加上或减去一个整数
建议59:细说缓冲区溢出
建议60:区别指针数组和数组指针
建议61:深入理解数组参数
第7章 结构、位域和枚举
建议62:结构体的设计要遵循简单、单一原则
建议62-1:尽量使结构体的功能单一
建议62-2:尽量减小结构体间关系的复杂度
建议62-3:尽量使结构体中元素的个数适中
建议62-4:合理划分与改进结构体以提高空间效率
建议63:合理利用结构体内存对齐原理来提高程序效率
建议64:结构体的长度不一定等于各个成员的长度之和
建议65:避免在结构体之间执行逐字节比较
建议66:谨慎使用位域
建议67:谨慎使用枚举
建议68:禁止在位域成员上调用offsetof宏
建议69:深入理解结构体数组和结构体指针
第8章 字符与字符串
建议70:不要忽视字符串的null('\0')结尾符
建议70-1:正确认识字符数组和字符串
建议70-2:字符数组必须能够同时容纳字符数据和null结尾符
建议70-3:谨慎字符数组的初始化
建议71:尽量使用const指针来引用字符串常量
建议72:区别strlen函数与sizeof运算符
建议73:在使用不受限制的字符串函数时,必须保证结果字符串不会溢出内存
建议73-1:避免字符串拷贝发生溢出
建议73-2:区别串拷贝strcpy与内存拷贝memcpy
建议73-3:避免strcpy与memcpy函数内存重叠
建议73-4:区别字符串比较与内存比较
建议73-5:避免strcat函数发生内存重叠与溢出
建议74:谨慎strtok函数的不可重入性
建议75:掌握字符串查找技术
建议75-1:使用strchr与strrchr函数查找单个字符
建议75-2:使用strpbrk函数查找多个字符
建议75-3:使用strstr函数查找一个子串
建议75-4:区别strspn与strcspn函数
第9章 文件系统
建议76:谨慎使用printf和scanf 函数
建议77:谨慎文件打开操作
建议77-1:正确指定fopen的mode参数
建议77-2:必须检查fopen函数的返回值
建议77-3:尽量避免重复打开已经被打开的文件
建议77-4:区别fopen与fopen_s函数
建议77-5:区别fopen与freopen函数
建议78:文件操作完成后必须关闭
建议79:正确理解EOF宏
建议80:尽量使用feof和ferror检测文件结束和错误
建议81:尽量使用fgets替换gets函数
建议82:尽量使用fputs替换puts函数
建议83:合理选择单个字符读写函数
建议84:区别格式化读写函数
建议84-1:区别printf/scanf、fprintf/fscanf和sprintf/sscanf
建议84-2:尽量使用snprintf替代sprintf函数
建议84-3:区别vprintf/vscanf、vfprintf/vfscanf 、vsprintf/vsscanf和vsnprintf
建议85:尽量使用fread与fwrite函数来读写二进制文件
建议86:尽量使用fseek替换rewind函数
建议87:尽量使用setvbuf替换setbuf函数
建议88:谨慎remove函数删除已打开的文件
建议89:谨慎rename函数重命名已经存在的文件
第10章 预处理器
建议90:谨慎宏定义
建议90-1:在使用宏定义表达式时必须使用完备的括号
建议90-2:尽量消除宏的副作用
建议90-3:避免使用宏创建一种“新语言”
建议91:合理地选择函数与宏
建议92:尽量使用内联函数代替宏
建议93:掌握预定义宏
建议94:谨慎使用“#include”
建议94-1:区别“#include ”与“#include "filename.h" ”
建议94-2:必须保证头文件名称的唯一性
建议95:掌握条件编译指令
建议95-1:使用“#ifndef/#define/#endif”防止头文件被重复引用
建议95-2:使用条件编译指令实现源代码的部分编译
建议95-3:妙用“defined”
建议96:尽量避免在一个函数块中单独使用“#define”或“#undef”
第11章 断言与异常处理
建议97:谨慎使用断言
建议97-1:尽量利用断言来提高代码的可测试性
建议97-2:尽量在函数中使用断言来检查参数的合法性
建议97-3:避免在断言表达式中使用改变环境的语句
建议97-4:避免使用断言去检查程序错误
建议97-5:尽量在防错性程序设计中使用断言来进行错误报警
建议97-6:用断言保证没有定义的特性或功能不被使用
建议97-7:谨慎使用断言对程序开发环境中的假设进行检查
建议98:谨慎使用errno
建议98-1:调用errno之前必须先将其清零
建议98-2:避免重定义errno
建议98-3:避免使用errno检查文件流错误
建议99:谨慎使用函数的返回值来标志函数是否执行成功
建议100:尽量避免使用goto进行出错跳转
建议101:尽量避免使用setjmp与longjmp组合
第12章 内存管理
建议102:浅谈程序的内存结构
建议103:浅谈堆和栈
建议104:避免错误分配内存
建议104-1:对内存分配函数的返回值必须进行检查
建议104-2:内存资源的分配与释放应该限定在同一模块或者同一抽象层内进行
建议104-3:必须对内存分配函数的返回指针进行强制类型转换
建议104-4:确保指针指向一块合法的内存
建议104-5:确保为对象分配足够的内存空间
建议104-6:禁止执行零长度的内存分配
建议104-7:避免大型的堆栈分配
建议104-8:避免内存分配成功,但并未初始化
建议105:确保安全释放内存
建议105-1:malloc等内存分配函数与free必须配对使用
建议105-2:在free之后必须为指针赋一个新值
建议106:避免内存越界
建议106-1:避免数组越界
建议106-2:避免sprintf、vsprintf、strcpy、strcat与gets越界
建议106-3:避免memcpy与memset函数长度越界
建议106-4:避免忽略字符串最后的'\0'字符而导致的越界
建议107:避免内存泄漏
建议108:避免calloc参数相乘的值超过size_t表示的范围
第13章 信号处理
建议109:理解信号
建议110:尽量使用sigaction替代signal
建议111:避免在信号处理函数内部访问或修改共享对象
建议112:避免以递归方式调用raise函数
第14章 了解C11标准
建议113:谨慎使用_Generic
建议114:尽量使用gets_s替换gets函数
建议115:尽量使用带边界检查的字符串操作函数
建议116:了解C11多线程编程
建议117:使用静态断言_Static_assert执行编译时检查
建议118:使用_Noreturn标识不返回值的函数
第15章 保持良好的设计
建议119:避免错误地变量初始化
建议120:谨慎使用内联函数
建议121:避免在函数内定义占用内存很大的局部变量
建议122:谨慎设计函数参数的顺序和个数
建议123:谨慎使用标准函数库
建议124:避免不必要的函数调用
建议125:谨慎程序中嵌入汇编代码

时间: 2024-11-27 13:59:58

《编写高质量代码:改善c程序代码的125个建议》—— 导读的相关文章

《深入理解Scala》——第1章,第1.2节当函数式编程遇见面向对象

1.2 当函数式编程遇见面向对象 深入理解Scala 函数式编程和面向对象编程是软件开发的两种不同途径.函数式编程并非什么新概念,在现代开发者的开发工具箱里也绝非是什么天外来客.我们将通过Java生态圈里的例子来展示这一点,主要来看Spring Application framework和Google Collections库.这两个库都在Java的面向对象基础上融合了函数式的概念,而如果我们把它们翻译成Scala,则会优雅得多.在深入之前,我们需要先理解面向对象编程和函数式编程这两个术语的含义

《深入理解Scala》——第1章,第1.4节与JVM的无缝集成

1.4 与JVM的无缝集成 深入理解Scala Scala的吸引力之一在于它与Java和JVM的无缝集成.Scala与Java有很强的兼容性,比如说Java类可以直接映射为Scala类.这种紧密联系使Java到Scala的迁移相当简单,但在使用Scala的一些高级特性时还是需要小心的,Scala有些高级特性是Java里没有的.在Scala语言设计时已经小心地考虑了与Java无缝交互的问题,用Java写的库,大部分可以直接照搬(as-is)到Scala里. 1.4.1 Scala调用Java 从S

《深入理解Scala》——第2章,第2.1节学习使用Scala交互模式(REPL)

第2章 核心规则深入理解Scala 本章包括的内容: • 使用Scala交互模式(Read Eval Print Loop 简称REPL) • 面向表达式编程 • 不变性(Immutability) • Option类 本章内容覆盖了每个新Scala开发者都需要知道的几个主题.本章不会深入到每个主题里,但是会讲到可以让你自己去接着探索的程度.你将学会使用REPL,学会如何利用这个工具做软件的快速原型开发.然后我们会学到面向表达式编程,并从另一个视角来看控制结构是怎么回事.在此基础上,我们来研究不

《深入理解Scala》——第1章,第1.3节静态类型和表达力

1.3 静态类型和表达力 深入理解Scala 开发人员中有一个误解,认为静态类型必然导致冗长的代码.之所以如此是因为很多继承自C的语言强制要求程序员必须在代码中多处明确地指定类型.随着软件开发技术和编译器理论的发展,情况已经改变.Scala利用了其中一些技术进步来减少样板(boilerplate)代码,保持代码简洁. Scala做了以下几个简单的设计决策,以提高代码表达力. • 把类型标注(type annotation)换到变量右边. • 类型推断. • 可扩展的语法. • 用户自定义的隐式转

《深入理解Scala》——第1章,第1.5节总结

1.5 总结 深入理解Scala 本章中,你学到了一些Scala的设计理念.设计Scala的初衷在于把不同语言中的多种概念融合起来.Scala融合了函数式和面向对象编程,尽管显然Java也已经这么做了.Scala精选其语法,极大地减少了语言中的繁冗之处,使一些强大的特性可以优雅地表达,比如类型推断.最后,Scala和Java能够紧密集成,而且运行在Java虚拟机上,这或许是让Scala变成一种实用选择的最重要的一点.几乎不花代价就可以把Scala用于我们的日常工作中. 因为Scala融合了多种概

《深入理解Scala》——第1章,第1.1节Scala一种混合式编程语言

第1章 Scala--一种混合式编程语言 Scala是一种将其他编程语言中的多种技巧融合为一的语言.Scala尝试跨越多种不同类型的语言,给开发者提供面向对象编程.函数式编程.富有表达力的语法.静态强类型和丰富的泛型等特性,而且全部架设于Java虚拟机之上.因此开发者使用Scala时可以继续使用原本熟悉的某种编程特性,但要发挥Scala的强大能力则需要结合使用这些有时候相互抵触的概念和特性,建立一种平衡的和谐.Scala对开发者的真正解放之处在于让开发者可以随意使用最适合手头上的问题的编程范式.

《深入理解Scala》——第2章,第2.2节优先采用面向表达式编程

2.2 优先采用面向表达式编程 深入理解Scala 面向表达式编程是个术语,意思是在代码中使用表达式而不用语句.表达式和语句的区别是什么?语句是可以执行的东西,表达式是可以求值的东西.在实践中这有什么意义呢?表达式返回值,语句执行代码,但是不返回值.本节我们将学习面向表达式编程的全部知识,并理解它对简化程序有什么帮助.我们也会看一下对象的可变性,以及可变性与面向表达式编程的关系. 作者注:语句VS表达式 语句是可以执行的东西,表达式是可以求值的东西. 表达式是运算结果为一个值的代码块.Scala

《深入理解Scala》——第2章,第2.3节优先选择不变性

2.3 优先选择不变性 深入理解Scala 编程中的不变性指对象一旦创建后就不再改变状态.这是函数式编程的基石之一,也是JVM上的面向对象编程的推荐实践之一.Scala也不例外,在设计上优先选择不变性,在很多场景中把不变性作为默认设置.对此,你可能一下子会不适应.本节中,我们将学到不变性对于判等问题和并发编程能提供什么帮助. Scala里首先要明白的是不变对象和不变引用(immutable referene)的区别.Scala里的所有变量都是指向对象的引用.把变量声明为val意味着它是个不变"引

《深入理解Scala》——第2章,第2.4节用None不用null

2.4 用None不用null深入理解Scala Scala在标准库里提供了scala.Option类,鼓励大家在一般编程时尽量不要使用null.Option可以视作一个容器,里面要么有东西,要么什么都没有.Option通过两个子类来实现此含义:Some和None.Some表示容器里有且仅有一个东西,None表示空容器,有点类似List的Nil的含义. 在Java和其他允许null的语言里,null经常作为一个占位符用于返回值,表示非致命的错误,或者表示一个变量未被初始化.Scala里,你可以用

《深入理解Scala》——第2章,第2.5节多态场景下的判等

2.5 多态场景下的判等 深入理解Scala 众所周知,为多态的面向对象系统定义合适的判等和散列方法是个特别难的过程.这是因为子类可能在整个过程中造成一些相当怪异的问题,尤其是当类型层次上有多个实体(concrete)级别的时候.一般来说,对于需要比引用判等更强的判等(译者注:比如需要判断对象内部数据)的类,最好避免多层实体类层次.这是什么意思呢?有些时候类只需要引用判等就够了.也就是说只要两个对象不是同一个实例就判为不等.但是如果我们需要判断两个不同实例是否相等,而且又有多层实体类层次(mul