先来测测你现在的 C 语言水平怎么样…
假如现在你去一家公司面试，要求：定义一个宏，求两个数中的最大数。
此处不要再往下看，停顿 5 分钟，写出你的答案，然后跟后面的答案对比。
———– 停顿 5 分钟 ————————————
合格
对于学过 C 语言的同学，写出这个宏基本上不是什么难事，使用条件运算符就能完成：
#define MAX(x,y) x > y ? x : y
这是最基本的 C 语言语法，如果连这个也写不出来，估计场面会比较尴尬。面试官为了缓解尴尬，一般会对你说：小伙子，你很棒，回去等消息吧，有消息，我们会通知你！这时候，你应该明白：不用再等了，赶紧把这篇文章看完，接着面下家。这个宏能写出来，也不要觉得你很牛 X，因为这只能说明你有了 C 语言的基础，但还有很大的进步空间。比如，我们写一个程序，验证一下我们定义的宏是否正确：
#define MAX(x,y) x > y ? x : y
int main(void)
{
printf("max=%d",MAX(1,2));
printf("max=%d",MAX(2,1));
printf("max=%d",MAX(2,2));
printf("max=%d",MAX(1!=1,1!=2));
return 0;
}
测试程序么，我们肯定要把各种可能出现的情况都测一遍。这不，测试第 4 行语句，当宏的参数是一个表达式，发现实际运行结果为 max=0,跟我们预期结果 max=1 不一样。这是因为，宏展开后，就变成了这个样子：
printf("max=%d",1!=1>1!=2?1!=1:1!=2);
因为比较运算符 > 的优先级为 6，大于 !=(优先级为 7)，所以展开的表达式，运算顺序发生了改变，结果就跟我们的预期不一样了。为了避免这种展开错误，我们可以给宏的参数加一个小括号()来防止展开后，表达式的运算顺序发生变化。这样的宏才能算一个合格的宏：
#define MAX(x,y) (x) > (y) ? (x) : (y)
中等
上面的宏，只能算合格，但还是存在漏洞。比如，我们使用下面的代码测试：
#define MAX(x,y) (x) > (y) ? (x) : (y)
int main(void)
{
printf("max=%d",3 + MAX(1,2));
return 0;
}
在程序中，我们打印表达式 3 + MAX(1, 2) 的值，预期结果应该是 5，但实际运行结果却是 1。我们展开后，发现同样有问题：
3 + (1) > (2) ? (1) : (2);
因为运算符 + 的优先级大于比较运算符 >，所以这个表达式就变为 4>2?1:2，最后结果为 1 也就见怪不怪了。此时我们应该继续修改这个宏：
#define MAX(x,y) ((x) > (y) ? (x) : (y))
使用小括号将宏定义包起来，这样就避免了当一个表达式同时含有宏定义和其它高优先级运算符时，破坏整个表达式的运算顺序。如果你能写到这一步，说明你比前面那个面试合格的同学强，前面那个同学已经回去等消息了，我们接着面试下一轮。
良好
上面的宏，虽然解决了运算符优先级带来的问题，但是仍存在一定的漏洞。比如，我们使用下面的测试程序来测试我们定义的宏：
#define MAX(x,y) ((x) > (y) ? (x) : (y))
int main(void)
{
int i = 2;
int j = 6;
printf("max=%d",MAX(i++,j++));
return 0;
}
在程序中，我们定义两个变量 i 和 j，然后比较两个变量的大小，并作自增运算。实际运行结果发现 max = 7，而不是预期结果 max = 6。这是因为变量 i 和 j 在宏展开后，做了两次自增运算，导致打印出 i 的值为 7。
遇到这种情况，那该怎么办呢？ 这时候，语句表达式就该上场了。我们可以使用语句表达式来定义这个宏，在语句表达式中定义两个临时变量，分别来暂储 i 和 j 的值，然后进行比较，这样就避免了两次自增、自减问题。
#define MAX(x,y)({
int _x = x;
int _y = y;
_x > _y ? _x : _y;
})
int main(void)
{
int i = 2;
int j = 6;
printf("max=%d",MAX(i++,j++));
return 0;
}
在语句表达式中，我们定义了 2 个局部变量_x、_y 来存储宏参数 x 和 y 的值，然后使用 _x 和 _y 来比较大小，这样就避免了 i 和 j 带来的 2 次自增运算问题。
你能坚持到了这一关，并写出这样自带 BGM 的宏，面试官心里可能已经有了给你 offer 的意愿了。但此时此刻，千万不要骄傲！为了彻底打消面试官的心理顾虑，我们需要对这个宏继续优化。
优秀
在上面这个宏中，我们定义的两个临时变量数据类型是 int 型，只能比较两个整型的数据。那对于其它类型的数据，就需要重新再定义一个宏了，这样太麻烦了！我们可以基于上面的宏继续修改，让它可以支持任意类型的数据比较大小：
#define MAX(type,x,y)({
type _x = x;
type _y = y;
_x > _y ? _x : _y;
})
int main(void)
{
int i = 2;
int j = 6;
printf("max=%dn",MAX(int,i++,j++));
printf("max=%fn",MAX(float,3.14,3.15));
return 0;
}
在这个宏中，我们添加一个参数：type，用来指定临时变量 _x 和 _y 的类型。这样，我们在比较两个数的大小时，只要将 2 个数据的类型作为参数传给宏，就可以比较任意类型的数据了。如果你能在面试中，写出这样的宏，面试官肯定会非常高兴，他一般会跟你说：小伙子，稍等，待会 HR 会跟你谈待遇问题。
还能不能更牛逼？
如果你想薪水拿得高一点，待遇好一点，此时不应该骄傲，你应该大手一挥：且慢，我还可以更牛逼！
上面的宏定义中，我们增加了一个 type 类型参数，来兼容不同的数据类型，此时此刻，为了薪水，我们应该把这个也省去。如何做到？使用 typeof 就可以了，typeof 是 GNU C 新增的一个关键字，用来获取数据类型，我们不用传参进去，让 typeof 直接获取！
#define max(x, y) ({
typeof(x) _x = (x);
typeof(y) _y = (y);
(void) (&_x == &_y);
_x > _y ? _x : _y; })
在这个宏定义中，使用了 typeof 关键字用来获取宏的两个参数类型。干货在(void) (&x == &y);这句话，简直是天才般的设计！一是用来给用户提示一个警告，对于不同类型的指针比较，编译器会给一个警告，提示两种数据类型不同；二是，当两个值比较，比较的结果没有用到，有些编译器可能会给出一个 warning，加个(void)后，就可以消除这个警告！
此刻，面试官看到你的这个宏，估计会倒吸一口气：乖乖，果然是后生可畏，这家伙比我还牛逼！你等着，HR 待会过来跟你谈薪水！恭喜你，拿到 offer 了！
打造一个趋近完美的宏
以上的宏解决了自增自减运算符 ++/– 带来的一系列问题。但也不是十全十美，通过与 @左江 的激情讨论，发现还是有漏洞：在宏内部的语句表达中，我们定义了 2 个临时变量 _x 和 _y 解决了 ++/– 带来的问题，但是也引入了一个新漏洞，比如当我们使用下面的代码时：
max(x, _x)
当宏展开后，第二个参数就与宏内部定义的临时变量同名了，这就影响宏最后的结果。因此，为了防止用户传入的参数跟宏内部的临时变量产生同名冲突，我们可以将宏内部的临时变量尽量定义得复杂一些，降低同名的概率，比如 Linux 内核中 max 宏的定义：
#define max(x, y) ({
typeof(x) _max1 = (x);
typeof(y) _max2 = (y);
(void) (&_max1 == &_max2);
_max1 > _max2 ? _max1 : _max2; })
在上面的宏定义中，虽然临时变量 _max1 和 max2 比我们上面的 _x 和 _y 好点，也只是更进一步降低跟用户的传参同名冲突的概率，但是还是不能完全杜绝。极端一点，我们可以把这两个变量定义得无比长、无比奇葩，只要不超过 C 标准规定以的标识符最大长度 j 就可以：
_____________tmp______________________for_______________________max______
再奇葩的程序员，再猪一样的队友，哪怕是团队毒瘤、代码杀手，估计也不会定义这样的变量吧！这样同名冲突的概率就大大降低了，但是还是不能完全杜绝，算是 Linux 内核的一个小漏洞吧。
还好，谢谢 @王云峰 提供的链接，下载新版本的 Linux 内核，发现已经堵住了这个漏洞：
#define __max(t1, t2, max1, max2, x, y) ({
t1 max1 = (x);
t2 max2 = (y);
(void) (&max1 == &max2);
max1 < max2 ? max1 : max2; })
#define ___PASTE(a,b) a##b
#define __PASTE(a,b) ___PASTE(a,b)
#define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __COUNTER__)
#define max(x, y)
__max(typeof(x), typeof(y),
__UNIQUE_ID(max1_), __UNIQUE_ID(max2_),
x, y)
在新版的宏中，内部的临时变量不再由程序员自己定义，而是让编译器生成一个独一无二的变量，这样就避免了同名冲突的风险。宏__UNIQUE_ID 的作用就是生成了一个独一无二的变量，确保了临时变量的唯一性。关于它的使用，可以参考下面的文章，写的很好：
是不是已经完美了？
新版本 Linux 内核堵住了临时变量可能带来的同名冲突的漏洞，但是是不是就完美了呢？还是不一定！针对 Linux 内核中宏的新版本，最近又引发各种争论，比如针对常量、变长数组问题等，看看他们提交的各种更新的版本吧：
Variable-length arrays and the max() messThe joy of max()
#define __single_eval_max(t1, t2, max1, max2, x, y) ({
t1 max1 = (x);
t2 max2 = (y);
(void) (&max1 == &max2);
max1 > max2 ? max1 : max2; })
#define __max(t1, t2, x, y)
__builtin_choose_expr(__builtin_constant_p(x) &&
__builtin_constant_p(y),
(t1)(x) > (t2)(y) ? (t1)(x) : (t2)(y),
__single_eval_max(t1, t2,
__UNIQUE_ID(max1_),
__UNIQUE_ID(max2_),
x, y))
#define max(x, y) __max(typeof(x), typeof(y), x, y)The joy of max() #define __single_eval_max(t1, t2, max1, max2, x, y) ({
t1 max1 = (x);
t2 max2 = (y);
(void) (&max1 == &max2);
max1 > max2 ? max1 : max2; })
#define __max(t1, t2, x, y)
__builtin_choose_expr(__builtin_constant_p(x) &&
__builtin_constant_p(y),
(t1)(x) > (t2)(y) ? (t1)(x) : (t2)(y),
__single_eval_max(t1, t2,
__UNIQUE_ID(max1_),
__UNIQUE_ID(max2_),
x, y))
#define max(x, y) __max(typeof(x), typeof(y), x, y)
还有这种更加复杂的 max 宏的实现：
#define __typecheck(x, y)
(!!(sizeof((typeof(x)*)1 == (typeof(y)*)1)))
#define __is_constant(x)
(sizeof(int) == sizeof(*(1 ? ((void*)((long)(x) * 0l)) : (int*)1)))
#define __no_side_effects(x, y)
(__is_constant(x) && __is_constant(y))
#define __safe_cmp(x, y)
(__typecheck(x, y) && __no_side_effects(x, y))
#define __cmp(x, y, op) ((x) op (y) ? (x) : (y))
#define __cmp_once(x, y, op) ({
typeof(x) __x = (x);
typeof(y) __y = (y);
__cmp(__x, __y, op); })
#define __careful_cmp(x, y, op)
__builtin_choose_expr(__safe_cmp(x, y),
__cmp(x, y, op), __cmp_once(x, y, op))
#define max(x, y) __careful_cmp(x, y, >)
小结：
上面以一个宏为例子，意在说明，对一门语言的掌握是永无止境的，就算你把当前所有的 C 语言知识点、编程技能都掌握了，C 语言也是不断更新的、C 标准也是不断更新变化的。编程技巧、编程技能也是不断进步的。
而自学往往是最有效的学习方法，但是前提是你要有好的学习资料、学习方法、学习目标，再加上刻意练习和实时反馈。否则，就是两眼一抹黑，不知道自己学得怎么样、学到什么水平了、学了有什么用、学得对不对。其实还有一种比较有效的学习方法，找个行业内的工程师带一带、参考优秀的书籍、教程学一学、再结合几个项目练一练，就知道什么该学、要学到什么程度，而且可以大大提高学习效率。
TIPS:
本文题所涉及到的 C 语言知识点：
- 自增自减运算符
- 宏定义
- 预处理过程
- 运算符的优先级与结合性
- 语句表达式：({……})
- GNU C 的扩展语法：typeof 关键字
- 内建函数：__builtin_……
- ……
———————————————————————–
2019.04.25 补充：
没想到帖子引来这么多人关注，评论也越来越变了味……
在此统一回复一下：
帖子的主题是 C 语言能学到什么高度？言外之意，就是你对 C 语言能掌握到什么程度。
- 写个 for 循环都要翻书的刚入门小白？
- 还是有万行编程经验的老鸟？
- 还是深谙 C 语言各种陷阱与缺陷的高手？
- 还是 C 语言专家？
什么是专家？各种资料上解释很多，一般就是在某一领域研究很深、或者说专业知识很全面，不仅横向知道某一领域的各个知识点，还要纵向上对发展过程、技术演变历史有所涉猎。个人觉得 C 语言专家也应如此，想到达专家级别，掌握 C 基本语法、编程技巧、写代码能力这是基础，更重要的是要知道：
- 知晓 C 语言的各种陷阱与缺陷、如何写出稳定高效的代码
- C 标准的掌握：它的发展过程、是如何演变的、解决了什么问题、弥补了 C 语言的哪些漏洞
- 不同编译器厂商、行业对 C 语言的语法扩展：C51、ARM、GNU C 等
- 一段相同的代码跨平台运行、在不同的编译器下运行，预期结果相同吗？为什么？
- 以 C 语言作为工具媒介，掌握各种平台编译器特性、系统架构、软件工程、框架、算法…
尤其是在嵌入式、底层系统软件这种对性能要求极高的开发中，开发人员除了熟练使用 C 编程之外，还要深谙 C 语言的各种高级特性、语法扩展、编译器特性、体系架构、编译原理等，才能写出高效率、高性能、更加稳定灵活的系统软件。
本来想以模拟面试举例，来测试你对 C 语言的掌握到了什么程度，有哪些知识点没有掌握，就这么简单。面试跟考试一样，本来就是一个选拔、淘汰机制。你高考的 log 现在用了多少？你面试考得各种东西实际工作中又用了多少？这就跟我们校园里的石板路一样，合理不合理让学生的脚投票：你会发现有些路尽管设计得很漂亮，但是基本上没人走，一步娘炮、两步扯蛋。而有些草地上，自发形成了各种捷径，走得人多了，也就成了路…
技术本身就很枯燥，学习本来就是很反人性的，为了使文章生动活泼有趣点，就举了个面试的例子，顺便夹杂几个段子、活跃活跃气氛，结果就引来各种人身攻击，揪住段子不放，至于么……，之所以删除楼下某层的评论，你自己来干嘛的，你自己心里很清楚，就事论事，就技术本身进行讨论，这个帖子永远欢迎。一上来就人身攻击，把自己那点经验当做真理，拿来指教别人，开始人身攻击，你我了解多少，你就敢下这么多武断的结论？你写过多少内核代码？写过多少内核驱动？你觉得内核难，那是你的事情，比你厉害，比你牛的人多的是，想成为牛 X 的人也多的是，你不会，你觉得痛苦，但你不能打击别人，阻断别人前进、进步的道路。你作为老师，带给学生的是希望？还是一个你武断结论下的绝望？
至于你说的天分论：每个学生有自己的天分，不行趁早转行。严重不同意你的观点。能考上大学，大家的智商都差不多，资质水平说白了都差不多。为什么有的学生越来越优秀，为什么学生之间的差距越来越大。最主要的原因根本不在于智商、天分，而是自律的品格、坚持的毅力、成长型思维这些优秀的性格品质在起作用。从某个时间节点或短期来看，个体的差异可能导致每个人对某一个问题的理解和接受能力不同，但从长远来看，学习成绩、工作绩效、科研成果的好坏，绝不仅仅是天分决定的，而是毅力! 毅力把生活当成一场马拉松，而不是短跑。毅力是对未来的坚持、日复一日，是对长远目标的激情和坚持。随着时间的积累，人的学习能力也是会变化的，它会随着你的努力程度而变化。你作为老师，倒好，一句天分论，打倒学生一大片，你知道你扼杀了多少个可能吗？
刘国梁的闺女生下来就会打高尔夫？柯洁生下来就会下象棋？郎朗在娘胎里就会弹钢琴？不是的，他们都是经过刻意练习、努力锻炼的结果。教学方法、训练方法随着时间的推移和技术的进步，都是可以不断提高和完善的。孙杨、宁泽涛、苏炳添，这些不断刷新记录和突破自身极限的优秀运动员，也在不断尝试国外先进的训练方法、或者聘请国外优秀的教练。包括最近在看的电影《绝杀慕尼黑》，苏联佬都知道美帝的培训更加先进，引进来训练自己的学员并最终获得奥运冠军。IT 培训也是如此，行业早起，技术积累不足、行业经验积累不够，IT 培训可能仅仅是入门，让学员能够找到工作。但是随着技术的进步、行业项目经验的积累，IT 的训练方法、培训体系也会不断提高和完善的。你作为培训老师，如果还停留在引导初学者入门，“师傅领进门，修行在个人”这些传统的观念上，我觉得你并不是一个优秀的老师，作为培训老师，也要不断跟踪行业变化、不断完善训练方法，培养出更高水平的学员。
在行业发展早期，由于学习资料、技术积累、行业经验的不足，每一个技术高手可能要走过很多弯路、踩过很多坑、浪费很多时间、瞎折腾很长时间，才能把自己的技术水平提高到一个很高的水准上。但是随着技术的进步、技术门槛一点点地被攻破，后来者就不用走太多弯路，吸取前人经验，就可以相对轻松地达到较高的水准。作为老师，主要职责就是从行业经验、失败案例、大家踩过的坑中总结经验、形成新的训练方法和教学体系，进而培养出更高水平的学员。你作为老师，还抱着“师傅领进门，修行在个人”的思想，我觉得已经不太适宜这个时代了，也许你是对的，这个世界就是这样，有人想中庸，平平淡淡过日子，岁月静好，有人想追求极致，不断超越自己、不断突破自己的极限。你有你的生存空间和教学思想，但是你不能不允许像《爆裂鼓手》这样的老师和学生的存在。
因此把在帖子里宣称自己是老师的一些人身攻击的评论删除了，你自己单开一贴骂就可以了，不想再理你，祝您开心。只是想善意提醒一下，作为一名在知乎上到处宣称自己是老师，并在 B 站上兼职做游戏主播的您，如果不能分享有趣的知识给大家，建议还是全职做游戏主播比较靠谱，至少不用现在在知乎上到处蹭热点、举报这个、举报那个，还引以为豪，把自己举报的战绩挂到自己的空间里分享，您不觉得无聊么？这就是您作为一个老师的基本素质？如果您无聊的话，建议多分析几篇你引以为傲的 C 语言混乱代码，多实用啊！挂到自己的空间上，还可以装点门面。然后哄一帮小孩子编程，反正又不用到实际的工作项目中。我们现在讨论的是 C 语言在嵌入式、Linux 行业扎扎实实在用的一些东西，不学习就看不懂、影响工作的一些东西，总之，跟你不在一个频道上。您在外围既然不想踏进来，那就继续呆在你的舒适区，也请不要忽悠想进来进一步提高的人跟你一样在外围转悠。至于其他的您就别费心了，希望您在少儿编程领域越走越好，小孩子跟着你能开心，喊你一声叫哥哥，一下子又仿佛年轻好几岁，是不是很开心？岂不乐哉？
宏 VS 内联函数
关于宏和函数的讨论，这个一下子说不清楚，有很多历史遗留原因：早期的 C 编译器，由于编译环境限制，比如内存可能只有几十 KB，不能把一个工程的所有源文件都加载到内存一次性编译，而是一个文件一个文件的编译，然后再使用链接器链接，生成可执行文件。所以对于变量、函数名这些标识符，必须先声明后引用，以配合编译器检查，于是就有了头文件这个东西。
包括内联函数也是一样，内联函数的执行效率高，书写方便，易于维护。早期的 C 语言是没有内联的，后来的 C 语言标准借鉴了 C++ 的很多优点，才扩充成为自己的 C 语言标准，比如内联函数、支持 // 注释等。但在早期的 C 中，宏确实是个编写程序的利器，尤其是在一些 C 开源软件中，如 glibc、Linux 内核，到处可见其张牙舞爪、各种炫技。那些顶尖的内核开发者们似乎要把宏的极限发挥到极致，把 C 语言的性能在底层开发领域发挥到极致。
对于一个 C 语言初学者来说，这里只是拓展了你对 C 语言的认知上限和边界：原来 C 语言还有这些不被人熟悉的东西。如果你以后想从事互联网开发，以后学习 Java、python、PHP、C++…..，这些东西可以不必关心，因为以后也用不到。如果你以后从事嵌入式开发、Linux 环境下开发，可能会接触到很多底层代码、跨平台代码，C 语言的这些扩展语法、底层的一些特性还是不得不学的，因为这些底层代码、GNU 开源代码处处在使用它。
关于宏的进一步学习，可以参考下面这 2 个帖子，写得很好：宏的很多应用并不是装逼，而是能很优雅地解决很多实际问题：
代码自动生成 – 宏带来的奇技淫巧 – loop_in_codes – C++ 博客深入理解 C 语言中宏定义
这篇帖子是从我以前写的 C 语言教程《嵌入式 C 语言自我修养》1~13 篇中的一篇 copy 过来的。在自己从事驱动开发、阅读内核源码的学习和工作过程中，总感觉阅读 Linux 内核代码力不从心，有些代码稀奇古怪，很难理解。在此背景下写了这篇 GNU C 扩展语法教程，旨在帮助大家学习 Linux 环境下，C 语言的一些扩展的语法，突破阅读障碍。大家以后如果想从事 Linux 环境下的开发工作、包括 Linux 内核、系统开发、应用开发，甚至阅读一些 GNU 开源软件，这部教程对您还是有一定帮助的。对于 C 语言初学者来说，希望这篇文章能拓宽你的视野：C 语言不仅仅是书本上、教科书上的那些知识，还有一些书本上现在看不到的知识。本人时间精力有限，尝试写了一部分，希望能拓宽你的知识面，开拓你的视野。
你是继续停留在自己的舒适区，岁月静好？还是不断去拓展自己的知识边界，不断提升自己，不断去提高自己的职场竞争力？路在你的脚下，选择权在你的手中。
跟涛哥一起学嵌入式宅学部落：跟涛哥一起学嵌入式 15：你为什么看不懂 Linux 内核驱动源码？宅学部落：嵌入式 C 语言自我修养 01：Linux 内核中的 C 语言语法扩展宅学部落：嵌入式 C 语言自我修养 02：Linux 内核驱动中的指定初始化宅学部落：嵌入式 C 语言自我修养 03：宏构造利器：语句表达式宅学部落：嵌入式 C 语言自我修养 04：Linux 内核第一宏：container_of宅学部落：嵌入式 C 语言自我修养 05：零长度数组宅学部落：嵌入式 C 语言自我修养 06：U-boot 镜像自拷贝分析：section 属性宅学部落：嵌入式 C 语言自我修养 07：地址对齐那些事儿宅学部落：嵌入式 C 语言自我修养 08：变参函数的格式检查宅学部落：嵌入式 C 语言自我修养 09：链接过程中的强符号和弱符号宅学部落：嵌入式 C 语言自我修养 10：内联函数探究宅学部落：嵌入式 C 语言自我修养 11：有一种函数，叫内建函数宅学部落：嵌入式 C 语言自我修养 12：有一种宏，叫可变参数宏宅学部落：嵌入式 C 语言自我修养 13：C 语言习题测试
