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

注意以写的文章，全部理论都是基于类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的互斥量快不少，而切比起自旋锁也多了检查死锁和能够递归操做的特性。