为了账号安全，请及时绑定邮箱和手机
点击这里，将文章分享到自己的动态
python闭包：确保引用的局部变量在函数返回后不能变
def calc_sum(lst):
def lazy_sum():
return sum(lst)
return lazy_sum
像这种内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）。
闭包的特点是返回的函数还引用了外层函数的局部变量，所以，要正确使用闭包，就要确保引用的局部变量在函数返回后不能变。
# 希望一次返回3个函数，分别计算1x1,2x2,3x3:
def count():
for i in range(1, 4):
return i*i
fs.append(f)
f1, f2, f3 = count()
你可能认为调用f1()，f2()和f3()结果应该是1，4，9，但实际结果全部都是 9（请自己动手验证）。
原因就是当count()函数返回了3个函数时，这3个函数所引用的变量 i 的值已经变成了3。由于f1、f2、f3并没有被调用，所以，此时他们并未计算 i*i，当 f1 被调用时：
# 因为f1现在才计算i*i，但现在i的值已经变为3
若觉得本文不错，就分享一下吧！
评论加载中...
相关文章推荐
正在加载中
作者相关文章C++返回局部变量的引用_百度知道
C++返回局部变量的引用
问题一：返回一个局部变量的引用。如：int&ABC(){intn=5;}voidmain(){x=ABC();cout&&x&&}为什么这里能接收到返回局部变量的引用呢？局部变量n没有被销毁吗？我实验...
问题一：返回一个局部变量的引用。如：int& ABC() {
int n = 5; }void main(){
cout&&x&&}为什么这里能接收到 返回局部变量的引用呢？局部变量n没有被销毁吗？我实验过了。问题二：局部对象这样也可以接收到。如下面这个程序：#include &iostream&class Complex
{public: Complex(double r=0,double i=0) {
real=r;imag=i; }
Complex(const Complex& c); Complex& operator+(Complex &);
void display( );
private: double real,
};Complex::Complex(const Complex& c){ real=c. imag=c.}Complex& Complex::operator+(Complex &c2){ int a=1; C
c.real=real+c2. c.imag=imag+c2. }void Complex::display( )
int xxxx=1; cout &&&(& &&real &&&+& &&imag &&&i)& &&}int main( ){ double x, cin&&x&&y; Complex comp1(x,y),comp2(y,x),comp3;
comp1.display( );
comp2.display( );
comp3=comp1.operator+(comp2); //用对象
接收函数返回的引用 Complex& p=comp1.operator+(comp2);
//用对象的引用
接收函数返回的引用
p.display(); comp3.display(); return 0;}这里 《用对象
接收函数返回的引用》和《用对象的引用
接收函数返回的引用》结果是不同的，一个被释放了。另一个没有被释放。为什么？用不同的类型接收 局部对象的引用有什么区别吗？不要说《用对象
接收函数返回的引用》 会调用拷贝构造函数。我设了断点看了。没有进入拷贝构造函数。而且很奇怪的现像是：
对于局部对象C的地址&C和《用对象
接收函数返回的引用》的对象comp3地址不同。。。 不理解《用对象接收 函数返回的引用》内部是怎样运作 的？int& ABC() {
int n = 5; } 如何实现 能让 int x=ABC()结果变？请举个例子对于赋值。comp3=comp1.operator+(comp2);如何实现 也能让 comp3变随机值？ 举例说明。。看不到不正常 我以后就这么用 返回临时变量的引用了。。。。
答题抽奖
首次认真答题后
即可获得3次抽奖机会，100%中奖。
采纳数：58
获赞数：195
1,所谓不能返回局部变量，是指局部变量在栈空间中分配内存，函数返回时栈指针回退，当主调函数继续调用其它被调函数时，栈指针上移，上一次函数调用所分配的空间会被本次调用覆盖，如果此时再引用原来的局部变量就会出现不可预见的结果。所以局部变量在函数返回时并不是被销毁而是相当于可被再次利用。所以如果第一题你在cout&&x&&前调用一函数，此函数大量分配局部变量，后面的输出值必变！2。第二题要明确构造函数是在对象构造时调用的，而不是在对象间相互赋值时调用的，你的comp3在对象在申明时已经调用了Complex(double r=0,double i=0).如果你这样写:& Complex comp3=comp1.operator+(comp2); //用对象
接收函数返回的引用& 则拷贝构造函数必被调用到。所以这样对于&局部对象C的地址&C和《用对象
接收函数返回的引用》的对象comp3地址不同。。。 &应该理解的吧。补充:向你这样把返回的引用赋给变量是无论怎么都不会变的，因为返回时进行了变量的复制(不一定是调用构造函数)，要改变其实我上面已经说了只要在cout&&X前调用一个函数且函数内定义了局部变量即可：
int &x= ABC(); //必须定义成引用
cout&&x;void test(){
int a=8;}这样X的输出将是8,下题类似不再举例.
lixuanalex
lixuanalex
获赞数：11
两个问题的原理一样。第一个程序，你用下面的程序做下比较int& ABC() {
int n = 5;
cout && *n &&
// 这里打印出n的内存地址，假设是 0001 }void main(){
// 执行函数，打印0001
cout&&*x&&
// 这里打印出n的内存地址， 你会发现打印出来的结果是0002。
int& y = ABC();
// 执行函数，打印0001
cout && *y &&
打印y的地址，你会发现打印的结果一热是0001}第二个程序，使用同样的方法测试下要修改的地方有： display函数中语句改成下面的语句
cout &&&(& &&*real &&&+& &&*imag &&&i)& &&Complex& Complex::operator+(Complex &c2)函数中在return之前加一句
c.display();执行，你会发现，comp3.display() 得到的结果与c.display()得到的结果不同。而p.display()得到的结果越与c.display() 得到的结果是相同的。原理：使用语句 Complex& p 会调用构造函数，因为这样写在编译器看来p只是一个别名（也就是对象的引用），没有分配另外分配内存。而Complex comp3 则不同，在编译器看来，comp3是一个需要特别为其分配另外的内存空间的变量（也就是对象）。利用返回引用类型的函数为p和comp3说白了，对p的赋值就是为局部变量的内存空间其别名p，而对comp3就是将局部变量的值赋给comp3。而由于局部变量在函数执行完毕后会被回收内存空间。因此，p指向的内存被销毁，值就变了。注意：用下面的语句会发生编译错误
error C2530: “p”: 必须初始化引用
采纳数：152
获赞数：809
第一个问题：函数退出时局部变量出栈，对象肯定是销毁了。销毁指的是将那块内存标为空闲供其它变量使用，而该内存上的值仍然存在。释放后那块内存并不是马上就被其他地方占用，根据实际情况起码会空闲一会，可能是一瞬间。如果你的程序较复杂，那这块内存可能很快就再次被使用，如果程序很简单，可能在很长一段时间内都是空闲。所以在函数返回后将变量的值马上赋值给另外一个变量，局部变量已经销毁了，这块内存上的值还没来得及被修改，所以你的外部变量获得了一个正确的值。所以你的结果正确并不代表变量没有被销毁。无论用引用还是变量来接受局部变量的值，局部变量肯定是已经销毁了的。第二个问题：用引用和用对象的区别在于，引用只是个别名，类似指针（引用在C++底层其实就是指针），而对象需要构造。你的局部变量跟接受值的外部变量是两个变量，分配在不同的栈上，所以肯定有两个不同的地址了。比如，引用：MyClass& x = func();这个只是将引用指向func()返回的变量。对象：分两种情况：MyClass x = func();这种情况调用的是MyClass的拷贝构造函数给x赋的值。MyCx = func();这种情况调用的是MyClass的operator=给x赋的值。你可以自己写个类，在它的拷贝构造函数或operator=函数返回前加很多乱七八糟的代码，等函数返回后再看成员变量的值是否还正常，有很大几率是个随机值。
采纳数：267
获赞数：572
1、调用函数时，向操作系统申请栈空间，函数返回时，栈空间被回收，就好比你向房东租房子，退房后，房子里面的东西（栈空间的变量）或许不变，或许物是人非，但你无权过问2、先了解什么叫拷贝函数，什么叫拷贝构造函数如何实现 也能让 comp3变随机值？ 举例说明。。倘若其它进程或线程或就是本进程的某个操作刷写了该地址的内容，那结果就是错误的。使用权不在你，操作系统无义务向你确保不改变该地址空间的内容
zhaomingnpu
zhaomingnpu
采纳数：45
获赞数：69
擅长：暂未定制
1：n值肯定是被销毁了，=将返回值的引用赋给x然后销毁n，栈上肯定是没有n的数据了。Complex& p=comp1.operator+(comp2);这么使用本身就是错的，引用就是一个别名，那句执行完之后的话p是栈上一个已经析构了complex对象的一个别名,结果肯定是不对的
其他2条回答
为你推荐：
其他类似问题
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。Computer Vision
如何编写无法维护的代码(现实中有的程序员就是这么干的)
让自己稳拿铁饭碗 ;-)
– Roedy Green（翻译版略有删节）
http://blog.jobbole.com/80241/
永远不要（把自己遇到的问题）归因于（他人的）恶意，这恰恰说明了（你自己的）无能。 — 拿破仑
为了造福大众，在Java编程领域创造就业机会，兄弟我在此传授大师们的秘籍。这些大师写的代码极其难以维护，后继者就是想对它做最简单的修改都需要花上数年时间。而且，如果你能对照秘籍潜心修炼，你甚至可以给自己弄个铁饭碗，因为除了你之外，没人能维护你写的代码。再而且，如果你能练就秘籍中的全部招式，那么连你自己都无法维护你的代码了！
（伯乐在线配图）
你不想练功过度走火入魔吧。那就不要让你的代码一眼看去就完全无法维护，只要它实质上是那样就行了。否则，你的代码就有被重写或重构的风险！
Quidquid latine dictum sit, altum sonatur.
(随便用拉丁文写点啥都会显得高大上。)
想挫败维护代码的程序员，你必须先明白他的思维方式。他接手了你的庞大程序，没有时间把它全部读一遍，更别说理解它了。他无非是想快速找到修改代码的位置、改代码、编译，然后就能交差，并希望他的修改不会出现意外的副作用。
他查看你的代码不过是管中窥豹，一次只能看到一小段而已。你要确保他永远看不到全貌。要尽量让他难以找到他想找的代码。但更重要的是，要让他不能有把握忽略任何东西。
程序员都被编程惯例洗脑了，还为此自鸣得意。每一次你处心积虑地违背编程惯例，都会迫使他必须用放大镜去仔细阅读你的每一行代码。
你可能会觉得每个语言特性都可以用来让代码难以维护，其实不然。你必须精心地误用它们才行。
“当我使用一个单词的时候” Humpty Dumpty 曾经用一种轻蔑的口气说, “它就是我想表达的意思，不多也不少。“
– Lewis Carroll — 《爱丽丝魔镜之旅》， 第6章
编写无法维护代码的技巧的重中之重是变量和方法命名的艺术。如何命名是和编译器无关的。这就让你有巨大的自由度去利用它们迷惑维护代码的程序员。
妙用&宝宝起名大全
单字母变量名
创造性的拼写错误
首字母大写的缩写
辞典大轮换
首字母大写
使用非英语字母
看上去没啥不对是吧？嘿嘿嘿…这里的第二个 ínt 的&í&实际上是东北欧字母，并不是英语中的 i 。在简单的文本编辑器里，想看出这一点点区别几乎是不可能的。
巧妙利用编译器对于命名长度的限制
下划线，真正的朋友
混合多语言
扩展 ASCII 字符
其他语言的命名
= (slash + asterix) /
令人眩晕的命名
marypoppins
= (superman + starship) /
这一招可以让阅读代码的人陷入迷惑之中，因为他们在试图想清楚这些命名的逻辑时，会不自觉地联系到不同的感情场景里而无法自拔。
何时使用 i
惯例 — 明修栈道，暗度陈仓
忽视 Java 编码惯例，Sun 自己就是这样做的。幸运的是，你违反了它编译器也不会打小报告。这一招的目的是搞出一些在某些特殊情况下有细微差别的名字来。如果你被强迫遵循驼峰法命名，你还是可以在某些模棱两可的情况下颠覆它。例如，inputFilename 和 inputfileName&两个命名都可以合法使用。在此基础上自己发明一套复杂到变态的命名惯例，然后就可以痛扁其他人，说他们违反了惯例。
小写的 l 看上去很像数字 1
把全局命名重用为私有
误导性的命名
让每个方法都和它的名字蕴含的功能有一些差异。例如，一个叫 isValid(x)的方法在判断完参数x的合法性之后，还顺带着把它转换成二进制并保存到数据库里。
当一个bug需要越长的时间才会暴露，它就越难被发现。- Roedy Green（本文作者）
编写无法维护代码的另一大秘诀就是伪装的艺术，即隐藏它或者让它看起来像其他东西。很多招式有赖于这样一个事实：编译器比肉眼或文本编辑器更有分辨能力。下面是一些伪装的最佳招式。
把代码伪装成注释，反之亦然
j&array_ j+ =8)
&&&&&total
+= array[j+0 ];
&&&&&total
+= array[j+1 ];
&&&&&total
+= array[j+2 ];
&&&&&total
+= array[j+6 ];
&&&&&total
+= array[j+7 ];
如果不是用绿色标出来，你能注意到这三行代码被注释掉了么？
用连接符隐藏变量
local_var xy_z
可以把 “xy_z” 打散到两行里：
local_var xy\
这样全局搜索 xy_z 的操作在这个文件里就一无所获了。 对于 C 预处理器来说，第一行最后的 “\” 表示继续拼接下一行的内容。
任何傻瓜都能说真话，而要把谎编圆则需要相当的智慧。- Samuel Butler (1835 – 1902)
不正确的文档往往比没有文档还糟糕。- Bertrand Meyer
既然计算机是忽略注释和文档的，你就可以在里边堂而皇之地编织弥天大谎，让可怜的维护代码的程序员彻底迷失。
在注释中撒谎
只记录显而易见的东西
记录 How 而不是 Why
该写的别写
在注释里挑拨离间
clever_SSInc
可能的话，除了注释之外，这些攻击抹黑的内容也要掺到代码里的重要语义部分，这样如果管理层想清理掉这些攻击性的言论然后发给外部承包商去维护，就会破坏代码结构。
编写无法维护代码的基本规则就是：在尽可能多的地方，以尽可能多的方式表述每一个事实。- Roedy Green
编写可维护代码的关键因素是只在一个地方表述应用里的一个事实。如果你的想法变了，你也只在一个地方修改，这样就能保证整个程序正常工作。所以，编写无法维护代码的关键因素就是反复地表述同一个事实，在尽可能多的地方，以尽可能多的方式进行。令人高兴的是，像Java这样的语言让编写这种无法维护代码变得非常容易。例如，改变一个被引用很多的变量的类型几乎是不可能的，因为所有造型和转换功能都会出错，而且关联的临时变量的类型也不合适了。而且，如果变量值要在屏幕上显示，那么所有相关的显示和数据录入代码都必须一一找到并手工进行修改。类似的还有很多，比如由C和Java组成的Algol语言系列，Abundance甚至Smalltalk对于数组等结构的处理，都是大有可为的。
利用Java的冗余
Bubblegom();
= swimner + 1;
永远不做校验
有礼貌，无断言
复制粘贴修改
使用静态数组
巨型监听器
好事成堆TM
myPanel.add(
getMyButton() );
JButton getMyButton()
&&&&&return
友好的朋友
使用三维数组
混合与匹配
就是 Final
全局变量，怎么强调都不过分
再一次说说全局变量
对于编写无法维护代码的任务来说，面向对象编程的思想简直是天赐之宝。如果你有一个类，里边有10个属性（成员/方法），可以考虑写一个基类，里面只有一个属性，然后产生9层的子类，每层增加一个属性。等你访问到最终的子类时，你才能得到全部10个属性。如果可能，把每个类的声明都放在不同的文件里。
= &three&;
&&&&printf(&%s&,
&&&&break;
一致性的小淘气
嵌套 Switch
利用隐式转化
使用八进制数
= new int []
myfunc(int
p) { return
myfunc(6291,
8)[Array];
遗憾的是，这一招只能在本地C类里用，Java 还不行。
放长线钓大鱼
使用异常的时机
狂热奔放地使用线程
在程序里留些bug，让后继的维护代码的程序员能做点有意思的事。精心设计的bug是无迹可寻的，而且谁也不知道它啥时候会冒出来。要做到这一点，最简单的办法的就是不要测试代码。
永远不要做性能测试
永远不要写任何测试用例
测试是给懦夫用的
勇敢的程序员会跳过这个步骤。太多程序员害怕他们的老板，害怕丢掉工作，害怕客户的投诉邮件，害怕遭到起诉。这种恐惧心理麻痹了行动，降低了生产率。有科学研究成果表明，取消测试阶段意味着经理有把握能提前确定交付时间，这对于规划流程显然是有利的。消除了恐惧心理，创新和实验之花就随之绽放。程序员的角色是生产代码，调试工作完全可以由技术支持和遗留代码维护组通力合作来进行。
如果我们对自己的编程能力有充分信心，那么测试就没有必要了。如果我们逻辑地看待这个问题，随便一个傻瓜都能认识到测试根本都不是为了解决技术问题，相反，它是一种感性的信心问题。针对这种缺乏信心的问题，更有效的解决办法就是完全取消测试，送我们的程序员去参加自信心培训课程。毕竟说起来，如果我们选择做测试，那么我们就要测试每个程序的变更，但其实我们只需要送程序员去一次建立自信的培训课就行了。很显然这么做的成本收益是相当可观的。
编程语言的选择
计算机语言正在逐步进化，变得更加傻瓜化。使用最新的语言算什么好汉？尽可能坚持使用你会用的最老的语言，先考虑用穿孔纸带，不行就用汇编，再不行用FORTRAN 或者 COBOL，再不行就用C 还有 BASIC，实在不行再用 C++。
宏汇编调用C
如果你有个汇编模块被C调用，那就尽可能经常从汇编模块再去调用C，即使只是出于微不足道的用途，另外要充分利用 goto, bcc 和其他炫目的汇编秘籍。
与他人共事之道
老板才是真行家
颠覆技术支持
每月一书俱乐部
加入一个计算机每月一书俱乐部。选择那些看上去忙着写书不可能有时间真的去写代码的作者。去书店里找一些有很多图表但是没有代码例子的书。浏览一下这些书，从中学会一些迂腐拗口的术语，用它们就能唬住那些自以为是的维护代码的程序员。你的代码肯定会给他留下深刻印象。如果人们连你写的术语都理解不了，他们一定会认为你非常聪明，你的算法非常深奥。不要在你的算法说明里作任何朴素的类比。
你一直想写系统级的代码。现在机会来了。忽略标准库， 编写你自己的标准，这将会是你简历中的一大亮点。
推出你自己的 BNF 范式
推出你自己的内存分配
地球人儿都知道，调试动态存储是复杂和费时的。与其逐个类去确认它没有内存溢出，还不如自创一套存储分配机制呢。其实它无非是从一大片内存中 malloc 一块空间而已。用不着释放内存，让用户定期重启动系统，这样不就清除了堆么。重启之后系统需要追踪的就那么一点东西，比起解决所有的内存泄露简单得不知道到哪里去了！而且，只要用户记得定期重启系统，他们也永远不会遇到堆空间不足的问题。一旦系统被部署，你很难想象他们还能改变这个策略。
其他杂七杂八的招
如果你给某人一段程序，你会让他困惑一天；如果你教他们如何编程，你会让他困惑一辈子。 — Anonymous
不要重编译
让我们从一条可能是有史以来最友好的技巧开始：把代码编译成可执行文件。如果它能用，就在源代码里做一两个微小的改动 — 每个模块都照此办理。但是不要费劲巴拉地再编译一次了。&你可以留着等以后有空而且需要调试的时候再说。多年以后，等可怜的维护代码的程序员更改了代码之后发现出错了，他会有一种错觉，觉得这些肯定是他自己最近修改的。这样你就能让他毫无头绪地忙碌很长时间。
挫败调试工具
对于试图用行调试工具追踪来看懂你的代码的人，简单的一招就能让他狼狈不堪，那就是把每一行代码都写得很长。特别要把 then 语句 和 if 语句放在同一行里。他们无法设置断点。他们也无法分清在看的分支是哪个 if 里的。
公制和美制
在工程方面有两种编码方式。一种是把所有输入都转换为公制（米制）计量单位，然后在输出的时候自己换算回各种民用计量单位。另一种是从头到尾都保持各种计量单位混合在一起。总是选择第二种方式，这就是美国之道！
要持续不懈地改进。要常常对你的代码做出“改进”，并强迫用户经常升级 — 毕竟没人愿意用一个过时的版本嘛。即便他们觉得他们对现有的程序满意了，想想看，如果他们看到你又“完善“了它，他们会多么开心啊！不要告诉任何人版本之间的差别，除非你被逼无奈 — 毕竟，为什么要告诉他们本来永远也不会注意到的一些bug呢？
”关于“一栏应该只包含程序名、程序员姓名和一份用法律用语写的版权声明。理想情况下，它还应该链接到几 MB 的代码，产生有趣的动画效果。但是，里边永远不要包含程序用途的描述、它的版本号、或最新代码修改日期、或获取更新的网站地址、或作者的email地址等。这样，所有的用户很快就会运行在各种不同的版本上，在安装N+1版之前就试图安装N+2版。
在两个版本之间，你能做的变更自然是多多益善。你不会希望用户年复一年地面对同一套老的接口或用户界面，这样会很无聊。最后，如果你能在用户不注意的情况下做出这些变更，那就更好了 — 这会让他们保持警惕，戒骄戒躁。
写无法维护代码不需要多高的技术水平。喊破嗓子不如甩开膀子，不管三七二十一开始写代码就行了。记住，管理层还在按代码行数考核生产率，即使以后这些代码里的大部分都得删掉。
只带一把锤子
一招鲜吃遍天，会干什么就吆喝什么，轻装前进。如果你手头只有一把锤子，那么所有的问题都是钉子。
有可能的话，忽略当前你的项目所用语言和环境中被普罗大众所接受的编程规范。比如，编写基于MFC 的应用时，就坚持使用STL 编码风格。
翻转通常的 True False 惯例
把常用的 true 和 false 的定义反过来用。这一招听起来平淡无奇，但是往往收获奇效。你可以先藏好下面的定义：
把这个定义深深地藏在代码中某个没人会再去看的文件里不易被发现的地方，然后让程序做下面这样的比较
( var == TRUE )
( var != FALSE )
某些人肯定会迫不及待地跳出来“修正”这种明显的冗余，并且在其他地方照着常规去使用变量var：
还有一招是为 TRUE 和 FALSE赋予相同的值，虽然大部分人可能会看穿这种骗局。给它们分别赋值 1 和 2 或者 -1 和 0 是让他们瞎忙乎的方式里更精巧的，而且这样做看起来也不失对他们的尊重。你在Java 里也可以用这一招，定义一个叫 TRUE 的静态常量。在这种情况下，其他程序员更有可能怀疑你干的不是好事，因为Java里已经有了内建的标识符 true。
在你的项目里引入功能强大的第三方库，然后不要用它们。潜规则就是这样，虽然你对这些工具仍然一无所知，却可以在你简历的“其他工具”一节中写上这些没用过的库。
假装不知道有些库已经直接在你的开发工具中引入了。如果你用VC++编程，忽略MFC 或 STL 的存在，手工编写所有字符串和数组的实现；这样有助于保持你玩指针技术的高水平，并自动阻止任何扩展代码功能的企图。
创建一套Build顺序
把这套顺序规则做得非常晦涩，让维护者根本无法编译任何他的修改代码。秘密保留 SmartJ ，它会让 make脚本形同废物。类似地，偷偷地定义一个 javac 类，让它和编译程序同名。说到大招，那就是编写和维护一个定制的小程序，在程序里找到需要编译的文件，然后通过直接调用 sun.tools.javac.Main 编译类来进行编译。
Make 的更多玩法
用一个 makefile-generated-batch-file 批处理文件从多个目录复制源文件，文件之间的覆盖规则在文档中是没有的。这样，无需任何炫酷的源代码控制系统，就能实现代码分支，并阻止你的后继者弄清哪个版本的 DoUsefulWork() 才是他需要修改的那个。
搜集编码规范
尽可能搜集所有关于编写可维护代码的建议，例如 SquareBox 的建议 ，然后明目张胆地违反它们。
规避公司的编码规则
某些公司有严格的规定，不允许使用数字标识符，你必须使用预先命名的常量。要挫败这种规定背后的意图太容易了。比如，一位聪明的 C++ 程序员是这么写的：
K_THOUSAND 999
编译器警告
一定要保留一些编译器警告。在 make 里使用 “-” 前缀强制执行，忽视任何编译器报告的错误。这样，即使维护代码的程序员不小心在你的源代码里造成了一个语法错误，make 工具还是会重新把整个包build 一遍，甚至可能会成功！而任何程序员要是手工编译你的代码，看到屏幕上冒出一堆其实无关紧要的警告，他们肯定会觉得是自己搞坏了代码。同样，他们一定会感谢你让他们有找错的机会。学有余力的同学可以做点手脚让编译器在打开编译错误诊断工具时就没法编译你的程序。当然了，编译器也许能做一些脚本边界检查，但是真正的程序员是不用这些特性的，所以你也不该用。既然你用自己的宝贵时间就能找到这些精巧的bug，何必还多此一举让编译器来检查错误呢？
把 bug 修复和升级混在一起
永远不要发布什么“bug 修复”版本。一定要把 bug 修复和数据库结构变更、复杂的用户界面修改，还有管理界面重写等混在一起。那样的话，升级就变成一件非常困难的事情，人们会慢慢习惯 bug 的存在并开始称他们为特性。那些真心希望改变这些”特性“的人们就会有动力升级到新版本。这样从长期来说可以节省你的维护工作量，并从你的客户那里获得更多收入。
在你的产品发布每个新版本的时候都改变文件结构
没错，你的客户会要求向上兼容，那就去做吧。不过一定要确保向下是不兼容的。这样可以阻止客户从新版本回退，再配合一套合理的 bug 修复规则（见上一条），就可以确保每次新版本发布后，客户都会留在新版本。学有余力的话，还可以想办法让旧版本压根无法识别新版本产生的文件。那样的话，老版本系统不但无法读取新文件，甚至会否认这些文件是自己的应用系统产生的！温馨提示：PC 上的 Word 文字处理软件就典型地精于此道。
不用费劲去代码里找 bug 的根源。只要在更高级的例程里加入一些抵销它的代码就行了。这是一种很棒的智力测验，类似于玩3D棋，而且能让将来的代码维护者忙乎很长时间都想不明白问题到底出在哪里：是产生数据的低层例程，还是莫名其妙改了一堆东西的高层代码。这一招对天生需要多回合执行的编译器也很好用。你可以在较早的回合完全避免修复问题，让较晚的回合变得更加复杂。如果运气好，你永远都不用和编译器前端打交道。学有余力的话，在后端做点手脚，一旦前端产生的是正确的数据，就让后端报错。
使用旋转锁
不要用真正的同步原语，多种多样的旋转锁更好 — 反复休眠然后测试一个(non-volatile的) 全局变量，直到它符合你的条件为止。相比系统对象，旋转锁使用简便，”通用“性强，”灵活“多变，实为居家旅行必备。
随意安插 sync 代码
把某些系统同步原语安插到一些用不着它们的地方。本人曾经在一段不可能会有第二个线程的代码中看到一个临界区（critical section）代码。本人当时就质问写这段代码的程序员，他居然理直气壮地说这么写是为了表明这段代码是很”关键“（单词也是critical）的！
如果你的系统包含了一套 NT 设备驱动，就让应用程序负责给驱动分配 I/O 缓冲区，然后在任何交易过程中对内存中的驱动加锁，并在交易完成后释放或解锁。这样一旦应用非正常终止，I/O缓存又没有被解锁，NT服务器就会当机。但是在客户现场不太可能会有人知道怎么弄好设备驱动，所以他们就没有选择（只能请你去免费旅游了）。
定制脚本语言
在你的 C/S 应用里嵌入一个在运行时按字节编译的脚本命令语言。
依赖于编译器的代码
如果你发现在你的编译器或解释器里有个bug，一定要确保这个bug的存在对于你的代码正常工作是至关重要的。毕竟你又不会使用其他的编译器，其他任何人也不允许！
一个货真价实的例子
下面是一位大师编写的真实例子。让我们来瞻仰一下他在这样短短几行 C 函数里展示的高超技巧。
Realocate(void*buf,
&&&&&void*
= malloc(os);
&&&&&memcpy((void*)temp,
(void*)buf,
&&&&&free(buf);
= malloc(ns);
&&&&&memset(buf,
&&&&&memcpy((void*)buf,
(void*)temp,
&&&&&return
重新发明了标准库里已有的简单函数。
Realocate 这个单词拼写错误。所以说，永远不要低估创造性拼写的威力。
无缘无故地给输入缓冲区产生一个临时的副本。
无缘无故地造型。 memcpy() 里有 (void*)，这样即使我们的指针已经是 (void*) 了也要再造型一次。另外，这样做可以传递任何东西作为参数，加10分。
永远不必费力去释放临时内存空间。这样会导致缓慢的内存泄露，一开始看不出来，要程序运行一段时间才行。
把用不着的东西也从缓冲区里拷贝出来，以防万一。这样只会在Unix上产生core dump，Windows 就不会。
很显然，os 和 ns 的含义分别是”old size” 和 “new size”。
给 buf 分配内存之后，memset 初始化它为 0。不要使用 calloc()，因为某些人会重写 ANSI 规范，这样将来保不齐 calloc() 往 buf 里填的就不是 0 了。（虽然我们复制过去的数据量和 buf 的大小是一样的，不需要初始化，不过这也无所谓啦）
如何修复 “unused variable” 错误
如果你的编译器冒出了 “unused local variable” 警告，不要去掉那个变量。相反，要找个聪明的办法把它用起来。我最喜欢的方法是：
大小很关键
差点忘了说了，函数是越大越好。跳转和 GOTO 语句越多越好。那样的话，想做任何修改都需要分析很多场景。这会让维护代码的程序员陷入千头万绪之中。如果函数真的体型庞大的话，对于维护代码的程序员就是哥斯拉怪兽了，它会在他搞清楚情况之前就残酷无情地将他踩翻在地。
一张图片顶1000句话，一个函数就是1000行
把每个方法体写的尽可能的长 — 最好是你写的任何一个方法或函数都不会少于1000行代码，而且里边是深度嵌套，这是必须的。
一定要保证一个或多个关键文件无法找到。利用includes 里边再 includes 就能做到这一点。例如，在你的 main 模块里，你写上：
&stdcode.h&
Stdcode.h 是有的。但是在 stdcode.h 里，还有个引用：
&a:\\refcode.h&
然后，refcode.h 就没地方能找到了。
（【译者注】为啥找不到呢？仔细看看，现在还有人知道 a:\ 是什么吗？A盘！传说中的软盘…）
到处都写，无处会读
至少要把一个变量弄成这样：到处被设置，但是几乎没有哪里用到它。不幸的是，现代编译器通常会阻止你做相反的事：到处读，没处写。不过你在C 或 C++ 里还是可以这样做的。
【译注】：原文在后面还有一些内容，翻译时略有删减。删节的内容主要是：
我看不懂的部分;
我觉得不怎么好笑的部分（其实很可能是因为没看懂所以找不到笑点）;
不容易引起现代程序猿共鸣的老旧内容。
本人水平有限，时间匆忙，难免有误，请读者不吝指出。谢谢！
怎么写出不可维护的PHP代码？
资深程序员冒死揭开软件潜规则：无法维护的代码
老码农冒死揭开行业黑幕：如何编写无法维护的代码
如何维护自己以前写的糟糕程序
一步步教你编写不可维护的 PHP 代码
一个java程序员的真实经历
老码农冒死揭开行业黑幕：如何编写无法维护的代码（上篇）
一个十几年程序员给所有新老程序员的忠告
程序员们，你愿意维护别人写的“烂”代码么?
没有更多推荐了，