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

Hoặc cho một cái gì đó hoàn toàn khác ... x trượ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, do đó, 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 bài) tương đương với x = x-1, do đó, mã chuyển đổi thành:

while(x > 0) {
    x = x-1;
    // logic
}

x có thể về 0 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 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 x sẽ chuyển đến 0 và thu hút 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ố 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". "-->" dễ dàng được ghi nhớ theo hướng và "trong khi x về 0" là nghĩa 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 sau x 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. while( x-- > 0 ) thực sự có nghĩa là while( x > 0). Bài viết x-- giảm 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à >. x là 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à toán tử giảm và > là toán tử lớn hơn .

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

Đó là sự kết hợp của hai nhà khai thác. Đầu tiên -- là để giảm giá trị và > là để 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ế, x đang giảm sau và với điều kiện đó đang được kiểm tra. Đó không phải là -->, đó 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 thành (a--) - b, trong trường hợp của bạn x-->0 dịch thành (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.

x-- chỉ là viết tắt cho phần trên và > chỉ là một số lớn hơn bình thường operator. 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;)

Cách thông thường chúng ta xác định điều kiện trong ngoặc đơn trong vòng lặp "()" và chấm dứt điều kiện bên trong dấu ngoặc "{}", nhưng -- & > này là cách người ta xác định tất cả cùng một lúc. Ví dụ:

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

Nó nói, giảm a và chạy vòng lặp cho đến thời điểm a lớn hơn 0

Cách khác nó nên có được như:

int abc() {
    int a = 5;
    while(a > 0) {
        a = a -1 // Decrement inside loop
        // Code
    }
}

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.