Apa yang dimaksud dengan operator "->" di C ++?

Setelah membaca Fitur Tersembunyi dan Sudut Gelap C ++ / STL aktif comp.lang.c++.moderated, saya benar-benar terkejut bahwa cuplikan berikut dikompilasi dan bekerja di Visual Studio 2008 dan G ++ 4.4.

Berikut kodenya:

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

Keluaran:

9 8 7 6 5 4 3 2 1 0

Saya berasumsi ini C, karena berfungsi di GCC juga. Di mana ini didefinisikan dalam standar, dan dari mana asalnya?

-->bukan operator. Sebenarnya dua operator terpisah, --dan> .

Pengurangan kode kondisional x, sambil mengembalikan nilai xasli (tidak dikurangi), dan kemudian membandingkan nilai asli dengan 0menggunakan >operator.

Untuk lebih memahami, pernyataan itu dapat ditulis sebagai berikut:

while( (x--) > 0 )

Atau untuk sesuatu yang sama sekali berbeda ... xslide 0.

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

Tidak begitu matematis, tapi ... setiap gambar melukis seribu kata ...

Itu operator yang sangat rumit, bahkan ISO / IEC JTC1 (Joint Technical Committee 1) menempatkan deskripsinya dalam dua bagian berbeda dari Standar C ++.

Di samping bercanda, mereka adalah dua operator yang berbeda: --dan >dijelaskan masing-masing dalam §5.2.6 / 2 dan §5.9 dari Standar C ++ 03.

Ini setara dengan

while (x-- > 0)

x--(post decrement) setara dengan x = x-1itu, kode berubah menjadi:

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

x dapat mencapai nol lebih cepat di arah yang berlawanan:

int x = 10;

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

8 6 4 2

Anda dapat mengontrol kecepatan dengan panah!

int x = 100;

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

90 80 70 60 50 40 30 20 10

;)

Nya

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

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

       printf("%d ", x);
     }

     return 0;
}

Hanya ruang membuat hal-hal terlihat lucu, --mengurangi dan >membandingkan.

Penggunaan -->memiliki relevansi historis. Pengurangan adalah (dan masih dalam beberapa kasus), lebih cepat daripada peningkatan pada arsitektur x86. Menggunakan -->menyarankan yang xakan 0, dan menarik bagi mereka yang memiliki latar belakang matematika.

while( x-- > 0 )

adalah bagaimana itu diuraikan.

Benar-benar geek, tapi saya akan menggunakan ini:

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

Satu buku yang saya baca (saya tidak ingat buku mana) menyatakan: Kompiler mencoba mengurai ekspresi ke token terbesar dengan menggunakan aturan kiri kanan.

Dalam hal ini, ungkapan:

x-->0

Parsing ke token terbesar:

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

Aturan yang sama berlaku untuk ungkapan ini:

a-----b

Setelah diurai:

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

Saya harap ini membantu untuk memahami ungkapan yang rumit ^^

Ini persis sama dengan

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

untuk nomor non-negatif

Bagaimanapun, kami memiliki operator "pergi ke" sekarang. "-->"mudah diingat sebagai arah, dan "sementara x pergi ke nol" artinya langsung.

Selain itu, ini sedikit lebih efisien daripada "for (x = 10; x > 0; x --)"pada beberapa platform.

Kode ini pertama kali membandingkan x dan 0 dan kemudian mengurangi x. (Juga disebutkan dalam jawaban pertama: Anda adalah post-decrementing x dan kemudian membandingkan x dan 0 dengan >operator.) Lihat output dari kode ini:

9 8 7 6 5 4 3 2 1 0

Kami sekarang pertama-tama membandingkan dan kemudian mengurangi dengan melihat 0 di output.

Jika kita ingin mengurangi pertama dan kemudian membandingkan, gunakan kode ini:

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

    while( --x> 0 ) // x goes to 0
    {
        printf("%d ", x);
    }
    return 0;
}

Output itu adalah:

9 8 7 6 5 4 3 2 1

Kompiler saya akan mencetak 9876543210 ketika saya menjalankan kode ini.

#include <iostream>
int main()
{
    int x = 10;

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

Seperti yang diharapkan. The while( x-- > 0 )sebenarnya berarti while( x > 0). The x--pasca decrements x.

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

adalah cara berbeda untuk menulis hal yang sama.

Sangat menyenangkan bahwa aslinya terlihat seperti "sementara x pergi ke 0" sekalipun.

Ada ruang yang hilang antara --dan >. xadalah post decremented, yaitu decremented setelah memeriksa kondisi x>0 ?.

--adalah penurunan operator dan >adalah lebih besar daripada operator.

Kedua operator diterapkan seperti satu -->.

Ini kombinasi dari dua operator. Pertama --adalah untuk mengurangi nilai, dan >untuk memeriksa apakah nilainya lebih besar dari operan kanan.

#include<stdio.h>

int main()
{
    int x = 10;

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

    return 0;
}

Outputnya adalah:

9 8 7 6 5 4 3 2 1 0            

Sebenarnya, xpost-decrementing dan dengan kondisi itu sedang diperiksa. Ini tidak -->, itu(x--) > 0

Catatan: nilai xdiubah setelah kondisi diperiksa, karena post-decrementing. Beberapa kasus serupa juga dapat terjadi, misalnya:

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

C dan C ++ mematuhi aturan "maksimum mengunyah". Cara yang sama a --- b diterjemahkan ke (a--) - b, dalam kasus Anda x-->0diterjemahkan menjadi(x--)>0 .

Pada dasarnya aturan mengatakan bahwa dari kiri ke kanan, ekspresi dibentuk dengan mengambil karakter maksimum yang akan membentuk ekspresi yang valid.

Kenapa semua komplikasinya?

Jawaban sederhana untuk pertanyaan awal adalah:

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

Melakukan hal yang sama. Tidak mengatakan Anda harus melakukannya seperti ini, tetapi melakukan hal yang sama dan akan menjawab pertanyaan dalam satu posting.

Ini x--hanya singkatan untuk di atas, dan >hanya lebih besar dari normal operator. Bukan misteri besar!

Ada terlalu banyak orang membuat hal-hal sederhana menjadi rumit saat ini;)

Dengan cara konvensional kita akan mendefinisikan suatu kondisi dalam whilekurung loop ()dan kondisi terminating di dalam kurung {}, tetapi--> mendefinisikan keduanya sekaligus.

Sebagai contoh:

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

Ini mengurangi adan menjalankan loop sementara alebih besar dari0 .

Secara konvensional, itu akan seperti:

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

Kedua cara, kami melakukan hal yang sama dan mencapai tujuan yang sama.

(x --> 0) cara (x-- > 0)

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

2. Anda dapat menggunakan (-- x > 0) itu berarti(--x > 0)
output -: 9 8 7 6 5 4 3 2 1

3. kamu bisa menggunakan

(--\
    \
     x > 0)

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

4. kamu bisa menggunakan

(\
  \
   x --> 0)

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

5. kamu bisa menggunakan

(\
  \
   x --> 0
          \
           \
            )

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

6. Anda juga bisa menggunakannya

(
 x 
  --> 
      0
       )

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

Anda juga dapat mencoba banyak metode untuk menjalankan perintah ini dengan sukses