相关疑难解决方法(0)

问题#1:在循环中声明一个变量是一个好习惯还是坏习惯？

我已经阅读了其他关于是否存在性能问题的线程(大多数说没有),并且您应该始终将变量声明为接近它们将被使用的位置.我想知道的是,这是否应该避免,或者它是否真的是首选.

例:

for(int counter = 0; counter <= 10; counter++)
{
   string someString = "testing";

   cout << someString;
}

问题2:大多数编译器是否已经声明变量已经被声明并且只是跳过了那个部分,或者它实际上每次都在内存中为它创建了一个位置？

为什么以下工作正常？

String str;
while (condition) {
    str = calculateStr();
    .....
}

但据说这个是危险的/不正确的:

while (condition) {
    String str = calculateStr();
    .....
}

是否有必要在循环外声明变量？

我只是想知道如果你做了这样的事情会有任何速度或效率的损失:

int i = 0;
while(i < 100)
{
    int var = 4;
    i++;
}

宣告int var一百次.在我看来会有,但我不确定.这样做会更实际/更快:

int i = 0;
int var;
while(i < 100)
{
    var = 4;
    i++;
}

或者它们是相同的,速度和效率方面的？

以下代码段是否存在任何性能损失？

for (int i=0; i<someValue; i++)
{
    Object o = someList.get(i);
    o.doSomething;
}

或者这段代码实际上更有意义吗？

Object o;
for (int i=0; i<someValue; i++)
{
    o = someList.get(i);
    o.doSomething;
}

如果在字节代码中这两个是完全等效的,那么显然第一种方法在样式方面看起来更好,但我想确保这种情况.

我发现这个问题为 C++ 提供了答案：
How do you get assembler output from C/C++ source in gcc?

我习惯这样做:

do
    local a
    for i=1,1000000 do
        a = <some expression>
        <...> --do something with a
    end
end

代替

for i=1,1000000 do
    local a = <some expression>
    <...> --do something with a
end

我的理由是,创建局部变量1000000次的效率低于仅创建一次并在每次迭代时重用它.

我的问题是:这是真的还是我缺少另一个技术细节？我在问,因为我没有看到有人这样做,但不确定原因是因为优势太小还是因为事实上更糟.更好的意思是使用更少的内存和更快的运行.

如果我执行以下操作之一(我假设这个问题与此问题相同)

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++编译器吗？

假设我们有一个迭代多次的循环:

for (int i=0; i < 1000000; ++i) {
  int s = 100;
  s += i;
  cout << s;
}

我们只s在循环体内部使用,所以理想情况下我们想在那里声明它所以它不会污染封闭的命名空间.

我想知道这是否有任何不利之处.例如,它是否会产生性能成本,因为程序会s在每次迭代时重新声明？

我的问题是,如果我在循环外声明一个变量并在循环内每次重新初始化或在循环内声明和初始化,这是否重要？那么基本上这两种语法(性能,标准等)之间有什么区别吗？

方法1

int a,count=0;
while(count<10)
   a=0;

方法2

int count=0;
while(count<10)
   int a=0;

请假设这只是一个更大程序的一部分,并且body循环内部要求变量每次a都有一个值0.那么,这两种方法的执行时间会有什么不同吗？

当我检查这个问题时,我不相信它,所以我测试了,似乎是真的.内部循环中的声明似乎比声明外部循环更快.有人可以解释为什么会这样吗？

这是我的测试代码:

public class CycleTest {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        long iterations = 1000000;
        warmUp(iterations);
        System.out.println("Cycle1");
        double individualTime = getAverageTimePerIterationc1(iterations);
        iterations = 1000;
        double totalTime = getTotalTimec1(iterations);

        System.out.println("ns/iteration: " + individualTime);
        System.out.println("Total time for " + iterations + " runs: " + totalTime);

        System.out.println("Cycle2");
        iterations = 1000000;
        double individualTime1 = getAverageTimePerIterationc2(iterations);
        iterations = 1000;
        double totalTime1 = getTotalTimec2(iterations);

        System.out.println("ns/iteration: " + individualTime1);
        System.out.println("Total time for " + …