Toán tử - -> trong C ++ là gì?

Sau khi đọc Các tính năng ẩn và Dark Corners của C ++ / STL trên comp.lang.c++.moderated, tôi đã hoàn toàn ngạc nhiên rằng sau Đoạn biên soạn và làm việc tại cả Visual Studio 2008 và G ++ 4.4.

Đây là mã:

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

Đầu ra:

9 8 7 6 5 4 3 2 1 0

Tôi cho rằng đây là C, vì nó cũng hoạt động trong GCC. Điều này được định nghĩa trong tiêu chuẩn và nó đến từ đâu?

-->không phải là một nhà điều hành. Trên thực tế, đó là hai toán tử riêng biệt --và >.

Mã giảm của điều kiện x, trong khi trả về xgiá trị gốc (không giảm), và sau đó so sánh giá trị ban đầu với 0việc sử dụng >toán tử.

Để hiểu rõ hơn, tuyên bố có thể được viết như sau:

while( (x--) > 0 )

Hoặc cho một cái gì đó hoàn toàn khác ... xtrượt đến 0.

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

Không phải là toán học, nhưng ... mỗi bức tranh vẽ một ngàn chữ ...

Đó là một toán tử rất phức tạp, thậm chí ISO / IEC JTC1 (Ủy ban kỹ thuật chung 1) đã đặt mô tả của nó trong hai phần khác nhau của Tiêu chuẩn C ++.

Đùa qua một bên, họ là hai toán tử khác nhau: --và >được mô tả tương ứng trong §5.2.6 / 2 và §5.9 của Tiêu chuẩn C ++ 03.

Nó tương đương với

while (x-- > 0)

x--(giảm dần bài) tương đương với x = x-1như vậy, mã chuyển đổi thành:

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

x có thể về không thậm chí nhanh hơn theo hướng ngược lại:

int x = 10;

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

8 6 4 2

Bạn có thể kiểm soát tốc độ bằng một mũi tên!

int x = 100;

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

90 80 70 60 50 40 30 20 10

;)

nó là

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

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

       printf("%d ", x);
     }

     return 0;
}

Chỉ cần không gian làm cho mọi thứ trông buồn cười, --giảm dần và >so sánh.

Việc sử dụng -->có liên quan lịch sử. Giảm là (và vẫn còn trong một số trường hợp), nhanh hơn so với tăng trên kiến ​​trúc x86. Sử dụng -->gợi ý rằng điều đó xsẽ xảy ra 0, và hấp dẫn những người có nền tảng toán học.

while( x-- > 0 )

là cách phân tích cú pháp.

Hoàn toàn đam mê, nhưng tôi sẽ sử dụng cái này:

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

Một cuốn sách tôi đã đọc (tôi không nhớ chính xác cuốn sách nào) đã nêu: Trình biên dịch cố gắng phân tích các biểu thức thành mã thông báo lớn nhất bằng cách sử dụng quy tắc bên trái.

Trong trường hợp này, biểu thức:

x-->0

Phân tích cú pháp token lớn nhất:

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

Quy tắc tương tự áp dụng cho biểu thức này:

a-----b

Sau khi phân tích cú pháp:

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

Tôi hy vọng điều này sẽ giúp hiểu được biểu thức phức tạp ^^

Điều này giống hệt như

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

cho các số không âm

Dù sao, bây giờ chúng ta có một nhà điều hành "đi đến". "-->"rất dễ được ghi nhớ như một hướng và "trong khi x về không" có nghĩa là thẳng.

Hơn nữa, nó hiệu quả hơn một chút so với "for (x = 10; x > 0; x --)"trên một số nền tảng.

Mã này trước tiên so sánh x và 0 và sau đó giảm x. (Cũng đã nói trong câu trả lời đầu tiên: Bạn đang giảm x sau và sau đó so sánh x và 0 với >toán tử.) Xem đầu ra của mã này:

