21 Soru: C ++ 'da “->” operatörü nedir?

tarafından oluşturulan soru Mon, Feb 13, 2017 12:00 AM

C ++ /STL'nin Gizli Özellikleri ve Karanlık Köşeleri comp.lang.c++.moderated'da, aşağıdaki snippet'in hem Visual Studio 2008 hem de G ++ 4.4'te derlenmesi ve çalışılmasından tamamen şaşırdım.

İşte kod:

 
#include <stdio.h>
int main()
{
    int x = 10;
    while (x --> 0) // x goes to 0
    {
        printf("%d ", x);
    }
}

GCC'de de çalıştığı için bunun C olduğunu varsayardım. Bu, standartta nerede tanımlanır ve nereden gelmiştir?

    
8347
  1. Veya sadece uygun boşluklar bile ... Daha önce değişken ile ++ veya -- arasında bir boşluk görmedim sanırım ...
    2009-10-29 07: 09: 47Z
  2. Bu "gider" operatörü geri alınabilir (0 < - x). Ayrıca bir "koşu" operatörü var (0
    2009-10-29 07: 27: 21Z
  3. Yeterince eğlenceli, yorum çok yanlış olmasına rağmen, kodun doğru şekilde ne yaptığını açıklar. :)
    2009-11-11 13: 51: 39Z
  4. Yeni sözdizimi olanaklarını düşünün: #define upto ++<, #define downto -->. Kendini kötü hissediyorsan #define for while( ve #define do ) { (ve #define done ;}) yazıp for x downto 0 do printf("%d\n", x) done Oh yazabilirsin, insanlık ...
    2010-03-04 07: 07: 25Z
  5. Tamamen yeni, etkileyici bir kodlama yöntemi, birkaç derleyici uyarısından feda etmeye değer bir olasılık sunar: bool CheckNegative (int x) {return x &0? doğru yanlış ); }
    2012-05-28 11: 12: 58Z
  6. 21 Yanıtlar                              21                         

    --> bir operatör değil. Aslında iki ayrı operatör, -- ve >.

    Koşullu kod x'u azaltırken, x'un orijinalini (azaltılmamış) değerini döndürür ve 0 operatörünü kullanarak orijinal değeri > ile karşılaştırır.

    Daha iyi anlamak için, ifade aşağıdaki gibi yazılabilir:

     
    while( (x--) > 0 )
    
        
    8030
    2018-12-23 15: 46: 05Z
    1. Sonra tekrar, bu bağlamda bir tür aralık operatörü gibi görünüyor.
      2009-10-29 07: 14: 52Z
    2. x'in post-decemente olduğunu ve sonra 0 ile karşılaştırıldığını söylemek, x'in 0 ile karşılaştırıldıktan sonra azaldığını söylemekle aynıdır
      2009-10-29 08: 35: 27Z
    3. Aynı olduğunu sanmıyorum. Bence "sonra" kelimesi bir emir olduğunu ima eder (düşüş sonrası, x'in değeri birdir). Sanırım bir kişi "x azaltma sonrası ve sonra eski değeri ile 0 ... karşılaştırılıyor" diyebilir. Ama bu zaten nitpicking. Ne anlama geldiğini hepimiz biliyoruz.
      2010-01-30 17: 42: 40Z
    4. Java’da da derler :)
      2013-02-12 08: 07: 27Z
    5. Bunun adı, @Jay, kötü programlama stili :-) Bu, sorunun ilk olarak sorulduğu gerçeğiyle kanıtlanır. İlişkili olmayan bir şeyden ziyade operatörleri üzerinde çalıştıkları şeye operatörleri metinsel olarak bağlamak çok daha mantıklıdır, bu yüzden while (x-- > 0) daha uygun olacaktır. Aynı zamanda, neler olup bittiğini (en azından sabit bir yazı tipinde bir düzenleyicide) daha belirgin hale getirir.bu cevaptaki parantez gerekli değildir.
      2016-02-15 01: 28: 00Z

    Veya tamamen farklı bir şey için ... x, 0'a kaydırılır

     
    while (x --\
                \
                 \
                  \
                   > 0)
         printf("%d ", x);
    

    Çok matematiksel değil, ama ... her resim bin kelimeyi boyar ...

        
    2771
    2018-10-09 06: 55: 47Z
    1. Üzgünüm, bunu anlamadım. Bu nasıl çalışır?
      2012-03-07 10: 48: 26Z
    2. @ mafutrct - C de hatırladığım kadarıyla bir satır sonu yokmuş gibi sonraki satırı ekler. \'Burada temel olarak hiçbir şey yapmazsınız.
      2012-03-10 04: 37: 36Z
    3. IIRC, K &RC, decrement operatöründeki '''ler arasında boşluk bıraktı, bu durumda bunun ortasında ters eğik çizgi olabilir daha serin. :)
      2013-07-13 09: 23: 17Z
    4. @ ArnavBorborah, bu bağlamda şaka olarak kullanılan, why waste words when a picture does a better job anlamına gelen eski bir ifadedir. (aslında 2 anahtar kelime while ve printf vardır)
      2016-09-10 11: 36: 46Z
    5. Ah evet, belirsiz slayt işleci. Nasıl unutabilirim?
      2017-10-27 10: 00: 48Z

    Bu çok karmaşık bir operatör, hatta ISO /IEC JTC1 (Ortak Teknik Komite 1) açıklamasını C ++ Standardının iki farklı bölümüne yerleştirdi.

    Şaka bir yana, bunlar iki farklı operatördür: sırasıyla C ++ 03 Standardının §5.2.6 /2 ve §5.9'larında açıklanan -- ve >.

        
    2301
    2017-03-02 06: 49: 17Z

    Şuna eşittir

     
    while (x-- > 0)
    

    x-- (azalma sonrası) x = x-1’a eşdeğerdir, bu nedenle kod aşağıdakilere dönüşür:

     
    while(x > 0) {
        x = x-1;
        // logic
    }
    
        
    1219
    2018-11-06 17: 27: 12Z
    1. Bu doğru değil. İkinci durumda, döngü gövdesi içindeki x'in değeri farklıdır. Örneğinizdeki atama ifadesi, eşdeğer olması için mantığın yukarıda olması gerekir. Sonek - 1'i çıkarır, ancak karşılaştırma öncesi değerinden çıkarılır.
      2018-10-16 16: 03: 48Z
    2. @ uliwitness Bunlar gerçekten eşdeğerdir. Önek kullanılıyorsa yanlış olur: 0 >-- x Bu durumda mantıktan önce x azalır. Postfix'de, mantık azaltmadan önce yürütülür ve bu nedenle her iki örnek de aynıdır. Onları Console'da yazmaktan ve sınamaktan çekinmeyin.
      2019-01-02 19: 36: 20Z
    3. Hala eşdeğer değiller. İlk döngüden sonra, x -1'dir (veya imzasız olması durumunda taşar), ikinciden sonra 0'dır. (X'in negatif olmayan bir şekilde başladığını varsayarsak, her iki döngü de x'i değiştirmez veya kesmez veya…)
      2019-01-15 14: 56: 57Z

    x zıt yönde daha da sıfıra gidebilir:

     
    int x = 10;
    
    while( 0 <---- x )
    {
       printf("%d ", x);
    }
    

    8 6 4 2

    Hızı bir okla kontrol edebilirsiniz!

     
    int x = 100;
    
    while( 0 <-------------------- x )
    {
       printf("%d ", x);
    }
    

    90 80 70 60 50 40 30 20 10

    ;)

        
    1049
    2017-10-11 02: 51: 48Z
    1. hangi işletim sistemi, bu tür bir çıktı üretti, hata mesajı aldığımda ubuntu 12.04 kullanıyorum
      2015-01-19 12: 13: 36Z
    2. Açık olmasına rağmen, C ++ 'a bunu okuyan herkes için açık olmalıdır: Yapmayın. Birden fazla artırma /azaltma gereksiniminiz varsa, artırılmış ödevi kullanın.
      2015-03-26 02: 41: 40Z
    3. "Lazerler" ile sıfır. while (0 > - - - - - - - - - - - ---------- x) ... aynı çıktı.
      2016-03-09 21: 54: 16Z
    4. @ phord derlemediğinden emin misiniz? - > coliru.stacked-crooked.com/a/5aa89a65e3a86c98
      2016-03-24 10: 43: 16Z
    5. @ doc c ++ ile derlenir, ancak c ile değil.
      2016-03-25 14: 58: 46Z

     
    #include <stdio.h>
    int main(void){
         int x = 10;
    
         while( x-- > 0 ){ // x goes to 0
    
           printf("%d ", x);
         }
    
         return 0;
    }
    

    Yalnızca boşluk işleri komik gösterir, -- azalış ve > karşılaştırır.

        
    528
    2018-03-08 17: 02: 25Z

    -->’un kullanımı tarihi bir öneme sahip. Azalma, (ve hala bazı durumlarda), x86 mimarisindeki artıştan daha hızlıydı. -->'un kullanılması, x'un 0'a gideceğini ve matematiksel geçmişi olanlara hitap ettiğini göstermektedir.

        
    398
    2009-11-18 12: 47: 41Z
    1. Tam olarak doğru değil. Azaltma ve Artırma aynı zaman alır, bunun yararı sıfıra karşılaştırmanın değişkene kıyasla daha hızlı olmasıdır. Bu, yalnızca x86 için değil, birçok mimar için geçerlidir. JZ komutuna sahip herhangi bir şey (sıfırsa zıplayın). Etrafınızda dolaşarak, karşılaştırmada döngüleri kurtarmak için geriye doğru yazılmış birçok "for" döngüsünü bulabilirsiniz. Bu, özellikle x86'da hızlıdır; değişkeni sıfır bayrağını uygun bir şekilde düşürme eylemi olarak düşürülür, böylece değişkeni açıkça karşılaştırmak zorunda kalmadan dallanabilirsiniz.
      2009-12-30 05: 16: 46Z
    2. Eh, sıfıra doğru düşürmek, döngü yineleme başına yalnızca 0 ile karşılaştırmak zorunda kalırken, n'ye doğru yineleme yapmak, her bir yinelemeyi n ile karşılaştırmak anlamına gelir. Birincisi daha kolay olma eğilimindedir (ve bazı mimarilerde, her veri kayıt işleminden sonra otomatik olarak test edilir).
      2010-04-12 15: 07: 58Z
    3. @ burrito Kabul etmeme rağmen, sıfır olmayan değerlere koşullu döngüler genel olarak mükemmel bir şekilde tahmin ediliyor.
      2014-01-11 09: 05: 12Z
    4. Artırma ve azaltma, muhtemelen tüm platformlarda (kesinlikle x86'da) aynı derecede hızlıdır. Fark, döngü sonu koşulunun test edilmesidir. Sayacın sıfıra ulaştığını görmek için pratik olarak ücretsizdir - bir değeri düşürdüğünüzde, işlemcide sıfır bayrağı ayarlanır ve bitiş koşulunu tespit etmek için sadece bu bayrağı kontrol etmeniz gerekir, oysa bitiş koşulundan önce bir karşılaştırma işlemi yapmanız gerekir tespit edilebilir.
      2015-02-18 11: 14: 01Z
    5. elbette, modern derleyiciler döngüleri otomatik olarak vektörleştirip tersine çevirebildiğinden, elbette, bunların hepsi bu günlerde oldukça etkileniyor.
      2015-02-20 03: 53: 56Z
     
    while( x-- > 0 )
    

    bunun nasıl ayrıştırıldığıdır.

        
    345
    2009-11-19 19: 46: 56Z

    Tamamen geek, ancak bunu kullanacağım:

     
    #define as ;while
    
    int main(int argc, char* argv[])
    {
        int n = atoi(argv[1]);
        do printf("n is %d\n", n) as ( n --> 0);
        return 0;
    }
    
        
    333
    2011-12-03 02: 33: 05Z
    1. Umarım kaynak kodunuzdan hiçbirine rastlamazdım…
      2012-08-15 01: 44: 31Z
    2. @ Mk12 Bu kaynak kod değil ... bu hiyeroglif :-)
      2012-09-07 03: 27: 35Z
    3. 2012-11-14 10: 00: 02Z
    4. Bu derleme yapmaz. C, Pascal değildir; burada do ... while'un içi bir açıklama listesidir. C'de bir blok var, bu yüzden do { ... } while olmalı.
      2016-09-11 02: 20: 23Z
    5. @ EJP bunu derledi. Sözdizimi do statement while ( expression ) ;'dur. Söylemiştim, umarım anlaşılır ki örneği şaka olarak kastettim.
      2016-10-18 17: 28: 10Z

    Okuduğum bir kitap (hangi kitabın doğru olduğunu hatırlamıyorum), şunları belirtti: Derleyiciler sol sağ kuralı kullanarak ifadeleri en büyük belirteçle ayrıştırmaya çalışıyor .

    Bu durumda, ifade:

     
    x-->0
    

    En büyük belirteçleri ayrıştırır:

     
    token 1: x
    token 2: --
    token 3: >
    token 4: 0
    conclude: x-- > 0
    

    Aynı kural bu ifadeye uygulanır:

     
    a-----b
    

    Ayrıştırdıktan sonra:

     
    token 1: a
    token 2: --
    token 3: --
    token 4: -
    token 5: b
    conclude: (a--)-- - b
    

    Umarım bu karmaşık ifadeyi anlamaya yardımcı olur ^^

        
    304
    2015-04-23 09: 02: 58Z
    1. İkinci açıklamanız doğru değil. Derleyici a-----b'u görecek ve (a--)-- - b'u derleyecektir, çünkü a-- bir değer döndürmez.
      2010-05-05 15: 26: 03Z
    2. Ayrıca, x ve -- iki ayrı belirteçtir.
      2010-07-02 19: 20: 05Z
    3. Bu, Maksimal munch olarak bilinir. >.
      2014-03-13 11: 09: 26Z
    4. @ DoctorT: lexer'dan geçer. sadece anlamsal geçiş bu hatayı kaldırabilir. bu yüzden açıklaması doğru.
      2014-09-01 03: 34: 53Z
    5. -->'un bir operatör olduğunu düşündüğünüz sürece (bu soruyu sormakla ima edilen şeydir), bu cevap hiç yardımcı olmaz - simge 2'nin --> değil, -- olduğunu düşünüyorum. -->’un bir operatör olmadığını biliyorsanız, muhtemelen sorudaki kodu anlamada sorun yaşamazsınız, bu nedenle, tamamen farklı bir sorunuz olmadığı sürece, bunun nasıl yararlı olabileceğinden emin değilim. div>
      2015-05-22 12: 33: 43Z

      Bu, tam olarak aynı

       
      while (x--)
      {
         printf("%d ", x);
      }
      

      negatif olmayan numaralar için

          
      253
      2015-04-30 22: 48: 34Z
      1. Bunun for(--x++;--x;++x--) olması gerekmez mi?
        2011-12-04 21: 32: 19Z
      2. @ DoctorT unsigned bunun içindir
        2013-03-23 ​​18: 39: 13Z
      3. @ MateenUlhaq, --x++ ifadesinin standarda göre yanlış olması, §1.9.15
        'e göre tanımsız davranışı var
        2015-06-19 02: 02: 01Z
      4. unsigned kullanıyor olsaydı, %u kullanıyor olurdu
        2019-02-21 22: 01: 27Z

      Her neyse, şimdi bir "gider" operatörümüz var. "-->", bir yön olarak hatırlanması kolaydır ve "x sıfıra giderken" anlamlıdır.

      Ayrıca, bazı platformlarda "for (x = 10; x > 0; x --)"'dan biraz daha verimlidir.

          
      230
      2013-02-28 17: 28: 13Z
      1. Özellikle x değeri negatif olduğunda her zaman doğru olamaz.
        2009-11-13 03: 22: 41Z
      2. Diğer sürüm aynı şeyi yapmıyor - for (size_t x=10; x-->0; ) ile döngünün gövdesi 9,8, .., 0 ile yürütülürken, diğer sürüm 10 ise, 9, .., 1. Aksi takdirde işaretsiz bir değişkeni olan bir döngüden sıfıra çıkmak oldukça zor.
        2010-06-21 08: 57: 44Z
      3. Bunun biraz yanıltıcı olduğunu düşünüyorum ... Artımlı bir iş yapmak için ++>'a ihtiyacımız olduğu için kelimenin tam anlamıyla "operatöre" gitmiyoruz.
        2013-06-15 02: 49: 10Z
      4. @ Josh: aslında, taşma int için tanımsız bir davranış sergiliyor, bu yüzden köpeğinizi negatif başlarsa x'u sıfıra kadar kolayca yiyebilir >
        2013-12-06 06: 57: 56Z
      5. Bu, @PeteKirkham'ın comnmet'inde verilen nedenlerden ötürü çok önemli bir deyimdir, çünkü genellikle imzasız miktarlarda 0'a kadar azalan döngüleri azaltmak zorunda kalıyorum . (Karşılaştırma için, sınamayan while (n--) yerine n yazmak gibi, sıfır için sınama testi deyimi, size hiçbir şey satın almaz ve benim için okunabilirliği büyük ölçüde engeller.) genellikle istediğiniz gibi olan başlangıç ​​indeksinden (örneğin, bir dizinin üzerindeki bir döngü için boyutunu belirtirsiniz). Ayrıca tabirsiz -->'u seviyorum, çünkü bu deyimi tanımayı kolaylaştırıyor.
        2014-08-30 20: 08: 39Z

      Bu kod ilk önce x ve 0'ı sonra da x'i azaltır. (Ayrıca, ilk yanıtta: X'i azalttıktan sonra x3 ile > işleciyle karşılaştırıyorsunuz.) Bu kodun çıktısına bakın:

       
      9 8 7 6 5 4 3 2 1 0
      

      Şimdi çıkışta 0 'ı görerek önce karşılaştırıp sonra da azalmayı yaptık.

      İlk önce azaltma ve sonra karşılaştırma yapmak istiyorsak, şu kodu kullanın:

       
      #include <stdio.h>
      int main(void)
      {
          int x = 10;
      
          while( --x> 0 ) // x goes to 0
          {
              printf("%d ", x);
          }
          return 0;
      }
      

      Bu çıktı:

       
      9 8 7 6 5 4 3 2 1
      
          
      212
      2016-01-03 17: 48: 14Z

      Bu kodu çalıştırdığımda derleyicim 9876543210 yazdıracak.

       
      #include <iostream>
      int main()
      {
          int x = 10;
      
          while( x --> 0 ) // x goes to 0
          {
              std::cout << x;
          }
      }
      

      Beklendiği gibi. while( x-- > 0 ) aslında while( x > 0) anlamına geliyor. x-- yayını sonrası x.

       
      while( x > 0 ) 
      {
          x--;
          std::cout << x;
      }
      

      aynı şeyi yazmanın farklı bir yoludur.

      Orijinalin "x, 0'a giderken" olsa da görünmesi güzel.

          
      167
      2015-04-30 22: 49: 12Z
      1. Sonuç, aynı değişkeni aynı ifadede bir kereden fazla artırırken /azalttığınızda belirsizdir. Bu durum için geçerli değildir.
        2010-05-05 15: 30: 19Z
      2. while( x-- > 0 ) actually means while( x > 0) - Orada ne söylemeye çalıştığınızdan emin değilim, ancak ifade ettiğiniz yöntem --'un ne anlama geldiğinin bir anlamı yok, ki bu kesinlikle çok yanlış.
        2015-05-22 12: 28: 30Z

      -- ile > arasında bir boşluk eksik. x gönderim sonrası azaltılır, yani x>0 ? koşulu denetlendikten sonra azalır.

          
      138
      2010-11-22 19: 02: 21Z
      1. Boşluk eksik - C (++) boşlukları yok sayar.
        2012-08-02 19: 16: 31Z
      2. @ H2CO3 Bu genel olarak doğru değildir. Belirteçleri ayırmak için beyaz boşluğun kullanılması gereken yerler vardır; #define foo()'a karşılık #define foo ()’da.
        2013-04-25 21: 16: 44Z
      3. @ Jens Nasıl yapılır: "Boşluk eksik - C (++) gereksiz beyaz boşluğu yoksayar."?
        2013-12-04 20: 35: 14Z

      --, azaltma operatörü ve >, büyüktür operatörüdür.

      İki operatör, --> gibi tek bir kullanıcı olarak uygulanır.

          
      129
      2011-10-29 21: 42: 06Z
      1. 2 ayrı operatör olarak uygulandılar . Onlar " yazılmıştır " tek bir tane "gibi görünmek için yanıltıcı şekilde yazılmıştır.
        2016-11-12 17: 56: 09Z

      İki operatörün birleşimi. İlk --, değeri azaltmak için ve >, değerin sağ işlenenden daha büyük olup olmadığını kontrol etmek içindir.

       
      #include<stdio.h>
      
      int main()
      {
          int x = 10;
      
          while (x-- > 0)
              printf("%d ",x);
      
          return 0;
      }
      

      Çıktı şöyle olacak:

       
      9 8 7 6 5 4 3 2 1 0            
      
          
      123
      2015-04-30 22: 50: 01Z

      Aslında, x azaltma sonrası ve bu koşul kontrol ediliyor. --> değil, (x--) > 0 değil

      Not: x'un değeri, koşul kontrol edildikten sonra değiştirilir, çünkü azalma sonrası değer değiştirilir. Bazı benzer durumlar da ortaya çıkabilir, örneğin:

       
      -->    x-->0
      ++>    x++>0
      -->=   x-->=0
      ++>=   x++>=0
      
          
      117
      2014-04-12 09: 52: 33Z
      1. Bunun dışında ++ > bir süre içinde pek kullanılamaz (). Bir "kadar gider ..." operatörü ++ olur<, hiç bir yere o kadar hoş görünmüyor. Operatör - > mutlu bir tesadüf.
        2014-09-01 09: 46: 25Z
      2. while (0 <-- x) da çalışabilir mi, sonra?
        2015-06-15 14: 00: 33Z
      3. @ BenLeggiero Bir şey yapan kod üretme anlamında 'çalışabilir' (sahte kodu sevmeyen okuyucuları çürütürken), ancak anlambilimsel farklı, önceden belirlenmiş kullanımı, daha az yinelemeyi gerçekleştireceği anlamına gelir. Tartışmalı bir örnek olarak, x 1'de başlarsa döngü halkasını hiçbir zaman çalıştırmaz, ancak while ( (x--) > 0 ) yapar. {edit} Eric Lippert C # 4 sürüm notlarında her ikisini de kapladı: blogs.msdn.microsoft.com/ericlippert/2010/04/01/…
        2016-11-12 17: 57: 29Z

      C ve C ++ " maksimum mide "kuralına uyun. Aynı şekilde, bir --- b, (a--) - b'a çevrilir, bu durumda x-->0, (x--)>0'a çevrilir.

      Kuralın esasen söylediği, soldan sağa gitmek, ifadelerin geçerli bir ifade oluşturacak maksimum karakteri alarak ifadelerdir.

          
      113
      2014-04-12 09: 55: 16Z
      1. OP'nin varsaydığı şey: işte "((a) - >)" en fazla munch'dı. OP'nin orijinal varsayımının yanlış olduğu ortaya çıktı: "- >" maksimum geçerli bir operatör değil.
        2014-08-28 00: 41: 45Z
      2. Doğru hatırlıyorsam, açgözlü ayrıştırma olarak da bilinir.
        2015-07-11 01: 04: 15Z
      3. @ RoyTinker Açgözlü tarama. Ayrıştırıcının bununla hiçbir ilgisi yok.
        2016-09-11 02: 21: 50Z

      Neden tüm komplikasyonlar?

      Asıl soruya verilen basit cevap sadece:

       
      #include <stdio.h>
      int main()
      {
          int x = 10;
          while (x > 0) 
          {
              printf("%d ", x);
              x = x-1;
          }
      }
      

      Aynı şeyi yapar. Bunu böyle yapman gerektiğini söylemiyorum, ama aynı şeyi yapıyor ve soruyu tek bir yazıya cevaplamış olacaktı.

      x--, yukarıdakiler için sadece kısa yoldur ve >, operator’dan normal bir büyüktür. Büyük gizem yok!

      Bugünlerde basit şeyleri karmaşık hale getiren çok fazla insan var;)

          
      26
      2018-06-30 10: 10: 56Z
      1. Bu soru komplikasyonlarla ilgili değildir, ancak ** C ++ /STL'nin Gizli Özellikleri ve Karanlık Köşeleri **
        2016-10-27 15: 32: 01Z
      2. Buradaki program, orijinalden farklı çıktılar verir çünkü burada x, printf işleminden sonra azalır. Bu, "basit cevapların" genellikle Yanlış olduğunu nasıl gösterir.
        2017-05-13 09: 30: 30Z
      3. The OP's way: 9 8 7 6 5 4 3 2 1 0 ve The Garry_G way: 10 9 8 7 6 5 4 3 2 1
        2017-12-15 18: 33: 22Z
      4. Aynı şeyi yapmıyor. x=x-1’u printf’dan önce hareket ettirdikten sonra "aynı şeyi yapıyor" diyebilirsiniz.
        2019-01-05 17: 05: 49Z

      Geleneksel yoldanwhile döngü parantezinde () bir koşulu ve {} parantezleri içindeki bir sonlandırma koşulunu tanımlayın, ancak --> her ikisini de aynı anda tanımlar.

      Örneğin:

       
      int abc(void)
      {
          int a = 5
          while((a--) > 0) // Decrement and comparison both at once
          {
              // Code
          }
      }
      

      Bu, a'u azaltır ve a, 0'dan büyükken döngüyü çalıştırır.

      Geleneksel olarak şöyle olur:

       
      int abc(void)
      {
          int a = 5;
          while(a > 0)
          {
              a--;
              // Code
          }
          a--;
      }
      

      Her iki şekilde de aynı şeyi yapar ve aynı hedeflere ulaşırız.

          
      23
      2019-06-15 19: 35: 13Z
      1. Bu yanlış. Sorunun içindeki kod şu şekildedir: 'test-write-execute' (önce test, yeni değer yaz, çevrimi yürü), örneğin 'test-execute-write'.
        2017-07-14 19: 07: 40Z
      2. @ v010dya Yanıt düzeltildi, şimdi soruda olduğu gibi test-write-execute, işaret ettiğiniz için teşekkür ederiz!
        2019-05-12 10: 59: 49Z
      3. @ VladislavToncharov Düzenlemeniz hala yanlıştı. Benimkini gör.
        2019-06-15 19: 36: 17Z
kaynak yerleştirildi İşte