真正的Ｃ程序要从可移植性开始

2019独角兽企业重金招聘Python工程师标准>>>

注意以写的文章，所有理论都是基于类Unix系统的C程序编写。

##平台可移植性

好的程序即使切换到任意操作系统平台并使用任意的编译器编译，也不应该出现太多的警告，更不能出现编译不通过的情况了。

• 要编写可移植性的代码，首先要知道当前编译的系统是什么系统，一般都是通过编译器内置的预编译宏进行确认，如下：

//平台检测
#if !defined(__LINUX__) && (defined(__linux__) || defined(__KERNEL__) \
	|| defined(_LINUX) || defined(LINUX) || defined(__linux))
  #define  __LINUX__    (1)
#elif !defined(__APPLE__) && (defined(__MacOS__) || defined(__apple__))
  #define  __APPLE__    (1)
#elif !defined(__CYGWIN__) && (defined(__CYGWIN32__) || defined(CYGWIN))
  #define  __CYGWIN__   (1)
#elif !defined(__WINDOWS__) && (defined(_WIN32) || defined(WIN32) \
	|| defined(_window_) || defined(_WIN64) || defined(WIN64))
  #define __WINDOWS__   (1)
#elif !(defined(__LINUX__) || defined(__APPLE__) \
  || defined(__CYGWIN__) || defined(__WINDOWS__))
  #error "`not support this platform`"
#endif

• 确定平台后，定义一个宏。然后使用这个宏去进行预编译处理，比如只有linux支持<sys/epoll.h>这个头文件，如下：

#ifdef __LINUX__
  #include <sys/epoll.h>
#endif

##编译器可移植性

• 除了平台会关联移植性，编译器也会关联，比如类Unix系统一般都使用gcc编译器，而该编译器提供了很多特性，首先确定编译器类型，如下：

//编译器版本
/* gcc version. for example : v4.1.2 is 40102, v3.4.6 is 30406 */
#define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)

• 编译器特性

  本人不是很厉害，现在仅仅使用下面两个很有用的特性。

  • 特性一：有的时候我们需要知道printf()类函数输入的参数是否合法，这样可以在编译时就发出警告，而不至于因为格式错误发生运行时错误，那么可以使用如下编译器提供的特性：

  //字符串格式化参数检查
  #if !defined(__printflike) && defined(GCC_VERSION)
      #define __printflike(fmtarg, firstvararg) __attribute__((__format__(__printf__, fmtarg, firstvararg)))
  #endif
  

  • 特性二：由于cpu在处理指令时，可以读取多条，特别是在处理条件跳转指令时，如果能预判断条件发送的概率，那么就可以提高处理指令的速度（这个原理我只一知半解，所以不能详细说出原理，了解到读者请指教），如下：

    //逻辑跳转优化
    #if GCC_VERSION
    /*条件大多数为真，与if配合使用，直接执行if中语句*/
        #define likely(x)     __builtin_expect(!!(x), 1)
    /*条件大多数为假，与if配合使用，直接执行else中语句*/
        #define unlikely(x)   __builtin_expect(!!(x), 0)
    #else
        #define likely(x)     (!!(x))
        #define unlikely(x)   (!!(x))
    #endif
    

• 使用编译器特性进行编程

  • 定义一个格式化日志输出函数，请类比printf()的使用方式；在函数声明后跟__printflike(6,7) 表面我们要检查类格式化函数的格式字符串从第六个参数开始，而被格式化的变参从第七个参数开始，如下：

  以后我讨论我的这套日志输出系统，这里的声明中函数有些不同，以后我会说明。

  // 写日志
  // @param cfg 日志配置数据
  // @param level 当前需要打印的日志级别
  // @param func 该条日志的输出所在函数名
  // @param file 该条日志的输出所在文件名
  // @param line 该条日志的输出所在文件行
  // @param formate 该条日志输出的格式
  // @param ... 依据格式输出的边参列表
  // @return 0 成功; -1 失败
  

