Какво е операторът "->" в C ++?

След като прочетете скритите функции и тъмните ъгли на C ++ / STL на comp.> , бях напълно изненадан, че следният фрагмент е съставен и работи както в Visual Studio 2008, така и в g ++ 4.4.

Ето кода:

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

Предполагам, че това е C, тъй като работи в GCC. Къде е дефиниран в стандарта и откъде идва?

8054
29 окт. настроен от GManNickG 29 окт. 2009-10-29 09:57 '09 в 9:57 ч. 2009-10-29 09:57
@ 25 отговора

--> не е оператор. Всъщност, това са два отделни оператора -- и > .

Условният код намалява стойността на x като връща първоначалната (не редуцирана) стойност на x , и след това сравнява първоначалната стойност с 0 използвайки > оператора.

За по-добро разбиране изразът може да бъде написан по следния начин:

 while( (x--) > 0 ) 
7743
29 окт. отговор, даден на Чарлз Салвия на 29 октомври 2009-10-29 10:00 '09 в 10:00 2009-10-29 10:00

Или за нещо съвсем различно ... x подхлъзва се до 0

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

Не толкова математически, но ... всяка картина рисува хиляди думи ...

2564
18 янв. отговорът е даден несинхронизиран на 18 януари 2012-01-18 14:18 '12 в 14:18 2012-01-18 14:18

Това е много сложен оператор, така че дори ISO / IEC JTC1 (Съвместен технически комитет 1) поставя описанието си в две различни части на стандарта C ++.

Това са два различни оператора: -- и > , описани съответно в раздел 5.2.6 / 2 и в раздел 5.9 на стандарта C ++ 03.

2265
29 окт. отговорът е даден от Кирил В. Лядвински на 29 октомври. 2009-10-29 11:38 '09 в 11:38 ч. 2009-10-29 11:38

Това е еквивалентно на

 while (x-- > 0) 

x-- (след намаляване) е еквивалентно на x = x-1 така че кодът се преобразува в:

 while(x > 0) { x = x-1; // logic } 
1183
29 окт. Отговорът е даден от Jay Riggs на 29 октомври. 2009-10-29 10:00 '09 в 10:00 2009-10-29 10:00

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

)

961
28 дек. отговорът е даден на doc 28 dec. 2014-12-28 03:32 '14 в 3:32 2014-12-28 03:32

Това е така

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

Просто пространство прави нещата забавни, намалява и > сравнява.

513
29 окт. отговорът е даден RageZ 29 окт. 2009-10-29 10:00 '09 в 10:00 2009-10-29 10:00

Използвайте --> има историческо значение. Намаляването е (и все още е в някои случаи) по-бързо от увеличаването на архитектурата x86. Използвайки --> , приемете, че x доближава до 0 и се отнася до тези, които имат математически произход.

380
18 нояб. Отговорът е даден от Matt Joiner на 18 ноември. 2009-11-18 15:47 '09 в 15:47 2009-11-18 15:47
 while( x-- > 0 ) 

как се анализира.

332
29 окт. отговор, даден от Grumdrig 29 октомври. 2009-10-29 10:00 '09 в 10:00 2009-10-29 10:00

Напълно маниак, но ще използвам това:

 #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; } 
310
18 мая '10 в 23:33 2010-05-18 23:33 отговорът е даден от Escualo на 18 май'10 в 23:33 2010-05-18 23:33

Една книга, която прочетох (не си спомням каква е била книгата), заяви: Компилаторите се опитват да анализират изрази в най-големия токен, като използват правилото за ляво-ляво.

В този случай изразът:

 x-->0 

Parsis за най-големите токени:

 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 

Надявам се това да помогне да се разбере сложният израз ^^

291
09 апр. отговорът е даден от NguyenDat 09 Apr 2010-04-09 03:04 '10 в 3:04 2010-04-09 03:04

То е точно същото като

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

за неотрицателни числа

246
31 дек. Отговорът е даден от добрия човек на 31 декември. 2009-12-31 16:48 '10 в 16:48 2009-12-31 16:48

Във всеки случай, сега имаме оператор "идващ". "-->" лесно да се запомни като посока и “докато х изчезва” означава “ясно”.

В допълнение, той е малко по-ефективен от "for (x = 10; x > 0; x --)" на някои платформи.

224
29 окт. отговори даден Тест 29 октомври. 2009-10-29 17:45 '09 в 17:45 2009-10-29 17:45

Този код първо сравнява 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 
206
18 нояб. Отговорът е даден от Sajad Bahmani 18 ноември 2009-11-18 15:52 '09 в 15:52 2009-11-18 15:52

Моят компилатор ще отпечата 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 x-- x .

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

- Това е друг начин да напишеш едно и също нещо.

Хубаво е, че оригиналът изглежда като "докато x отива на 0".

160
17 янв. отговорът е даден cool_me5000 17 януари. 2010-01-17 03:46 '10 в 3:46 2010-01-17 03:46

Между -- и > няма място. x позицията се намалява, т.е. намалява след проверка на условието x>0 ? ,

133
отговорът е даден на г-н 28 дек. X 28 декември 2009-12-28 19:32 '10 в 19:32 2009-12-28 19:32

-- - оператор декремент и > - оператор повече .

Два оператора се прилагат като един, например --> .

124
06 апр. отговори 06 април. 2010-04-06 13:45 '10 в 13:45 2010-04-06 13:45

Това е комбинация от два оператора. Първият -- предназначен да намали стойността и > да провери дали стойността е по-голяма от десния операнд.

 #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 
117
02 апр. Отговор, даден от Rajeev Das 02 Apr. 2013-04-02 14:22 '13 в 14:22 ч. 2013-04-02 14:22

В действителност, x след декремента и това условие се проверява. Това не е --> , то (x--) > 0

Забележка: стойността на x променя след проверка на състоянието, тъй като тя е след декремента. Някои подобни случаи могат да възникнат, например:

 --> x-->0 ++> x++>0 -->= x-->=0 ++>= x++>=0 
112
18 авг. Отговорът е даден от AndroidLearner 18 август. 2012-08-18 10:34 '12 в 10:34 ч. 2012-08-18 10:34

C и C ++ следват правилото за "максимално дъвчене". Точно както --- b се превежда към (a--) - b , в случая x-->0 превежда на (x--)>0 .

Правилото по същество казва, че движението от ляво на дясно, изрази се формират чрез приемане на максимум символи, които ще формират правилния израз.

105
10 февр. Отговорът е даден от Пандрей 10 февруари. 2014-02-10 20:29 '14 в 20:29 2014-02-10 20:29

Защо всички усложнения?

Прост отговор на първоначалния въпрос:

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

Прави същото. Не казвам, че трябва да го направите по този начин, но той прави същото и ще отговори на един въпрос.

x-- е просто кратко описание на горното, и > е просто по-нормално от operator x-- . Няма големи тайни!

В момента има твърде много хора, които правят прости неща;)

23
27 окт. Отговорът е даден Garry_G 27 октомври. 2016-10-27 18:09 '16 в 18:09 часа 2016-10-27 18:09

По обичайния начин определяме условието в скобите на цикъла " () " и условието за прекратяване в къдравите скоби " {} ", но това и > е начинът, по който всеки определя всичко едновременно. Например:

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

Той казва, намалява a и започва цикъла, докато времето a по-голямо от 0

Друг начин трябваше да бъде:

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

в двете посоки правим същото и постигаме същите цели.

20
28 мая '17 в 23:10 2017-05-28 23:10 отговорът е даден Zohaib Ejaz 28 май '17 в 23:10 2017-05-28 23:10

C / C ++ игнорира пространства с условие. По същество, кодът

 while (x --> 0) 

то е същото като

 while (x-- > 0) 

или

 while(x > 0){ x = x - 1 ... 

Използване на пост-декремент в състояние. Да кажем x = 10 . Условият оператор ще бъде 10>0 и printf("%d ", x); операторът в цикъла ще даде 9 при първото пускане. За второто изпълнение условието ще бъде 9>0 и уплътнението ще бъде равно на 8 и така нататък до условие 0>0 .

0
06 сент. отговорът е даден Zirc 06 sep. 2018-09-06 00:20 '18 в 0:20 2018-09-06 00:20

--> е основно едно и също нещо като:

  for(x=10; x<1; ++x) cout<<x 

ще намерите всички числа между x и дадения номер.

-1
Отговор, даден от Алекс. 14 апр. S. Apr 2018-04-14 21:59 '18 в 21:59 ч. 2018-14-14 21:59

Ако трябваше да напишете функция, за да направите обратното, синтаксисът е много по-очевиден, да не говорим, че не мисля, че съм го виждал преди:

  #include <stdio.h> int main() { int x {10}; while (x ++< 20) // x increments to 20 { printf("%d ", x); } } 

резултат:

11 12 13 14 15 16 17 18 19 20

-1
13 июля '18 в 18:34 2018-07-13 18:34 TrevorLee отговори на 13 юли '18 в 18:34 ч. 2018-07-13 18:34

Всъщност → не един оператор. Това е комбинация от два отделни оператора - и>

Да вземем за пример. Докато (x → 0) Това е един конфиденциален израз с едно потвърждение. Тук първото х е декремента с неговата стойност и след това се сравнява с 0.

-4
06 дек. Отговор, даден от Lovekush Vishwakarma Дек 06 2017-12-06 16:45 '17 в 16:45 2017-12-06 16:45

Други въпроси относно маркерите или задаване на въпрос