你有见到过最美的c语言代码吗？

我们都知道雷军雷布斯说过当时他写的代码像诗一样优美，那已经是三十年前的汇编时代了，那么现在你有见到过最美的c语言代码吗？

我在网上收集了一些代码，供大家赏诗，其中我本人最喜欢最后一个。

这是我找到最多的答案，估计是程序员想自黑还是说这个带大家步入了代码的世界。

#include《stdio.h》

int main（void）

{

printf（“Hello，World”）;

return 0;

}

代码的运行结果是代码本身

char* f = “char * f = %c%s%c;main（）{printf（f，34，f，34，10）;}%c”;

main（）

{

printf（f，34，f，34，10）;

}

编译结果如下：

汇编留下来的小技巧

#define STATE_TABLE

ENTRY（STATE0， func0）

ENTRY（STATE1， func1）

ENTRY（STATE2， func2）

。..

ENTRY（STATEX， funcX）

enum

{

#define ENTRY（a，b） a，

STATE_TABLE

#undef ENTRY

NUM_STATES

};

p_func_t jumptable［NUM_STATES］ =

{

#define ENTRY（a，b） b，

STATE_TABLE

#undef ENTRY

};

#define ENTRY（a，b） static void b（void）;

STATE_TABLE

#undef ENTRY

用来获取函数中的可变参数，具体用法可参加printf的源码实现

typedef char * va_list;

#define _INTSIZEOF（x） （（sizeof（x）+ sizeof（int）- 1） & ~（sizeof（int） - 1））

#define va_start（ap，v） （ ap= （va_list）&v+ _INTSIZEOF（v） ）

#define va_arg（ap，t） （ *（t *）（（ap += _INTSIZEOF（t）） - _INTSIZEOF（t）） ）

#define va_end（ap） （ ap = （va_list）0 ）

这是算64位里有多少个bit是1的

const uint64_t m1 = 0x5555555555555555; //binary： 0101.。.

const uint64_t m2 = 0x3333333333333333; //binary： 00110011.。

const uint64_t m4 = 0x0f0f0f0f0f0f0f0f; //binary： 4 zeros， 4 ones 。..

const uint64_t m8 = 0x00ff00ff00ff00ff; //binary： 8 zeros， 8 ones 。..

const uint64_t m16 = 0x0000ffff0000ffff; //binary： 16 zeros， 16 ones 。..

const uint64_t m32 = 0x00000000ffffffff; //binary： 32 zeros， 32 ones

int popcount64a（uint64_t x）

{

x = （x & m1 ） + （（x 》》 1） & m1 ）; //put count of each 2 bits into those 2 bits

x = （x & m2 ） + （（x 》》 2） & m2 ）; //put count of each 4 bits into those 4 bits

x = （x & m4 ） + （（x 》》 4） & m4 ）; //put count of each 8 bits into those 8 bits

x = （x & m8 ） + （（x 》》 8） & m8 ）; //put count of each 16 bits into those 16 bits

x = （x & m16） + （（x 》》 16） & m16）; //put count of each 32 bits into those 32 bits

x = （x & m32） + （（x 》》 32） & m32）; //put count of each 64 bits into those 64 bits

return x;

}

以上代码来自www.wikipedia.org

链接：

https://en.wikipedia.org/wiki/Hamming_weight#Efficient_implementation

kernel 链表 list 操作代码的一部分

linux kernel中最重要的迭代方法，很巧妙，通过一个结构体的成员指针获取结构体本身的指针，一个计算偏移，一个计算首地址，Linux内核或驱动开发常遇见。

#define offsetof（TYPE， MEMBER） （（size_t） &（（TYPE *）0）-》MEMBER）

#define container_of（ptr， type， member） （{

const typeof（（（type *）0）-》member）*__mptr = （ptr）;

（type *）（（char *）__mptr - offsetof（type， member））;}）

#define list_entry（ptr， type， member）

container_of（ptr， type， member）

linux里面对链表的操作见到过DO_SOMETHING 只是我做例子取的一个macro名字；do_something（） 并不是一行，可能是很多行，很多处理逻辑。

#define DO_SOMETHING（） do

{

do_something（）;

}while（0）

DO_SOMETHING（）;

首届IOCCC比赛中的一个代码

由于年代久远，看不到这段代码到底有什么效果，于是写了个可以在windows下编译运行的代码。

short main［］ = {

277， 04735， -4129， 25， 0， 477， 1019， 0xbef， 0， 12800，

-113， 21119， 0x52d7， -1006， -7151， 0， 0x4bc， 020004，

14880， 10541， 2056， 04010， 4548， 3044， -6716， 0x9，

4407， 6， 5568， 1， -30460， 0， 0x9， 5570， 512， -30419，

0x7e82， 0760， 6， 0， 4， 02400， 15， 0， 4， 1280， 4， 0，

4， 0， 0， 0， 0x8， 0， 4， 0， ‘，’， 0， 12， 0， 4， 0， ‘#’，

0， 020， 0， 4， 0， 30， 0， 026， 0， 0x6176， 120， 25712，

‘p’， 072163， ‘r’， 29303， 29801， ‘e’

};

不用加头文件就可以编译的，这段代码主要是弹出一个消息框做演示如下

double main［］ = {

-2.4701240043063294e-255，7.0200995176637059e-269，

1.7039916353015322e-248，

2.0829486981857065e-017，3.1678173412277654e-152，

1.4561366983095816e-300，

2.8652426426650795e+161，1.1610765287701034e+200，

-1.1126115309662626e+034，

2.5955200557858144e-303，5.3745432333120549e+196，

3.2709387181673304e+228，

-7.1518888970417846e+161，-1.7905983542158763e+305，

1.0622411385586801e-321

};

也有说到菲波那契

int fibonacci（ int n ）

{

return fib_iter（ 0， 1， n ）;

}

int fib_iter（ int a， int b， int n ）

{

return n ？ fib_iter（ b， a+b， n-1 ） ： b;

}

最后这个

#include 《stdio.h》

int main（void）

{

//for （ ; ; ）;

printf（“I Love You！”）;

return 0;

}

如果感兴趣的可以继续深入编译了解一下，抛砖引玉，意在引起大家的兴趣。

原文标题：你见过“最美”的C语言代码是什么？

文章出处：【微信公众号：FPGA之家】欢迎添加关注！文章转载请注明出处。

责任编辑：haq