int (SLogWrite)(SLogCfgT *cfg, const SLogLevelT *level, const char *func, const char *file, int line, const char *formate, ...) __printflike(6, 7); //正确的使用方式 ... /*默认日志级别定义表/ extern const SLogLevelT g_slogLevels[]; /*默认日志配置/ extern SLogCfgT g_slogCfg; (SLogWrite)(&g_slogCfg, &g_slogLevels[1], func, file, line, "%s", "test macro of __printflike(x, y)"); //错误的使用方式 (SLogWrite)(&g_slogCfg, &g_slogLevels[1], func, file, line, "%d", "test macro of __printflike(x, y)");

第一条调用不会发生警告，而第二条会发生警告，原本是希望将变参当作整数处理，可是却传入了一个字符串，这会产生一条编译警告，而警告可能会使程序运行产生未知行为，担任有时候也不会出什么问题，但有时会使程序蹦掉，所以不能存在侥幸心理。

- 条件预判断。几乎所有的C程序都需要检查变量的合法性，比如我们定义了一个结构体，但是可能忘记初始化结构体了，如果这样交给函数处理，可能发送未知行为，而导致错误的结果，甚至发生程序蹦掉。如下：
```c
...
struct T {
    void *data;
    ...
};
void deal(struct T *ptr) {
  int *data = (int*)ptr->data;
  printf("%d\n", *data);
}
struct T data;
deal(&data);
...

如果未初始化的data.data指向的是一个不可读写的指针地址，那么在deal()中解引用一定会使程序引发段错误而蹦掉。下面我们定义一系列宏，进行判断，但是发生错误的情况是甚少的，所以为效率考虑，我们在宏中使用likely()条件预判断：

//魔数
// 结构体中设置一个magic的成员变量，以检查结构体是否被正确初始化
#if !defined(OBJMAGIC)
#define OBJMAGIC (0xfedcba98)
//设置魔术
#define REFOBJ(obj)				 \
	({					 \
		bool _ret = false;		 \
		if (likely((obj))) {		 \
			(obj)->magic = OBJMAGIC; \
			_ret = true;		 \
		}				 \
		_ret;				 \
	})
//重置魔数
#define UNREFOBJ(obj)			     \
	({				     \
		bool _ret = false;	     \
		if (likely((obj) &&	     \
		(obj)->magic == OBJMAGIC)) { \
			(obj)->magic = 0;    \
			_ret = true;	     \
		}			     \
		_ret;			     \
	})
//验证魔数
#define ISOBJ(obj) \
	(likely((obj) && (obj)->magic == OBJMAGIC))
//断言魔数
#define ASSERTOBJ(obj) \
	(assert(ISOBJ((obj))))
#endif	/* if !defined(OBJMAGIC) */

使用如下：

struct T {
    int magic;
    void *data;
    ...
};
 void deal(struct T *ptr) {
    if(!ISOBJ(ptr)) return;
    int *data = (int*)ptr->data;
    printf("%d\n", *data);
}
void initobj(struct T *ptr, void *data) {
    if(!REFOBJ(&data) || !data) return;
    ptr->data = data;
}
...
struct T data;
int value = 1;
initobj(&data, (void*)&value);
//下个初始化不会再次初始化结构体
initobj(&data, (void*)&value);
deal(&data);

虽然每个结构体必须要保留一个magic这个字段，会占用一些时间和空间，但这样做是值得的，至少你可以少些很多代码来证明这个结构体被正确的初始化过，可以放心的使用。你应该保证你的初始化函数是预期的执行过。当然你也可以使用ASSERTOBJ ()判断结构体，在发现未初始化后，立马abort()程序，然后根据日志纠正错误，这至少比莫名的段错误要好很多。C就是这样，你要做很多工作来保证你的程序的正确性，这个是你的职责所在，不能嫌麻烦。关键是你要以何种灵活简单高效的方法来做这个事情。

##接下来讨论什么

在多核cpu流行的今天，多线程编程是必不可少的技能，而在原子操作是多线程里占很重要的地位，下一节我们将讨论原子操作的运行，并用原子操作实现一个比较高级的同步锁，该锁能很好的检查死锁，并将其修复，而且速度比起POSIX的互斥量快很多，而切比起自旋锁也多了检查死锁和可以递归操作的特性。

转载于:https://my.oschina.net/u/1160717/blog/725480