C ++ 'da artırma - x ++ veya ++ x ne zaman kullanılır?

Şu anda C ++ öğreniyorum ve artışı bir süre önce öğrendim. Arttırmayı önce yapmak için "++ x" ve sonra yapmak için "x ++" kullanabileceğinizi biliyorum.

Yine de ikisini de ne zaman kullanacağımı gerçekten bilmiyorum ... "++ x" i hiç kullanmadım ve şimdiye kadar her şey yolunda gitti - peki, ne zaman kullanmalıyım?

Örnek: Bir for döngüsünde, "++ x" kullanmak ne zaman tercih edilir?

Ayrıca, birisi farklı artışların (veya azalmaların) nasıl çalıştığını tam olarak açıklayabilir mi? Gerçekten minnettar olurum.

Bu bir tercih meselesi değil, mantık meselesi.

x++geçerli ifadeyi işledikten sonra değişken x'in değerini artırır .

++xgeçerli ifadeyi işlemeden önce x değişkeninin değerini artırır .

O yüzden sadece yazdığınız mantığa karar verin.

x += ++ii'yi artıracak ve x'e i + 1 ekleyecektir. x += i++i'yi x'e ekler, sonra i'yi artırır.

Scott Meyers , mantığın sonekin uygun olduğunu belirlediği durumlar dışında öneki tercih etmenizi söyler.

"Daha Etkili C ++" madde # 6 - bu benim için yeterli yetki.

Kitabın sahibi olmayanlar için, işte ilgili alıntılar. Sayfa 32'den itibaren:

Bir C programcısı olarak geçirdiğiniz günlerden, artırma operatörünün önek biçiminin bazen "artırma ve getirme" olarak adlandırıldığını, sonek biçiminin ise genellikle "getir ve artır" olarak bilindiğini hatırlayabilirsiniz. İki cümlenin hatırlanması önemlidir, çünkü hepsi resmi şartnameler olarak işlev görür ...

Ve 34. sayfada:

Verimlilik konusunda endişelenen biriyseniz, postfix artış işlevini ilk gördüğünüzde muhtemelen ter döktünüz. Bu işlevin dönüş değeri için geçici bir nesne yaratması gerekir ve yukarıdaki uygulama ayrıca oluşturulması ve yok edilmesi gereken açık bir geçici nesne yaratır. Önek artırma işlevinin böyle bir geçiciliği yoktur ...

Gönderen cppreference yineleyicinızı artırılmıyor zaman:

