Что такое оператор «->» в C / C ++?

На самом деле, вы можете "создать" оператор -> просто для удовольствия)

class MyClass {
    class Helper
    {
        MyClass* ptr;
        Helper(MyClass* _this): ptr{_this} {}
    public:
        Helper(const Helper&) = delete;
        Helper(Helper&&) = delete;
        void operator=(const Helper&) = delete;
        void operator=(Helper&&) = delete;
        operator MyClass()
        {
            auto tmp = *ptr;
            tmp._value++;
            return tmp;
        }
        friend MyClass;
        void operator>(int){std::cout << "Operator -->" << std::endl;}
    };

    int _value = 0;
public:
    MyClass() = default;
    MyClass(int value): _value{value} {}
    Helper operator--(int)
    {
        _value--;
        return Helper(this);
    }
    int get() const noexcept
    {
        return _value;
    }
    bool operator>(int num) const noexcept
    {
        return _value > num; 
    }
};

int main()
{
    MyClass obj(5);
    obj > 1;            //operator >
    obj--;              //operator --
    MyClass b = obj--;  //still works
    std::cout << b.get() << std::endl;      //4
    std::cout << obj.get() << std::endl;    //3
    b --> 5;            //operator -->
    //But there is at least one problem
    auto c = obj--;     //auto can deduce a private type :(
}

Но, как я уже сказал, это только для развлечения;)

Вместо обычного оператора стрелки (->) вы можете использовать оператор бронебойной стрелы: --x> (обратите внимание на эти острые зазубрины на кончике стрелки). Он добавляет +1 к пробитию брони, поэтому завершает цикл 1 быстрее, чем обычный стрелок. Попробуйте сами:

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

Вот что вы имеете в виду.

while((x--) > 0)

Мы слышали в детстве,

Стой, не давай, отпусти (روکو مت ، انے دو)

Если запятая вводит в заблуждение

Стой, не отпускай. (روکو ، مت انے دو)

То же самое происходит и в программировании, ПРОБЕЛ вносит путаницу. : D

--> - это не оператор, это сочетание -- (постдекремент) и > (больше, чем сравнение).

Цикл будет выглядеть более знакомым как:

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

Этот цикл является классической идиомой для перечисления значений между 10 (исключенная верхняя граница) и 0 включенной нижней границей, полезной для перебора элементов массива от последнего к первому.

Начальное значение 10 - это общее количество итераций (например, длина массива), плюс одно плюс первое значение, используемое внутри цикла. 0 - это последнее значение x внутри цикла, поэтому комментарий x переходит в 0 .

Обратите внимание, что значение x после завершения цикла равно -1.

Обратите также внимание на то, что этот цикл будет работать таким же способом , если x имеет беззнаковый тип , например size_t, что является сильным преимуществом size_t, что является сильным преимуществом 8372318782 над >.

По этой причине я на самом деле поклонник этого удивительного синтаксиса: while (x --> 0). Я считаю эту идиому привлекательной и элегантной, точно так же, как for (;;) vs: while (1) (которая выглядит сбивающе похожей на while (l)). Он также работает на других языках, синтаксис которых основан на C: C ++, Objective-C, java, javascript, C # и многих других.

Это то же самое, что и

while (x--)

char sep = '\n'  /1\
; int i = 68    /1  \
; while (i  ---      1\
                       \
                       /1/1/1                               /1\
                                                            /1\
                                                            /1\
                                                            /1\
                                                            /1\
                            /           1\
                           /            1 \
                          /             1  \
                         /              1   \
                         /1            /1    \
                          /1          /1      \
                           /1        /1        /1/1> 0) std::cout \
                              <<i<<                               sep;

Для больших чисел в C ++ 20 представлены некоторые более продвинутые функции циклов. Сначала, чтобы поймать i, мы можем построить обратный цикл-де-цикл и отклонить его на std::ostream. Однако скорость i определяется реализацией, поэтому мы можем использовать новый оператор скорости C ++ 20 <<i<<, чтобы ускорить ее. Мы также должны поймать это, построив стену, если мы этого не сделаем, i покинет область видимости, и обращение к ней приведет к неопределенному поведению. Чтобы указать разделитель, мы можем использовать:

 std::cout \
           sep

