目录

有品位的C代码

C 固然是我喜欢的语言，但是它的灵活性，导致可以使用它写出各种难以理解的代码（个人觉得是糟粕），导致代码的可读性不好、还伴有难以发现的 BUG 。使用一门语言，并不需要理解和使用它的全部，聪明的人都会挑选出它的一个子集作为自己的心头所爱。本文所写的就是我自己的心头所爱。

预处理器篇

要时刻记住的是：预处理器做的事情，仅仅是字符替换，它没有任何语义上的理解和处理。并且使用它的时候要特别小心，考虑周全，当然能不用预处理就最好不用。

#define max(A,B) ((A) > (B) ? (A) : (B))

lvalue、rvalue、地址与变量名

变量名

int a;

当看到上面一句代码时，首先会想到什么？

我会想到一块“空间”，空间名字是a，大小是4（由int推知）。它是一大块已编号空间的一部分。它有编号地址，可以由&a运算得出。

由“名字”可以唯一确定一块空间，由“地址+大小”也可以唯一确定一块空间，两者是等价的。

左值

a = 10;

看到上面代码时，我会想到，这操作是将 10 这个数字，放到a空间中。此时 a 是lvalue（左值）。

右值

b = a;

看到上面代码时，我会想到，这操作是将a空间里的东西10放到b空间里。此时，a是rvalue（右值）。

同样是a这个名字：

  • 在=左边时，它的含义是一块具体的“空间”，可以往里面存“东西”

  • 在=右边时，它的含义却是这块空间里的“东西”

地址

那么，思考下，如果我想要将a的“地址”存到b空间里面呢？首先，我们要考虑的问题是：

  • 多大的空间才能存下“地址”呢？ （8个字节）

  • 如何才能获得这样的空间呢？ （long、void*、int*、char*、short*都能声明8个字节的空间）

void* b;     // 思考下与 int* 声明的不同
b = &a;

看到上面代码，我就会想到，声明了b空间，往里面存放了a空间的地址。

int* c;

c = b;
b = 10;

看上面代码，再思考下同一个名字b，作为lvalue与rvalue时的不同。执行后，c空间也存放了a空间的地址。

假如由于某种情况，名字a不能使用了，或者空间根本就没有名字（malloc操作获得的空间）。而b与c空间里，存下了a空间的“地址”, 那么可不可以通过“名字”c来操作空间a呢。

首先，c 名字已经代表了c空间，&c 代表了地址，那么我们就用 *c 代表 a空间。

int d;
*c = 100;           // 往 a 空间存入 100
d  = *c;            // 将 a 空间的东西 存入 d 空间

回顾下：

由“名字”可以唯一确定一块空间，由“地址+大小”也可以唯一确定一块空间，两者是等价的。

上述讨论，只涉及到了“地址”，那么“大小”是如何确定的呢？答案就在b空间与c空间的声明上：

void* b;
int*  c;

long、void*、int*、char*、short*每种声明都能拿到一个8字节的空间，都能刚好存下一个“地址”，唯一不同的是:不同类型声明确定了该“地址”空间的“大小”。而“地址 + 大小”唯一指定了一块空间。

当然，有了“地址”后，我们也可以强制指定一个“大小”，用来锁定某块空间。比如 (int*)b ，强制按照4字节来使用b空间里的“地址”。

上面提到，有的空间没有“名字”，这是通过malloc调用获得的：

malloc(4);      // 获取 4 个字节的空间,返回一个 地址

通过上述讨论，我们已经知道如何来间接使用这块“匿名空间”。

int* p = malloc(4); // p 存了 该匿名空间的地址

*p    = 1000;       // 将 1000 存入该空间
int h = *p;         // h = 1000

二重指针

现在，我们来思考这样一种情况，b空间存了a空间地址，c空间存了b空间的地址。

int a  = 10;
int *b = &a;
int *c = &b;

根据上面我们关于“空间”的讨论，有：

int h = **c;    // 等价于 h = a;   最终 h = 10
**c   = 100;    // 等价于 a = 100; 最终 a = 100
int d  = 10;
int *e = NULL;

e  = *c;        // 等价与 e = b;  最终 e 存了 a 的地址
*c = &d;        // 等价与 b = &d; 最终 b 存了 d 的地址

思考

思考下，下面程序的输出：

void func( void *p )
{
    printf("&p: %p\n", &p);                     // &p: 0x7fffc19d00c8
    printf(" p: %p\n", p);                      //  p: 0x7fffc19d00f0
    printf("*p: %p\n", *(long*)p);              // *p: 0x558f5b130260
    printf("**P: %ld\n", **(int**)p);           // **P: 10
    printf("**p: %d\n", *(int*)(*(long*)p) );   // **p: 10
}
int main(int argc, char *argv[])
{
    int *a = (int*)malloc(4);
    *a = 10;
    func( &a );
    printf("&a: %p\n", &a); // &a: 0x7fffc19d00f0
    printf(" a: %p\n", a);  //  a: 0x558f5b130260
    printf("*a: %d\n", *a); // *a: 10
    return 0;
}

数据篇

绝不使用 unsigned 作运算

思考下，为何 c 的值是 0 ?

unsigned int a = 9;
int b = -4;
int c = a / b;
printf("c: %d\n", c); // 0

算术运算中，如果混入了 unsigned 操作数，则式子中所有操作数都要先转化成unsigned数，然后再运算，经常引入一些很难以察觉的 BUG。

算术运算

思考下，为何 a != ~b ?

unsigned char a = 0;
unsigned char b = 0xFF;

