Question

在thedailywtf.com上阅读此article之后，我不确定我是否真的得到了这个笑话。

它说有人改变了代码

int function() 
{ 
  int x;
  char data_string[15];
  ...
  x = 2;
  strcpy(data_string,"data data data");
  ...
}

到

int function() 
{
  int x = 2;
  char data_string[15] = "data data data";
  ...
}

代码中的任何地方，由于某种原因确实将可执行文件的大小从1张CD扩充到2张（或者可能没有这样做？）。

显然我对C / C ++不熟悉得到这个笑话，但最让人感到奇怪的是，第二个代码清单似乎“更干净” - 至少从我在学校被告知的那个（即初始化）变量是一件好事，而不是坏事。）

Answer 1

OIC，这是源代码流失问题

乍一看，这两种形式是等价的。第二个确实看起来更好，但他们做同样的事情。

但后来我读了引用的页面。

问题是这个新人搅动了源树，很多。通过一个巨大的源代码树进行巨魔并进行毫无意义的改变是一种糟糕的形式。当然，也许一种风格比另一种风格稍好一些，但实际上，在将1000个增量放入源代码控制系统之前，它应该好多了，以便让人们为永恒而跋涉是合理的。< / p>

我怀疑这是源版本，或者其他一些未提及的复杂性导致编辑这么多文件以扩展其分发。对该网站的贡献进行了相当多的编辑，但基本上这个问题在没有具体细节的情况下是可以理解的。

为样式更改编辑zillion文件的一个问题是无意中错误的可能性增加。当初级开发人员这样做时，这个机会大大增加。即使对于有经验的人，也要考虑墨菲定律。如果它在发布之前发生，那真的是一种悬而未决的行为。

Answer 2

取决于编译器和编译器选项，像这样初始化

char data_string[15] = "data data data";

导致大量移动指令将文字数据复制到堆栈。

致电strcpy需要更少的指示。

在大型代码库中执行此类操作可能会显着增加二进制文件大小。

当然，他没有把时间花在增加任何价值上。

Answer 3

第二个代码确实“更干净”，但是如果项目的大小与文章相关，那么认为像这样的重构最多是无用的，最坏的是容易出错，这是荒谬的。

然而，这种重构不会使.Exe大小形式1到2 cds

Answer 4

我无法从中得到不同的行为。我尝试使用LLVM：我必须在返回值处添加一些内容，以便LLVM不会优化任何内容，但生成的wtf和wtf2代码是完全相同的。该wtf是BAAAAAD

输入

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int wtf(int X) {
  int x;
  char data_string[15];
  x = 2;
  strcpy(data_string,"data data data");
  return 5*X+x+ data_string[X];
}
int wtf2(int X) {
  int x = 2;
  char data_string[15]="data data data";
  return 5*X+x+ data_string[X];
}
int main(int argc, char **argv) {
  printf("%d\n", wtf(atoi(argv[1]))+wtf2(atoi(argv[1])));
}

输出：

; ModuleID = '/tmp/webcompile/_3856_0.bc'
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32"
target triple = "i386-pc-linux-gnu"
@.str = internal constant [15 x i8] c"data data data\00"        ; <[15 x i8]*> [#uses=3]
@.str1 = internal constant [4 x i8] c"%d\0A\00"     ; <[4 x i8]*> [#uses=1]

define i32 @wtf(i32 %X) nounwind readnone {
entry:
    %0 = mul i32 %X, 5      ; <i32> [#uses=1]
    %1 = getelementptr [15 x i8]* @.str, i32 0, i32 %X      ; <i8*> [#uses=1]
    %2 = load i8* %1, align 1       ; <i8> [#uses=1]
    %3 = sext i8 %2 to i32      ; <i32> [#uses=1]
    %4 = add i32 %0, 2      ; <i32> [#uses=1]
    %5 = add i32 %4, %3     ; <i32> [#uses=1]
    ret i32 %5
}

define i32 @wtf2(i32 %X) nounwind readnone {
entry:
    %0 = mul i32 %X, 5      ; <i32> [#uses=1]
    %1 = getelementptr [15 x i8]* @.str, i32 0, i32 %X      ; <i8*> [#uses=1]
    %2 = load i8* %1, align 1       ; <i8> [#uses=1]
    %3 = sext i8 %2 to i32      ; <i32> [#uses=1]
    %4 = add i32 %0, 2      ; <i32> [#uses=1]
    %5 = add i32 %4, %3     ; <i32> [#uses=1]
    ret i32 %5
}

define i32 @main(i32 %argc, i8** nocapture %argv) nounwind {
entry:
    %0 = getelementptr i8** %argv, i32 1        ; <i8**> [#uses=1]
    %1 = load i8** %0, align 4      ; <i8*> [#uses=1]
    %2 = tail call i32 @atoi(i8* %1) nounwind readonly      ; <i32> [#uses=2]
    %3 = getelementptr [15 x i8]* @.str, i32 0, i32 %2      ; <i8*> [#uses=1]
    %4 = load i8* %3, align 1       ; <i8> [#uses=1]
    %5 = sext i8 %4 to i32      ; <i32> [#uses=1]
    %tmp2 = mul i32 %2, 10      ; <i32> [#uses=1]
    %6 = shl i32 %5, 1      ; <i32> [#uses=1]
    %7 = add i32 %6, 4      ; <i32> [#uses=1]
    %8 = add i32 %7, %tmp2      ; <i32> [#uses=1]
    %9 = tail call i32 (i8*, ...)* @printf(i8* noalias getelementptr ([4 x i8]* @.str1, i32 0, i32 0), i32 %8) nounwind     ; <i32> [#uses=0]
    ret i32 undef
}

declare i32 @atoi(i8*) nounwind readonly

declare i32 @printf(i8*, ...) nounwind

Answer 5

嗯，请仔细阅读文章：）

真正的WTF是他在应该修复内存泄漏时用这些变化触及了整个解决方案。

同样做这样的改变并不重要，除了可能破坏/引入其他可能比实例更复杂的文件中的错误。

Answer 6

是的，第二个代码更干净，但根据编译器的不同，可能会导致发出更多的机器代码。这完全取决于编译器，但WTF文章的重点是，在第二种情况下，编译器会为每个代码片段分配一个字符串/整数值的副本，在第一种情况下，每个程序只会执行一次

我没有得到这个C / C ++笑话

6 个答案:

OIC，这是源代码流失问题