Question

为了便于阅读，我认为下面的第一个代码块更好。但第二个代码块是否更快？

第一块：

for (int i = 0; i < 5000; i++){
    int number = rand() % 10000 + 1;
    string fizzBuzz = GetStringFromFizzBuzzLogic(number);
}

第二块：

int number;
string fizzBuzz;
for (int i = 0; i < 5000; i++){
    number = rand() % 10000 + 1;
    fizzBuzz = GetStringFromFizzBuzzLogic(number);
}

在C ++中重新声明变量是否需要花费任何费用？

Answer 1

任何现代编译器都会注意到这一点并进行优化工作。如有疑问，请始终考虑可读性。尽可能在最内部范围内声明变量。

Answer 2

第一个代码块应该被认为更快，因为您没有任何一次调用std::string默认构造函数的开销。

实际上，您没有在第二个代码块中重新声明变量。这些只是简单的分配操作。

重新声明实际上意味着你有类似的东西

int number;
string fizzBuzz;
for (int i = 0; i < 5000; i++){
    int number = rand() % 10000 + 1;
 // ^^^
    string fizzBuzz = GetStringFromFizzBuzzLogic(number);
 // ^^^^^^
}

在这种情况下，开销将由编译器优化，因为外部范围变量根本不被使用。

Answer 3

我对这个特定的代码进行了基准测试，即使没有进行优化，两种变体的运行时间几乎相同。一旦打开最低级别的优化，结果就非常接近相同（时间测量中的+/-一点噪声）。

编辑：下面对生成的汇编程序代码的分析表明，很难猜出哪种形式更快，因为大多数人可能给出的答案是func2，但事实证明这个函数稍慢一点，至少在用clang ++和-O2编译时。并且很好的证据表明“代码，基准，更改代码，基准”是处理性能的正确方法，而不是基于读取代码的猜测。记住有人告诉我的事情，优化有点像分层洋葱 - 一旦你优化了一个部分，你最终会看到一些非常相似的东西......;）

但是，我的初步分析显示func1明显变慢了 - 原因是编译器出于某些商业原因，没有优化rand() % 10000 + 1中的func1，但是转换优化时func2。这意味着func1。但是，一旦启用优化，两个函数都会获得“快速”模数。

使用linux性能工具perf显示使用clang ++和-O2我们得到以下func1

  15.76%  a.out    libc-2.20.so         free
  12.31%  a.out    libstdc++.so.6.0.20  std::string::_S_construct<char cons
  12.29%  a.out    libc-2.20.so         _int_malloc
  10.05%  a.out    a.out                func1
   7.26%  a.out    libc-2.20.so         __random
   6.36%  a.out    libc-2.20.so         malloc
   5.46%  a.out    libc-2.20.so         __random_r
   5.01%  a.out    libstdc++.so.6.0.20  std::basic_string<char, std::char_t
   4.83%  a.out    libstdc++.so.6.0.20  std::string::_Rep::_S_create
   4.01%  a.out    libc-2.20.so         strlen

和func2：

  17.88%  a.out    libc-2.20.so         free
  10.73%  a.out    libc-2.20.so         _int_malloc                    
   9.77%  a.out    libc-2.20.so         malloc
   9.03%  a.out    a.out                func2                        
   7.63%  a.out    libstdc++.so.6.0.20  std::string::_S_construct<char con
   6.96%  a.out    libstdc++.so.6.0.20  std::string::_Rep::_S_create
   4.48%  a.out    libc-2.20.so         __random  
   4.39%  a.out    libc-2.20.so         __random_r
   4.10%  a.out    libc-2.20.so         strlen

存在一些细微差别，但我会将其称为更多与基准测试的相对较短的运行时间有关，而不是编译器生成的实际代码的差异。

这是使用以下代码：

#include <iostream>
#include <string>
#include <cstdlib>

#define N 500000

extern std::string GetStringFromFizzBuzzLogic(int number);

void func1()
{
    for (int i = 0; i < N; i++){
        int number = rand() % 10000 + 1;
        std::string fizzBuzz = GetStringFromFizzBuzzLogic(number);
    }
}

void func2()
{
    int number;
    std::string fizzBuzz;
    for (int i = 0; i < N; i++){
        number = rand() % 10000 + 1;
        fizzBuzz = GetStringFromFizzBuzzLogic(number);
    }
}

static __inline__ unsigned long long rdtsc(void)
{
    unsigned hi, lo;
    __asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi));
    return ( (unsigned long long)lo)|( ((unsigned long long)hi)<<32 );
}

int main(int argc, char **argv)
{

    void (*f)();

    if (argc == 1)
    f = func1;
    else
    f = func2;

    for(int i = 0; i < 5; i++)
    {
        unsigned long long t1 = rdtsc();

        f();
        t1 = rdtsc() - t1;

        std::cout << "time=" << t1 << std::endl;
    }
}

