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

Okuduktan sonra Gizli Özellikleri ve C ++ / STL Dark Corners üzerine comp.lang.c++.moderated, tamamen aşağıdaki derlenmiş ve Visual Studio 2008 ve G ++ 4.4 hem çalıştı snippet'ine olduğu şaşırdı.

İşte kod:

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

Çıktı:

9 8 7 6 5 4 3 2 1 0

Bunun C olduğunu varsayacağım, çünkü GCC'de de çalışıyor. Bu standartta nerede tanımlanır ve nereden gelir?

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

Koşulun kodu x, xorijinal (azaltılmamış) değeri döndürülürken azalır ve ardından orijinal değeri işleci 0kullanarak karşılaştırır >.

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

while( (x--) > 0 )

Ya da tamamen farklı bir şey için ... xkayar 0.

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

O kadar matematiksel değil, ama ... her resim bin kelimeyi boyar ...

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

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

Eşittir

while (x-- > 0)

x--(azaltma sonrası) buna eşdeğerdir x = x-1, kod şuna dönüşür:

while(x > 0) {
    x = x-1;
    // logic
}
x--;   // The post decrement done when x <= 0

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

int x = 10;

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

8 6 4 2

Hızı bir ok ile kontrol edebilirsiniz!

int x = 100;

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

90 80 70 60 50 40 30 20 10

;)

Onun

#include <stdio.h>
int main(void){
     int x = 10;

     while( x-- > 0 ){ // x goes to 0

       printf("%d ", x);
     }

     return 0;
}

Sadece alan şeylerin komik görünmesini sağlar, --azalır ve >karşılaştırır.

Kullanımının -->tarihsel önemi vardır. Azaltma, (ve bazı durumlarda hala) x86 mimarisinde artıştan daha hızlıydı. Kullanılması -->düşündürmektedir xgidiyor 0matematiksel kökenden olanlara, ve itirazlar.

while( x-- > 0 )

işte böyle ayrıştırılıyor.

Tamamen inek, ama bunu kullanacağız:

#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;
}

Okuduğum bir kitap (hangi kitabı doğru hatırlamıyorum) ifade etti: Derleyiciler , sol sağ kuralı kullanarak ifadeleri en büyük jetonla ayrıştırmaya çalışırlar .

Bu durumda, ifade:

x-->0

En büyük jetonlara ayrıştırma:

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

Aynı kural bu ifade için de geçerlidir:

a-----b

Ayrıştırmadan 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 ^^

Bu tam olarak aynı

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

negatif olmayan sayılar için

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

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

Bu kod önce x ve 0'ı karşılaştırır, sonra x'i azaltır. (Ayrıca ilk cevapta da söylendi: x >değerini azaltma ve x ile 0'ı operatörle karşılaştırma.) Bu kodun çıktısına bakın:

9 8 7 6 5 4 3 2 1 0

Şimdi çıktıda 0'ı görerek önce karşılaştırıyoruz ve azalıyoruz.

Önce azaltmak ve sonra karşılaştırmak istiyorsak, bu 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

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;
    }
}

Beklenildiği gibi. while( x-- > 0 )Aslında demektir while( x > 0). x--Sonrası azaltır x.

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

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

Yine de orijinalin "x 0'a giderken" gibi olması güzel.

--Ve arasında eksik bir boşluk var >. xsonrası azaltılır, yani durumu kontrol ettikten sonra azaltılır x>0 ?.

--bir eksiltme operatörü >olan büyüktür operatör.

İki operatör tek bir tane gibi uygulanır -->.

İki operatörün bir kombinasyonu. Birincisi --, değeri azaltmak ve değerin >sağ taraftaki işlenenden daha büyük olup olmadığını kontrol etmektir.

#include<stdio.h>

int main()
{
    int x = 10;

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

    return 0;
}

Çıktı şöyle olacaktır:

9 8 7 6 5 4 3 2 1 0            

Aslında, xazalmadan sonra ve bu durum kontrol ediliyor. Değil -->, değil(x--) > 0

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

-->    x-->0
++>    x++>0
-->=   x-->=0
++>=   x++>=0

C ve C ++ , "maksimum munch" kuralına uyar. Aynı şekilde --- b'ye çevrilir (a--) - b, sizin durumunuzda da x-->0tercüme edilir (x--)>0.

Kuralın temelde söylediği şey, soldan sağa doğru, ifadelerin geçerli bir ifade oluşturacak maksimum karakter alınarak oluşturulur.

Neden tüm komplikasyon?

Orijinal sorunun basit cevabı şudur:

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

Aynı şeyi yapar. Bunu böyle yapmanız gerektiğini söylememek, ama aynı şeyi yapar ve soruyu bir gönderide cevaplardı.

Yukarıdaki x--sadece kısayol ve >normalden daha büyük operator. Büyük gizem yok!

Günümüzde basit şeyleri karmaşık hale getiren çok fazla insan var;)

Geleneksel yolla, whiledöngü parantezinde bir koşul ve parantez içindeki ()bir sonlandırma koşulu tanımlayacağız {}, ancak -->ikisini birden tanımlayacağız.

Örneğin:

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

Bu adöngü adaha büyükken döngüyü azaltır ve çalıştırır 0.

Geleneksel olarak şöyle olur:

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

Her iki şekilde de aynı şeyi yapıyoruz ve aynı hedeflere ulaşıyoruz.

(x --> 0) anlamına geliyor (x-- > 0)

1. kullanabilirsiniz (x -->)
output -: 9 8 7 6 5 4 3 2 1 0

2. Kullanabileceğiniz (-- x > 0) Bu kötü biri(--x > 0)
output -: 9 8 7 6 5 4 3 2 1

3. kullanabilirsiniz

(--\
    \
     x > 0)

output -: 9 8 7 6 5 4 3 2 1

4. kullanabilirsiniz

(\
  \
   x --> 0)

output -: 9 8 7 6 5 4 3 2 1 0

5. kullanabilirsiniz

(\
  \
   x --> 0
          \
           \
            )

output -: 9 8 7 6 5 4 3 2 1 0

6. ayrıca kullanabilirsiniz

(
 x 
  --> 
      0
       )

output -: 9 8 7 6 5 4 3 2 1 0

benzer şekilde, bu komutu başarıyla yürütmek için birçok yöntemi deneyebilirsiniz