ตัวดำเนินการ“ ->” ใน C ++ คืออะไร

หลังจากที่ได้อ่านคุณลักษณะที่ซ่อนอยู่และมุมมืดของ C ++ / STLบนcomp.lang.c++.moderatedฉันรู้สึกประหลาดใจอย่างสมบูรณ์ที่ต่อไปนี้ข้อมูลที่รวบรวมและทำงานทั้งใน Visual Studio 2008 และ G ++ 4.4

นี่คือรหัส:

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

เอาท์พุท:

9 8 7 6 5 4 3 2 1 0

ฉันคิดว่านี่คือ C เพราะมันใช้ได้ใน GCC เช่นกัน สิ่งนี้นิยามไว้ที่ไหนในมาตรฐานและมาจากที่ไหน

-->ไม่ใช่ผู้ประกอบการ มันเป็นความจริงสองผู้ประกอบการที่แยกจากกันและ-->

การลดลงของรหัสตามเงื่อนไขxในขณะที่ส่งคืนค่าxดั้งเดิม (ไม่ลดลง) แล้วเปรียบเทียบค่าเดิมกับการ0ใช้ตัว>ดำเนินการ

เพื่อความเข้าใจที่ดีขึ้นสามารถเขียนข้อความดังต่อไปนี้:

while( (x--) > 0 )

หรือสำหรับบางสิ่งบางอย่างที่แตกต่างกันอย่างสิ้นเชิง ... สไลด์ไปx0

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

ไม่ใช่ทางคณิตศาสตร์ แต่ ... ทุกภาพวาดพันคำ ...

นั่นเป็นตัวดำเนินการที่ซับซ้อนมากดังนั้นแม้ISO / IEC JTC1 (คณะกรรมการด้านเทคนิคร่วม 1)วางคำอธิบายไว้ในสองส่วนที่แตกต่างกันของมาตรฐาน C ++

พวกเขาเป็นตัวดำเนินการที่ต่างกันสองตัว: --และ>อธิบายตามลำดับใน§5.2.6 / 2 และ§5.9ของมาตรฐาน C ++ 03

มันเทียบเท่ากับ

while (x-- > 0)

x--(การลดลงภายหลัง) เทียบเท่ากับx = x-1ดังนั้นรหัสแปลงเป็น:

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

x สามารถไปที่ศูนย์ได้เร็วขึ้นในทิศทางตรงกันข้าม:

int x = 10;

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

8 6 4 2

คุณสามารถควบคุมความเร็วด้วยลูกศร!

int x = 100;

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

90 80 70 60 50 40 30 20 10

;)

มัน

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

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

       printf("%d ", x);
     }

     return 0;
}

แค่พื้นที่ทำให้สิ่งต่าง ๆ ดูตลก--ลดลงและ>เปรียบเทียบ

การใช้งานของ-->มีความเกี่ยวข้องทางประวัติศาสตร์ การลดลงคือ (และยังคงอยู่ในบางกรณี) เร็วกว่าการเพิ่มขึ้นของสถาปัตยกรรม x86 การใช้การ-->แนะนำที่xกำลังจะเกิดขึ้น0และดึงดูดผู้ที่มีภูมิหลังทางคณิตศาสตร์

while( x-- > 0 )

เป็นวิธีที่แยกวิเคราะห์

เกินบรรยาย แต่ฉันจะใช้สิ่งนี้:

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

หนังสือเล่มหนึ่งที่ฉันอ่าน (ฉันจำไม่ถูกต้องว่าหนังสือเล่มใด) ที่ระบุไว้: คอมไพเลอร์พยายามแยกการแสดงออกของโทเค็นที่ใหญ่ที่สุดโดยใช้กฎด้านซ้ายขวา

ในกรณีนี้การแสดงออก:

x-->0

แยกวิเคราะห์โทเค็นที่ใหญ่ที่สุด:

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

กฎเดียวกันนี้ใช้กับนิพจน์นี้:

a-----b

หลังจากแยกวิเคราะห์:

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

ฉันหวังว่านี่จะช่วยให้เข้าใจการแสดงออกที่ซับซ้อนได้ ^^

ตรงนี้เป็นเช่นเดียวกับ

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

สำหรับตัวเลขที่ไม่ใช่ลบ

อย่างไรก็ตามเรามีโอเปอเรเตอร์ "ไปที่" แล้ว "-->"ง่ายต่อการจดจำเป็นทิศทางและ "ในขณะที่ x ไปที่ศูนย์" เป็นความหมายตรง

นอกจากนี้ยังมีประสิทธิภาพมากกว่า"for (x = 10; x > 0; x --)"ในบางแพลตฟอร์มเล็กน้อย

รหัสนี้เปรียบเทียบ x และ 0 ก่อนแล้วจึงลดลง x (ยังกล่าวในคำตอบแรก: คุณโพสต์ลดลง x แล้วเปรียบเทียบ x และ 0 กับ>ผู้ประกอบการ) ดูผลลัพธ์ของรหัสนี้:

9 8 7 6 5 4 3 2 1 0

ตอนนี้เราเปรียบเทียบก่อนแล้วลดลงโดยเห็น 0 ในผลลัพธ์

หากเราต้องการลดอันดับแรกจากนั้นเปรียบเทียบใช้รหัสนี้:

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

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

ผลลัพธ์นั้นคือ:

9 8 7 6 5 4 3 2 1

คอมไพเลอร์ของฉันจะพิมพ์ออกมา 9876543210 เมื่อฉันเรียกใช้รหัสนี้

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

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

อย่างที่คาดไว้. ความwhile( x-- > 0 )หมายที่while( x > 0)แท้จริง x--โพสต์ xdecrements

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

เป็นวิธีที่แตกต่างในการเขียนสิ่งเดียวกัน

เป็นเรื่องที่ดีที่ต้นฉบับดูเหมือนว่า "ในขณะที่ x ไปที่ 0"

มีช่องว่างระหว่าง--และ>ถึง xถูกโพสต์ decremented ที่เป็น decremented x>0 ?หลังจากการตรวจสอบสภาพ

--เป็นตัวดำเนินการลดค่าและ>เป็นตัวดำเนินการมากกว่า

-->สองผู้ประกอบการจะนำไปใช้เป็นหนึ่งเดียวเช่น

มันเป็นการรวมกันของผู้ให้บริการสองราย อันดับแรก--คือการลดค่าและ>สำหรับการตรวจสอบว่าค่ามากกว่าตัวถูกดำเนินการทางขวาหรือไม่

#include<stdio.h>

int main()
{
    int x = 10;

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

    return 0;
}

ผลลัพธ์จะเป็น:

9 8 7 6 5 4 3 2 1 0            

ที่จริงแล้วxมีการโพสต์ลดลงและมีการตรวจสอบเงื่อนไขที่ มันไม่ใช่-->มัน(x--) > 0

หมายเหตุ: ค่าของxจะถูกเปลี่ยนหลังจากตรวจสอบเงื่อนไขแล้วเนื่องจากมีการเปลี่ยนแปลงภายหลัง บางกรณีที่คล้ายกันสามารถเกิดขึ้นได้เช่น:

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

CและC ++ปฏิบัติตามกฎ "การทำลายล้างสูงสุด" วิธีเดียวกัน --- ขแปลไป(a--) - bในกรณีของคุณ จะแปลว่าx-->0(x--)>0

สิ่งที่กฏบอกเป็นหลักคือไปทางซ้ายไปทางขวานิพจน์เกิดขึ้นจากการใช้อักขระสูงสุดซึ่งจะทำให้เกิดนิพจน์ที่ถูกต้อง

ทำไมต้องเกิดภาวะแทรกซ้อนทั้งหมด?

คำตอบง่ายๆสำหรับคำถามต้นฉบับคือ:

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

ทำสิ่งเดียวกัน ไม่ได้บอกว่าคุณควรทำแบบนี้ แต่ทำสิ่งเดียวกันและจะตอบคำถามในโพสต์เดียว

x--เป็นเพียงชวเลขข้างต้นและเป็นเพียงมากขึ้นกว่าปกติ> operatorไม่มีความลึกลับที่ยิ่งใหญ่!

ทุกวันนี้มีคนจำนวนมากที่สร้างสิ่งเรียบง่ายซับซ้อน)

ในวิธีการทั่วไปเราจะกำหนดเงื่อนไขในwhileวงเล็บห่วง()และเงื่อนไขยุติภายในวงเล็บปีกกา{}แต่-->กำหนดทั้งสองในครั้งเดียว

ตัวอย่างเช่น:

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

การลดลงนี้aและวิ่งวนรอบในขณะที่มีค่ามากกว่าa0

ตามอัตภาพมันจะเป็นเช่น:

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

ทั้งสองวิธีเราทำสิ่งเดียวกันและบรรลุเป้าหมายเดียวกัน

(x --> 0) วิธี (x-- > 0)

1. คุณสามารถใช้ได้ (x -->)
output -: 9 8 7 6 5 4 3 2 1 0

2. คุณสามารถใช้(-- x > 0) มันหมายความว่า(--x > 0)
output -: 9 8 7 6 5 4 3 2 1

3. คุณสามารถใช้ได้

(--\
    \
     x > 0)

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

4. คุณสามารถใช้ได้

(\
  \
   x --> 0)

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

5. คุณสามารถใช้ได้

(\
  \
   x --> 0
          \
           \
            )

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

6. คุณสามารถใช้

(
 x 
  --> 
      0
       )

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

เช่นเดียวกันคุณสามารถลองวิธีการมากมายในการเรียกใช้คำสั่งนี้ได้สำเร็จ