在循环中声明变量是否有效？ [复制]

Question

如果我执行以下操作之一（我假设对于这个问题来说是等效的）

for(int i=0; i<A; i++)
{
  //... do stuff
  for(int j=0; j<B; j++)
  {
    //... do stuff
  }
  //... do stuff
}

for(int i=0; i<A; i++)
{
  int j;
  //... do stuff
}

变量j 是否在每个循环中都在堆栈上重新创建（SP 是否在每个循环中不断更新），或者编译器是否足够聪明，可以知道一个函数一次可能有多少个局部变量，以及然后在函数入口处为堆栈上的所有这些腾出空间？

我知道这在理论上是依赖于编译器的，但我假设像这样的简单事情在所有主要编译器中都很常见。如果没有，是否有人特别了解 GCC 和 VC++ 编译器？

Answer 1

效率很高。 gcc 将优化它，就像大多数现代编译器一样。还要记住 Donald Knuth 说过的话：

我们应该忘记小的效率，比如大约 97% 的时间： 过早优化是万恶之源。

您可以通过比较汇编代码来检查它是否有效。例如，使用diff 进行比较。要生成程序集，请使用 -S 标志 gcc -S。相当于gcc -S -O0，因为默认优化级别为0。所以，即使在最低级别的优化中，gcc 也会为您处理这个变量。

第一个版本（为了更好的可读性更喜欢这种方式）：

#include <stdio.h>

int main()
{
    for (int i = 0; i < 10; i++)
    {
        for (int j = 0; j < 10; j++)
        {
            printf("%d ", i + j);
        }
    }
    return 0;
}

第二版：

#include <stdio.h>

int main()
{
    for (int i = 0; i < 10; i++)
    {
        int j;
        for (j = 0; j < 10; j++)
        {
            printf("%d ", i + j);
        }
    }
    return 0;
}

相同的组装结果：

    .file   "main.cpp"
    .section    .rodata
.LC0:
    .string "%d "
    .text
.globl main
    .type   main, @function
main:
.LFB0:
    .cfi_startproc
    .cfi_personality 0x3,__gxx_personality_v0
    pushq   %rbp
    .cfi_def_cfa_offset 16
    movq    %rsp, %rbp
    .cfi_offset 6, -16
    .cfi_def_cfa_register 6
    subq    $16, %rsp
    movl    $0, -4(%rbp)
    jmp .L2
.L5:
    movl    $0, -8(%rbp)
    jmp .L3
.L4:
    movl    -8(%rbp), %eax
    movl    -4(%rbp), %edx
    leal    (%rdx,%rax), %eax
    movl    %eax, %esi
    movl    $.LC0, %edi
    movl    $0, %eax
    call    printf
    addl    $1, -8(%rbp)
.L3:
    cmpl    $9, -8(%rbp)
    setle   %al
    testb   %al, %al
    jne .L4
    addl    $1, -4(%rbp)
.L2:
    cmpl    $9, -4(%rbp)
    setle   %al
    testb   %al, %al
    jne .L5
    movl    $0, %eax
    leave
    ret
    .cfi_endproc
.LFE0:
    .size   main, .-main
    .ident  "GCC: (Ubuntu 4.4.3-4ubuntu5.1) 4.4.3"
    .section    .note.GNU-stack,"",@progbits

int i 是 -4(%rbp)，int j 是 -8(%rbp)。如您所见，int j 没有重新分配或其他什么。

Answer 2

我相信变量只会被创建一次，虽然我不在乎，我也不相信你应该这样做。

这可能是您进行预优化（或不必要的优化）的一个示例；在循环中声明变量所造成的潜在低效率非常小，通过在不同位置声明变量来“优化”代码对程序的整体运行时和内存使用的影响可以忽略不计。

考虑花时间优化您的算法并寻找有效的数据结构，因为这可能会更好地利用您的时间。

Answer 3

今天的编译器功能太强大了，无法优化这些东西。因此，请不要打扰并根据您的方便使用。过早的优化更邪恶。

Answer 4

为什么不自己试试看呢？

class foo {
public:
    foo () { std::cout << "Construct\n"; }
    ~foo () { std::cout << "Destruct\n"; }
    };

int main () {
    for ( int i = 0; i < 10; ++i ) {
        foo f;
    }

    return 0;
}

您会看到f 的构造函数（和析构函数！）在每次循环中都会被调用。因此，您的问题的答案是“是的，每次通过循环都会重新创建变量。”

回到你的例子，你声明了一个 int，它有一个构造函数和析构函数，它们什么都不做。因此，在循环中声明 int 不会降低性能。