tra-loi-cau-hoi-phat-trien-web.com

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

Sau khi đọc Các tính năng ẩn và góc tối của C++/STL trên comp.lang.c++.moderated, tôi hoàn toàn ngạc nhiên khi đoạn trích sau được biên dịch và hoạt động trong 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);
    }
}

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?

8282
GManNickG

--> không phải là toán tử. Thực tế, đây là hai toán tử riêng biệt, -->.

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

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

while( (x--) > 0 )
7974
Charles Salvia

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ữ ...

2737
unsynchronized

Đó 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: --> được mô tả tương ứng trong §5.2.6/2 và §5.9 của Tiêu chuẩn C++ 03.

2297
Kirill V. Lyadvinsky

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
}
1214
Jay Riggs

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

;)

1034
doc

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.

524
RageZ

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.

395
Matt Joiner
while( x-- > 0 )

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

343
Grumdrig

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

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 ^^

302
NguyenDat

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

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

cho các số không âm

252
Good Person

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.

230
Test

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
212
Sajad Bahmani

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".

167
cool_me5000

Có một khoảng trống bị thiếu giữa -->. 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 ?.

138
Mr. X

-- là toán tử giảm > 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ư -->.

129
sam

Đó 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            
123
Rajeev Das

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
117
AndroidLearner

CC++ 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ệ.

113
Pandrei

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

26
Garry_G

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.

23
Zohaib Ejaz