if( a == ~b )
    printf("a == ~b\n");    
else
    printf("a != ~b\n"); // 这句被打印

使用~运算，千万要注意字位数，在32位以上计算机中，表达式在运行时，将unsigned char型的变量自动转换成了unsigned int型变量，即~b = 0xFFFFFF00,而a = 0x00000000，所以不相等，大坑！

声明篇

定义类型

在 C 程序中，只使用简单的基本类型 和 typedef 定义出来的类型 去声明变量（注意，这里强调不要再使用* () []等直接原生的方式声明变量了）。另外，在命名上指针要加上PTR后缀，并且大写，这样使整个程序可读性好。

typedef char *String;               // 字符串类型
typedef int *INT_PTR;               // int 类型指针
typedef char CHAR_20_ARR[20];       // 包含20个char元素的数组类型
typedef char (* CHAR_4_PTR)[4];     // 指向包含4个char元素的数组的指针 类型
typedef int (* FUNC_PTR)(int, int); // 函数指针

String p, lineptr[100]; // 
INT_PTR arr[3];         // 等价于 int *arr[3]; 表示有 3 个int指针的数组
CHAR_20_ARR a1, a2, a3; // 等价于 char a1[20];char a2[20];char a3[20];
CHAR_4_PTR p2;          // 等价于 char (*p2)[4];指向 包含 4 个char元素的数组
CHAR_4_PTR arr[3];      // 包含 3 个指针，指针指向 包含 4 个char元素的数组

为结构体定义类型

typedef struct node
{
    char *item;
    struct node *next; // 注意这里只能使用已扫描的 struct node，不能使用 NODE_PTR
} NODE, *NODE_PTR;

函数篇

使用 typedef 简化声明

下面是 signal 函数的声明，整个代码看起来一团糟，要理解它还需要费脑力，没有任何的好处。

void ( *signal( int, void(*)(int) ) )( int );

如果我们使用 typedef 简化下，就能得到一个很清晰的代码，只需要结合一点点函数指针声明的理解，就知道singal函数的 返回值 以及 参数。

typedef void (*HANDLER)( int );
HANDLER signal(int, HANDLER);

指针篇

先取值 再移动

char ch  = 'a';
char *cp = &ch;

对于上述两个变量的表达式如下，圆形粗体线代表了表达式执行后的返回值，方框粗体则表示作为左值时，表达式标示的位置。

表达式左值右值
ch
&ch非法
cp
&cp非法
*cp + 1非法
*(cp+1)
++cp非法
cp++非法
*++cp
*cp++
(*cp)++非法
++*cp非法
++*++cp非法
++*cp++非法

通过上表，对于*cp++这样的表达式，首先它作为“左值”和“右值”，都是对cp指针的当前指向位置进行操作，操作完毕后，再将指向位置移动一位。所以非常经常被用来编写出简短的代码：

size_t strlen(char *string){
    int length = 0;
    while( *string++ != '\0' )
        length++;
    return length;
}
void strcpy( char *s, char *t )
{
    while( *s++ = *t++ )
        ;
}

结构体

typedef struct{
    int a;
    short b[2];
} Ex2;
typedef struct EX{
    int  a;
    char b[3];
    Ex2  c;
    struct EX *d;
}
Ex   x = { 10, "Hi", { 5, {-1, 25} }, 0 };
Ex *px = &x;
Ex   y;
x.d    = &y;

表达式左值右值
px
*pxx所在空间
px->aa所在空间
&px->a非法
px->b非法
px->b[1]i所在空间
px->cc所在空间
px->c.a5所在空间
*px->c.b px->c.b[0]-1所在空间
px->d&y
*px->dy所在空间
px->d->c.b[1]空间

错误处理

// dbg.h
#include <stdio.h>
#include <errno.h>
#include <string.h>

#ifdef NDEBUG
    #define debug(M, ...)
#else
    #define debug(M, ...) fprintf(stderr, "DEBUG %s:%d: " M "\n", __FILE__, __LINE__, ##__VA_ARGS__)
#endif

#define  error_str() (errno == 0 ? "None" : strerror(errno))
#define log_err(M, ...) \
fprintf(stderr, "[ERROR] (%s:%d: errno: %s) " M "\n", __FILE__, __LINE__,  error_str(), ##__VA_ARGS__)
#define log_warn(M, ...) \
fprintf(stderr, "[WARN] (%s:%d: errno: %s) " M "\n", __FILE__, __LINE__,  error_str(), ##__VA_ARGS__)
#define log_info(M, ...) \
fprintf(stderr, "[INFO] (%s:%d) " M "\n", __FILE__, __LINE__, ##__VA_ARGS__)

#define check(A, M, ...) \
if(!(A)) { log_err(M, ##__VA_ARGS__); errno=0; goto error; }

#define check_mem(A) check((A), "Out of memory.")

#define check_debug(A, M, ...) if(!(A)) { debug(M, ##__VA_ARGS__); errno=0; goto error; }
#define sentinel(M, ...)  { log_err(M, ##__VA_ARGS__); errno=0; goto error; }

傻逼代码

以前看到这样的一些代码，我觉得很厉害，能理解它们的人都非常强。现在我觉得，这些代码就是傻逼，花时间去理解这样代码的人都是浪费时间，走了弯路。事实上，你不需要理解下面任何一句代码，但你仍然可以是一个很好的 C 程序员，并且写出很棒的 C 程序。

int ( *func )( int * );
int ( *func[5] )( int * );
char ( *( *x() )[] )( );
void ( *b[10] )( void(*)() );
double (*)()( *e )[9];