Eski değeri kullanmayacaksanız, artırma öncesi operatörünü (++ iter) artım sonrası operatörüne (iter ++) tercih etmelisiniz. Arttırma sonrası genellikle şu şekilde uygulanır:

   Iter operator++(int)   {
     Iter tmp(*this); // store the old value in a temporary object
     ++*this;         // call pre-increment
     return tmp;      // return the old value   }

Açıkçası, ön artıştan daha az verimli.

Ön artış, geçici nesneyi oluşturmaz. Nesnenizin oluşturulması pahalıysa, bu önemli bir fark yaratabilir.

Anlambilimin (ön / sonun) önemli olmadığı pre / post artışını kullanırsanız, genleşmiş kodun aynı olduğunu fark etmek istiyorum.

misal:

pre.cpp:

#include <iostream>

int main()
{
  int i = 13;
  i++;
  for (; i < 42; i++)
    {
      std::cout << i << std::endl;
    }
}

post.cpp:

#include <iostream>

int main()
{

  int i = 13;
  ++i;
  for (; i < 42; ++i)
    {
      std::cout << i << std::endl;
    }
}

_

$> g++ -S pre.cpp
$> g++ -S post.cpp
$> diff pre.s post.s   
1c1
<   .file   "pre.cpp"
---
>   .file   "post.cpp"

Akılda tutulması gereken en önemli şey, imo, x ++ 'nın, artış gerçekleşmeden önce değeri döndürmesi gerektiğidir - bu nedenle, nesnenin geçici bir kopyasını (ön artış) yapması gerekir. Bu, yerinde artırılan ve döndürülen ++ x'ten daha az etkilidir.

Yine de bahsetmeye değer başka bir şey, çoğu derleyicinin mümkün olduğunda bu tür gereksiz şeyleri optimize edebilmesidir, örneğin burada her iki seçenek de aynı koda yol açacaktır:

for (int i(0);i<10;++i)
for (int i(0);i<10;i++)

@ BeowulfOF ile aynı fikirdeyim, yine de açıklık için ifadeleri her zaman mantığın kesinlikle net olacak şekilde bölmeyi savunurdum, yani:

i++;
x += i;

veya

x += i;
i++;

Yani cevabım, eğer açık bir kod yazarsanız, o zaman bu nadiren önemli olacaktır (ve eğer önemliyse, o zaman kodunuz muhtemelen yeterince açık değildir).

Sadece ++ x'in x ++ 'dan daha hızlı olmasının beklendiğini tekrar vurgulamak istedim (özellikle x bazı rasgele türden bir nesneyse), bu nedenle mantıksal nedenlerle gerekmedikçe, ++ x kullanılmalıdır.

Farkı doğru söyledin. Bu, x'in her döngüden önce veya sonra artmasını isteyip istemediğinize bağlıdır. Program mantığınıza, neyin uygun olduğuna bağlıdır.

STL-Yineleyiciler (bu işleçleri de uygular) ile uğraşırken önemli bir fark, o ++ yineleyicinin işaret ettiği nesnenin bir kopyasını oluşturması, ardından artırması ve ardından kopyayı döndürmesidir. ++ Öte yandan, önce artışı yapar ve ardından yineleyicinin işaret ettiği nesneye bir başvuru döndürür. Bu, çoğunlukla performansın her bir parçası önemli olduğunda veya kendi STL-yineleyicinizi uyguladığınızda geçerlidir.

Düzenleme: önek ve sonek gösterimlerinin karışımı düzeltildi

++ 'ın sonek formu, - işleci kullan-sonra-değiştir kuralını izler ,

Önek formu (++ x, - x), kural değişikliğinden sonra kullanılır .

Örnek 1:

Birden fazla değer, cout kullanılarak << ile basamaklandırıldığında, hesaplamalar (varsa) sağdan sola gerçekleşir ancak yazdırma işlemi soldan sağa, örneğin ( eğer başlangıçta 10 ise val ise)

 cout<< ++val<<" "<< val++<<" "<< val;

sonuçlanacak

12    10    10 

Örnek 2:

Turbo C ++'da, bir ifadede birden fazla ++ veya (herhangi bir biçimde) bulunursa, önce tüm önek formları hesaplanır, ardından ifade değerlendirilir ve son olarak sonek formları hesaplanır, örn.

int a=10,b;
b=a++ + ++a + ++a + a;
cout<<b<<a<<endl;

Turbo C ++ 'da çıktısı

48 13

Oysa günümüzün modern derleyicisinde çıktısı olacak (çünkü kurallara kesinlikle uyuyorlar)

45 13

• Not: Bir ifadede aynı değişken üzerinde artırma / azaltma operatörlerinin çoklu kullanımı önerilmez. Bu tür
  ifadelerin işlenmesi / sonuçları derleyiciden derleyiciye değişir.

Kodun netliği düşünüldüğünde dil sözdizimini anlamak önemlidir. Bir karakter dizesini kopyalamayı düşünün, örneğin artım sonrası:

char a[256] = "Hello world!";
char b[256];
int i = 0;
do {
  b[i] = a[i];
} while (a[i++]);

Döngünün, dizenin sonunda sıfır karakteriyle (yanlışı test eden) karşılaşarak yürütülmesini istiyoruz. Bu, ön artış değerinin test edilmesini ve ayrıca endeksin artırılmasını gerektirir. Ancak bu sırayla olmak zorunda değil - bunu ön artışla kodlamanın bir yolu şöyle olacaktır:

int i = -1;
do {
  ++i;
  b[i] = a[i];
} while (a[i]);

Bu daha net olan bir zevk meselesidir ve makinede bir dizi kayıt varsa, a [i] pahalı veya yan etkileri olan bir işlev olsa bile, her ikisinin de aynı yürütme süresine sahip olması gerekir. Endeksin çıkış değeri önemli bir fark olabilir.