и у нас есть цикл for от 67 до 1.

Обычным способом мы определяем условие в круглых скобках цикла while «()» и условие завершения внутри фигурных скобок «{}», но этот -- & > - это способ определить все сразу. Например:

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) {
        a = a -1 // Decrement inside loop
        // Code
    }
}

В обоих случаях мы делаем одно и то же и достигаем одинаковых целей.

Почему все сложности?

Простой ответ на исходный вопрос:

#include <stdio.h>

int main()
{
    int x = 10;
    while (x > 0)
    {
        printf("%d ", x);
        x = x-1;
    }
}

Он делает то же самое. Я не говорю, что вы должны делать это так, но он делает то же самое и ответил бы на вопрос в одном посте.

x-- - это просто сокращение для вышеупомянутого, а > просто нормальное значение больше operator. Нет большой загадки!

В наши дни слишком много людей усложняют простые вещи;)

(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

Точно так же вы можете попробовать множество методов для успешного выполнения этой команды.

Этот --> вообще не оператор. У нас есть оператор типа ->, но не типа -->. Это просто неправильная интерпретация while(x-- >0), которая просто означает, что x имеет оператор пост-декремента, и этот цикл будет выполняться до тех пор, пока он не станет больше нуля .

Другой простой способ написать этот код - while(x--). Цикл while будет остановлен всякий раз, когда он получит ложное условие, и здесь есть только один случай, то есть 0. Поэтому он остановится, когда значение x уменьшится до нуля .

Здесь -- - унарный оператор пост декремента.

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

• Вначале условие будет оцениваться как (x > 0) // 10 > 0
• Теперь, поскольку условие истинно, оно войдет в цикл с уменьшенным значением x-- // x = 9
• Вот почему первое напечатанное значение - 9
• И так далее. В последнем цикле x=1, значит условие истинно. Согласно унарному оператору, значение изменилось на x = 0 во время печати. ​​
• Теперь x = 0, который оценивает условие (x > 0 ) как ложное, и цикл while завершается.

Это

#include <stdio.h>

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

Просто пробел делает вещи забавными, -- уменьшает, а > сравнивает.

Это эквивалент

while (x-- > 0)

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

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

Или что-то совсем другое ... x перемещается на 0.

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

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

Это очень сложный оператор, поэтому даже ISO / IEC JTC1 (Объединенный технический комитет 1) разместил его описание в двух разных частях стандарта C ++.

Если шутить, это два разных оператора: -- и >, описанные соответственно в §5.2.6 / 2 и §5.9 стандарта C ++ 03.

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

;)

Этот код сначала сравнивает 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

Это комбинация двух операторов. Первый -- предназначен для уменьшения значения, а > предназначен для проверки того, больше ли значение правого операнда.

#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            

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

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

- это другой способ записать одно и то же.

Приятно, что оригинал выглядит как «пока x идет в 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

Надеюсь, это поможет понять сложное выражение ^^

C и C ++ подчиняются правилу «максимального количества еды». Таким же образом a --- b переводится в (a--) - b, в вашем случае x-->0 преобразуется в (x--)>0.

По сути, правило гласит, что при движении слева направо выражения формируются путем взятия максимального количества символов, которые образуют допустимое выражение.

Фактически, x является постдекрементным и с этим условием проверяется. Это не -->, это (x--) > 0

Примечание: значение x изменяется после проверки условия, потому что оно пост-декремент. Возможны и подобные случаи, например:

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

Так или иначе, у нас есть оператор "переходит к". "-->" легко запомнить как направление, а «пока x стремится к нулю» означает прямое.

Кроме того, на некоторых платформах он немного более эффективен, чем "for (x = 10; x > 0; x --)".

Совершенно чудаковатый, но я буду использовать это:

#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 пост-декрементируется, то есть уменьшается после проверки условия x>0 ?.

while( x-- > 0 )

вот как это разбирается.

Использование --> имеет историческое значение. Уменьшение было (и остается в некоторых случаях) быстрее, чем приращение на архитектуре x86. Использование --> предполагает, что x собирается на 0, и обращается к тем, кто имеет математическое образование.