并在另一个文件中：

#include <string>

std::string GetStringFromFizzBuzzLogic(int number)
{
    return "SomeString";
}

使用func1运行：

./a.out
time=876016390
time=824149942
time=826812600
time=825266315
time=826151399

使用func2运行：

./a.out
time=905721532
time=895393507
time=886537634
time=879836476
time=883887384

这是另外一个0添加到N - 所以运行时间长10倍 - 它看起来相当一致有点慢，但它只有几个百分点，可能在噪音中，真的 - 及时，整个基准测试需要1.30-1.39秒。

编辑：查看实际循环的汇编代码[这只是循环的一部分，但其余部分在代码的行为方面是相同的]

FUNC1：

.LBB0_1:                                # %for.body
    callq   rand
    movslq  %eax, %rcx
    imulq   $1759218605, %rcx, %rcx # imm = 0x68DB8BAD
    movq    %rcx, %rdx
    shrq    $63, %rdx
    sarq    $44, %rcx
    addl    %edx, %ecx
    imull   $10000, %ecx, %ecx      # imm = 0x2710
    negl    %ecx
    leal    1(%rax,%rcx), %esi
    movq    %r15, %rdi
    callq   _Z26GetStringFromFizzBuzzLogici
    movq    (%rsp), %rax
    leaq    -24(%rax), %rdi
    cmpq    %rbx, %rdi
    jne .LBB0_2
.LBB0_7:                                # %_ZNSsD2Ev.exit
    decl    %ebp
    jne .LBB0_1

FUNC2：

.LBB1_1:
    callq   rand
    movslq  %eax, %rcx
    imulq   $1759218605, %rcx, %rcx # imm = 0x68DB8BAD
    movq    %rcx, %rdx
    shrq    $63, %rdx
    sarq    $44, %rcx
    addl    %edx, %ecx
    imull   $10000, %ecx, %ecx      # imm = 0x2710
    negl    %ecx
    leal    1(%rax,%rcx), %esi
    movq    %rbx, %rdi
    callq   _Z26GetStringFromFizzBuzzLogici
    movq    %r14, %rdi
    movq    %rbx, %rsi
    callq   _ZNSs4swapERSs
    movq    (%rsp), %rax
    leaq    -24(%rax), %rdi
    cmpq    %r12, %rdi
    jne .LBB1_4
.LBB1_9:                                # %_ZNSsD2Ev.exit19
    incl    %ebp
    cmpl    $5000000, %ebp          # imm = 0x4C4B40

因此，可以看出，func2版本包含一个额外的函数调用：

    callq   _ZNSs4swapERSs

转换为std::basic_string<char, std::char_traits<char>, std::allocator<char> >::swap(std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)或std::string::swap(std::string&) - 这可能是调用std::string::operator=(std::string &s)的结果。这可以解释为什么func2略慢于func1。

我确信有可能找到构造/销毁对象在循环中占用大量时间的情况，但一般情况下，它几乎没有差别或者没有差别，并且具有更清晰的代码实际上将有助于读者。它通常也会帮助编译器进行“生命周期分析”，因为它可以“走”以找出以后是否使用该变量的代码较少（在这种情况下，代码很短，但显然情况并非如此）在现实生活中的例子）

Answer 4

在C ++中没有重新声明的东西。在您的第二个代码段中，number和fizzBuzz仅被声明并初始化一次。稍后关注的=是分配。

与所有优化问题一样，您只能猜测或最好衡量。当然，这完全取决于您的编译器以及您调用它的设置。当然，速度优化和空间优化之间可以进行权衡。

我知道没有严肃的C ++程序员不喜欢第一种形式，因为它更容易阅读，而且更简洁。

只有 ，如果 ，程序会被认为太慢，而如果则会测量哪些部分代码导致速度减慢，如果那些测量指向此循环，只有这样才会考虑更改它。

然而，正如其他人所说，这是一个不切实际的情况。现代编译器极不可能在优化方面以不同的方式处理这两个片段，并且您将遇到任何可测量的速度差异。

（编辑：抱歉打字错误，混淆了“第一”和“第二”）

Answer 5

所有声明（值）变量都是通过该函数/方法中所有局部变量的组合大小来增加堆栈。

调用构造函数/析构函数可能需要花费超过对象类型（字符串）的最佳时间的成本。

在这种情况下没有区别。如果使用合适的编译器，优化器无论如何都会为您提供最佳解决方案。

您可能希望代码以最佳方式阅读，以便您的同事不会认为您编写了错误的代码！

在C ++中重新声明变量是否需要花费任何成本？

5 个答案: