Bir döngü içinde bir değişkeni bildirmenin herhangi bir yükü var mı? (C ++)

Merak ediyorum da böyle bir şey yaparsanız hız veya verimlilik kaybı olur mu?

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

ki int varyüz kez ilan eder . Bana öyle geliyormuş gibi görünüyor, ama emin değilim. bunun yerine bunu yapmak daha pratik / hızlı olur mu:

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

yoksa aynı, hızlı ve verimlilik açısından mı?

Yerel değişkenler için yığın alanı genellikle fonksiyon kapsamında tahsis edilir. Böylece döngü içinde yığın işaretçisi ayarı gerçekleşmez, sadece 4'e atanır var. Bu nedenle, bu iki parçacık aynı ek yüke sahiptir.

İlkel tipler ve POD türleri için hiçbir fark yaratmaz. Derleyici, değişken için yığın alanını işlevin başlangıcında ayırır ve işlev her iki durumda da geri döndüğünde onu serbest bırakır.

Önemsiz olmayan kurucuları olan POD dışı sınıf türleri için bir fark yaratacaktır - bu durumda, değişkeni döngünün dışına koymak, kurucuyu ve yıkıcıyı yalnızca bir kez ve atama işlecini her yinelemeyi çağırır. döngü, döngünün her yinelemesi için kurucuyu ve yıkıcıyı çağırır. Sınıfın yapıcısı, yıkıcısı ve atama operatörünün ne yaptığına bağlı olarak, bu istenebilir veya istenmeyebilir.

İkisi de aynıdır ve derleyicinin ne yaptığına bakarak nasıl öğrenebileceğiniz aşağıda açıklanmıştır (optimizasyon yüksek olarak ayarlanmasa bile):

Derleyicinin (gcc 4.0) basit örneklerinize ne yaptığına bakın:

1.c:

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

gcc -S 1.c

1. s:

_main:
    pushl   %ebp
    movl    %esp, %ebp
    subl    $24, %esp
    movl    $0, -16(%ebp)
    jmp L2
L3:
    movl    $4, -12(%ebp)
L2:
    cmpl    $99, -16(%ebp)
    jle L3
    leave
    ret

2.c

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

gcc -S 2.c

2. s:

_main:
        pushl   %ebp
        movl    %esp, %ebp
        subl    $24, %esp
        movl    $0, -16(%ebp)
        jmp     L2
L3:
        movl    $4, -12(%ebp)
L2:
        cmpl    $99, -16(%ebp)
        jle     L3
        leave
        ret

Bunlardan iki şey görebilirsiniz: Birincisi, kod her ikisinde de aynıdır.

İkinci olarak, var için depolama alanı döngünün dışında ayrılır:

         subl    $24, %esp

Ve son olarak döngüdeki tek şey atama ve koşul kontrolüdür:

L3:
        movl    $4, -12(%ebp)
L2:
        cmpl    $99, -16(%ebp)
        jle     L3

Bu, döngüyü tamamen kaldırmadan olabildiğince verimli.

Derleyici kodu daha iyi optimize edebileceğinden (değişken kapsamını azalttığından), sabit olmadığı sürece, bu günlerde onu döngü içinde bildirmek daha iyidir.

DÜZENLEME: Bu cevap çoğunlukla artık geçersiz. Post-klasik derleyicilerin yükselişiyle birlikte, derleyicinin çözemediği durumlar ender hale geliyor. Hala inşa edebilirim ama çoğu insan inşaatı kötü kod olarak sınıflandırır.

Çoğu modern derleyici bunu sizin için optimize eder. Daha okunaklı bulduğum için ilk örneğinizi kullanacağım söyleniyor.

Yerleşik bir tür için 2 stil arasında büyük olasılıkla hiçbir fark olmayacaktır (muhtemelen üretilen koda kadar).

Bununla birlikte, değişken önemsiz olmayan bir kurucu / yıkıcıya sahip bir sınıfsa, çalışma zamanı maliyetinde büyük bir fark olabilir. Genelde değişkeni döngünün içine dahil ederdim (kapsamı olabildiğince küçük tutmak için), ancak bunun mükemmel bir etkisi olduğu ortaya çıkarsa, sınıf değişkenini döngünün kapsamının dışına taşımaya bakarım. Ancak, ode yolunun anlambilimi değişebileceğinden, bunu yapmak bazı ek analizler gerektirir, bu nedenle bu yalnızca anlambilim izin verirse yapılabilir.

Bir RAII sınıfı bu davranışa ihtiyaç duyabilir. Örneğin, dosya erişimini doğru bir şekilde yönetmek için, dosya erişim ömrünü yöneten bir sınıfın her döngü yinelemesinde oluşturulması ve yok edilmesi gerekebilir.

LockMgrOluşturulduğunda kritik bir bölüm alan ve yok edildiğinde onu serbest bırakan bir sınıfınız olduğunu varsayalım :

while (i< 100) {
    LockMgr lock( myCriticalSection); // acquires a critical section at start of
                                      //    each loop iteration

    // do stuff...

}   // critical section is released at end of each loop iteration

şundan oldukça farklıdır:

LockMgr lock( myCriticalSection);
while (i< 100) {

    // do stuff...

}

Her iki döngü de aynı verime sahiptir. İkisi de sonsuz bir zaman alacak :) Döngülerin içinde i'yi artırmak iyi bir fikir olabilir.

Bir keresinde bazı performans testleri yaptım ve şaşırtıcı bir şekilde, vaka 1'in aslında daha hızlı olduğunu gördüm! Sanırım bunun nedeni, döngünün içindeki değişkeni bildirmenin kapsamını daraltması, dolayısıyla daha önce serbest kalması olabilir. Ancak, bu çok eski bir derleyicide uzun zaman önceydi. Modern derleyicilerin farklılıkları ortadan kaldırmak için daha iyi bir iş çıkardığından eminim, ancak değişken kapsamınızı olabildiğince kısa tutmak yine de zarar vermez.

#include <stdio.h>
int main()
{
    for(int i = 0; i < 10; i++)
    {
        int test;
        if(i == 0)
            test = 100;
        printf("%d\n", test);
    }
}

Yukarıdaki kod her zaman 100 10 kez yazdırır, bu da döngü içindeki yerel değişkenin her işlev çağrısı için yalnızca bir kez tahsis edildiği anlamına gelir.

Emin olmanın tek yolu onları zamanlamaktır. Ancak, eğer varsa, fark mikroskobik olacaktır, bu nedenle çok büyük bir zamanlama döngüsüne ihtiyacınız olacak.

Daha da önemlisi, birincisi daha iyi stildir çünkü değişken var değişkenini başlatırken diğeri onu başlatılmamış olarak bırakır. Bu ve değişkenlerin mümkün olduğunca kullanım noktalarına yakın tanımlanması gerektiği yönündeki kılavuz, normalde ilk formun tercih edilmesi gerektiği anlamına gelir.

Yalnızca iki değişkenle, derleyici muhtemelen her ikisi için de bir kayıt atayacaktır. Bu kayıtlar zaten orada, bu yüzden bu zaman almıyor. Her iki durumda da 2 yazmaç yazma ve bir yazmaç okuma talimatı vardır.

Bence yanıtların çoğunda dikkate alınması gereken önemli bir nokta eksik: "Açık mı?" Ve tüm tartışmalara göre gerçek şu ki; hayır öyle değil. Çoğu döngü kodunda, verimliliğin hemen hemen sorun olmadığını (bir mars iniş aracını hesaplamadıkça) öneririm, bu yüzden gerçekten tek soru daha mantıklı, okunabilir ve sürdürülebilir görünen şeydir - bu durumda beyan etmenizi tavsiye ederim döngünün önündeki ve dışındaki değişken - bu, onu daha net hale getirir. O zaman sizin gibi insanlar, geçerli olup olmadığını görmek için çevrimiçi olarak kontrol etmekle zaman kaybetmeye bile zahmet etmem.

bu doğru değil, ama ihmal edilebilir ek yükü var.

Muhtemelen yığın üzerinde aynı yerde son bulacak olsalar bile, yine de onu atar. Bu int için yığın üzerinde bellek konumu atayacak ve sonra} sonunda serbest bırakacaktır. Yığın serbest anlamda değil, sp'yi (yığın işaretçisi) 1 oranında hareket ettirecektir. Ve sizin durumunuzda, sadece bir yerel değişkene sahip olduğunu düşünürsek, sadece fp (çerçeve işaretçisi) ve sp'yi eşitleyecektir.

Kısa cevap: NEREDEYSE AYNI ŞEKİLDE ÇALIŞIRSA DİKKAT ETMEYİN.

Ancak yığının nasıl düzenlendiği hakkında daha fazla okumayı deneyin. Lisans okulumun bu konuda oldukça iyi dersleri vardı Daha fazlasını okumak istiyorsanız buraya bakın http://www.cs.utk.edu/~plank/plank/classes/cs360/360/notes/Assembler1/lecture.html