Será que a condição de término de um 'loop' de actualização no VC ++ 6?

Question

for (int i = 0 ; i < stlVector.size() ; i++)
{ 
    if (i == 10)
    { 
        stlVector.erase(stlVector.begin() + 5 )
    }
}

Será que a parte condição de término "stlVector.size ()" tomar "stlVector.erase (...)" em consideração? Em outras palavras faz stlVector.size refresh () para cada iteração do loop? Eu não posso testá-lo agora, então eu postei uma pergunta aqui.

Thx com antecedência!

Com os melhores cumprimentos,

zhengtonic

Answer 1

Só para ficar claro, não pense nisso em termos do ciclo refrescante nada. Toda vez que a condição é verificada (no início de cada iteração do loop), o método size () é chamado na variável stlVector, e o tamanho atual do vector é retornado.

O método de apagamento () reduz o tamanho do vector, de modo que o tamanho de tempo seguinte () é chamado, o valor devolvido será menor.

Answer 2

Sim, é verdade!

stlVector.size () // is called for evey iteration

Assim, para cada loop que você vai ter o teste de "i

Answer 3

Sim, é realizado o teste, com efeitos secundários, para cada ciclo.

A for loop é apenas uma boa convenção - um loop é facilmente decomposto como um tempo loop:

for (int i = 0 ; i < stlVector.size() ; i++)
{ 
    if (i == 10)
    { 
        stlVector.erase(stlVector.begin() + 5 )
    }
}

Torna-se:

int i = 0 ;

while(i < stlVector.size())
{ 
    if (i == 10)
    { 
        stlVector.erase(stlVector.begin() + 5 )
    }
    i++;
}

-Adam

Answer 4

Sim, é verdade, mas não faça isso! Se você quiser remover elementos de um vetor, fazê-lo dentro de outro loop. Você está excluindo elementos após o índice i neste caso: não garante nada que o stlVector [i + 5] elemento existe. Se você remover o i-ésimo elemento do vetor, sua contagem é quebrado porque você pode saltar elementos sem verificá-los.

A maneira mais segura de fazer isso é armazenar referências para os elementos na stlVector que deseja excluir em outro vector, e, em seguida, iterate sobre este vector fazendo stlVector.erase auxiliar (auxVector [i]).

Answer 5

Espero que o código fornecido é apenas "código de fantasia" (como um comentarista colocá-lo), para dar um exemplo concreto do tipo de coisa que você está tentando fazer.

No entanto, apenas no caso de ele não é: o loop que você deu ignorará o elemento 12 (ou seja, o elemento originalmente em stlVector[11]), porque ao examinar stlVector[10] você excluir um elemento anteriormente, fazendo com que todos os elementos posteriores ao shunt frente uma posição, mas você i ainda incremento no final do loop. Portanto, a próxima iteração vai olhar para stlVector[11] que na verdade é o elemento que estava originalmente no stlVector[12]. Para remediar esta situação, é preciso --i após a chamada para erase().

Answer 6

Sempre reavaliar certeza!

Answer 7

Além disso, para esclarecer um pouco, já que você perguntou se ele é feito desta maneira "no VC ++ 6".

O "continuar condição" é re-avaliar em cada ciclo na versão CADA de C, C ++, C # e Java.

Se algum compilador não gera código que faz isso, ele está quebrado, e deve ser evitado.

Answer 8

Como já foi dito, sim, a condição é re-avaliado cada vez através do loop. É por isso que uma otimização de desempenho comum é:

int saveSize = someExpensiveComputation();

for (int i = 0 ; i < saveSize ; i++)
{ 
    foo(i);
}

onde o condicional circuito é nada caro para calcular, em vez de

for (int i = 0 ; i < someExpensiveComputation(); i++)
{ 
    foo(i);
}

Onde o cálculo caro é desnecessariamente feito cada iteração através do laço.

Answer 9

Sim, reduz o tamanho. Mais informações estão aqui