9 8 7 6 5 4 3 2 1 0

Bây giờ chúng ta trước tiên so sánh và sau đó giảm dần bằng cách thấy 0 trong đầu ra.

Nếu chúng ta muốn giảm đầu tiên và sau đó so sánh, hãy sử dụng mã này:

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

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

Đầu ra đó là:

9 8 7 6 5 4 3 2 1

Trình biên dịch của tôi sẽ in ra 9876543210 khi tôi chạy mã này.

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

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

Như mong đợi. Các while( x-- > 0 )phương tiện thực sự while( x > 0). Các x--bài giảm dần x.

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

là một cách viết khác nhau của cùng một điều.

Thật là tốt khi bản gốc trông giống như "trong khi x đi về 0".

Có một khoảng trống bị thiếu giữa --và >. xlà bài giảm dần, nghĩa là giảm dần sau khi kiểm tra điều kiện x>0 ?.

--là sụt điều hành và >là lớn hơn-hơn toán tử.

Hai toán tử được áp dụng như một như một -->.

Đó là sự kết hợp của hai nhà khai thác. Đầu tiên --là để giảm giá trị và >để kiểm tra xem giá trị đó có lớn hơn toán hạng bên phải hay không.

#include<stdio.h>

int main()
{
    int x = 10;

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

    return 0;
}

Đầu ra sẽ là:

9 8 7 6 5 4 3 2 1 0            

Trên thực tế, xlà giảm sau và với điều kiện đó đang được kiểm tra. Không phải -->, đó là(x--) > 0

Lưu ý: giá trị của xđược thay đổi sau khi điều kiện được kiểm tra, vì nó giảm sau. Một số trường hợp tương tự cũng có thể xảy ra, ví dụ:

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

C và C ++ tuân theo quy tắc "tối đa munch". Giống như cách a --- b được dịch sang (a--) - b, trong trường hợp của bạn x-->0dịch sang (x--)>0.

Những gì quy tắc nói về cơ bản là từ trái sang phải, các biểu thức được hình thành bằng cách lấy tối đa các ký tự sẽ tạo thành một biểu thức hợp lệ.

Tại sao tất cả các biến chứng?

Câu trả lời đơn giản cho câu hỏi ban đầu chỉ là:

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

Có làm điều tương tự. Không nói rằng bạn nên làm điều đó như thế này, nhưng nó làm điều tương tự và sẽ trả lời câu hỏi trong một bài.

Nó x--chỉ là viết tắt cho những điều trên, và >chỉ là một bình thường lớn hơnoperator . Không có bí ẩn lớn!

Ngày nay có quá nhiều người làm những điều đơn giản trở nên phức tạp;)

Theo cách thông thường, chúng ta sẽ định nghĩa một điều kiện trong whilengoặc đơn vòng lặp ()và điều kiện kết thúc bên trong dấu ngoặc {}, nhưng -->định nghĩa cả hai cùng một lúc.

Ví dụ:

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

Điều này giảm avà chạy vòng lặp trong khi alớn hơn 0.

Thông thường, nó sẽ giống như:

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

Cả hai cách, chúng tôi làm cùng một điều và đạt được cùng một mục tiêu.

(x --> 0) có nghĩa (x-- > 0)

1. bạn có thể dùng (x -->)
output -: 9 8 7 6 5 4 3 2 1 0

2. bạn có thể sử dụng (-- x > 0) Nó có nghĩa là(--x > 0)
output -: 9 8 7 6 5 4 3 2 1

3. bạn có thể dùng

(--\
    \
     x > 0)

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

4. bạn có thể dùng

(\
  \
   x --> 0)

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

5. bạn có thể dùng

(\
  \
   x --> 0
          \
           \
            )

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

6. bạn cũng có thể sử dụng

(
 x 
  --> 
      0
       )

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

tương tự, bạn có thể thử nhiều phương thức để thực hiện lệnh này thành công