Почему точки с запятой и запятые меняются местами в циклах?

На многих языках (широкий список, от C до JavaScript):

• запятые ,отдельные аргументы (например func(a, b, c)), в то время как
• точки с запятой ;разделяют последовательные инструкции (например instruction1; instruction2; instruction3).

Так почему же это отображение в тех же языках для циклов for :

for ( init1, init2; condition; inc1, inc2 )
{
    instruction1;
    instruction2;
}

вместо (что кажется мне более естественным)

for ( init1; init2, condition, inc1; inc2 )
{
    instruction1;
    instruction2;
}

?

Конечно, forэто ( как правило) не функция, но аргументы (то есть init, condition, increment) ведут себя скорее как аргументы функции , чем последовательность инструкций.

Это связано с историческими причинами / соглашением, или есть хорошее обоснование для обмена ,и ;в циклах?

Так почему же на тех же языках такое отображение для циклов наоборот?

Технически, отображение не «обратное».

• Вещи, разделенные запятыми, не являются параметрами. В (по крайней мере) C ++ и Java они могут быть объявлениями, поэтому они даже не являются выражениями.
• Вещи, разделенные точкой с запятой, также не являются (одиночными) утверждениями.

В действительности у нас есть другой синтаксический контекст, в котором одни и те же символы используются по-разному. Мы не сравниваем подобное с подобным, поэтому нет сопоставления и нет веских аргументов в пользу согласованного сопоставления, основанного на семантической согласованности.

Так почему бы не сделать это наоборот?

Ну, я думаю, что причины происходят от "естественного" значения ,и ;. В английском письменном языке точка с запятой является «более сильным» разрывом, чем запятая, а символ точки с запятой более заметен, чем запятая. Эти две вещи объединяются, чтобы сделать текущую аранжировку (для меня!) Более естественной.

Но единственный способ точно узнать, почему был сделан выбор синтаксиса, - это если бы разработчики C могли рассказать нам, что они думали в 1970 году. Я сомневаюсь, что у них есть четкая память о технических решениях, принятых так давно.

Это из-за исторических причин / соглашения

Я не знаю ни одного языка до C, который использовал C-подобный синтаксис для циклов for:

• Донал Феллоуз отмечает, что BCPL и B не имели эквивалентной конструкции.

• Эквиваленты FORTRAN, COBOL и Algol-60 (и Pascal) были менее выразительными и имели синтаксисы, которые не напоминали синтаксис «для» C.

Но такие языки, как C, C ++ и Java, появившиеся после C, явно заимствуют свой синтаксис "for" из C.

Мы пишем циклы как:

 for(x = 0; x < 10; x++)

Язык можно было бы определить так, чтобы циклы выглядели так:

 for(x = 0, x < 10, x++)

Однако подумайте о том же цикле, реализованном с использованием цикла while:

 x = 0;
 while(x < 10)
 {
     x++;
 }

Обратите внимание, что операторы x=0и x++являются окончанием точкой с запятой. Они не являются выражениями, как вы бы при вызове функции. Точки с запятой используются для разделения операторов, и поскольку два из трех элементов в цикле for являются операторами, это то, что используется там. Цикл for - это просто ярлык для такого цикла while.

Кроме того, аргументы не действуют как аргументы функции. Второе и третье оцениваются неоднократно. Это правда, что они не являются последовательностью, но они также не являются аргументами функций.

Кроме того, тот факт, что вы можете использовать запятые для нескольких операторов в цикле for, - это то, что вы можете делать вне цикла for.

x = 0, y= 3;

является совершенно допустимым утверждением даже вне цикла for. Я не знаю ни одного практического использования вне цикла for. Но дело в том, что запятые всегда делят утверждения; это не особенность цикла for.

В C и C ++ это оператор запятой, а не просто запятая.

Грамматика для forцикла это что-то вроде

for ([pre-expression]; [terminate-condition]; [increment-expression]) body-expression

В случае вашего вопроса:

pre-expression -> init1, init2
terminate-condition -> condition
increment-expression -> inc1, inc2

Обратите внимание, что оператор запятой позволяет вам выполнять несколько действий в одном выражении (как это видит компилятор). Если бы ваше предложение было реализовано, в грамматике была бы неоднозначность относительно того, когда программист намеревался написать оператор запятой или разделитель.

Короче говоря, ;означает конец утверждения. forЦикл является ключевым словом , за которым следует список дополнительных заявлений в окружении (). Оператор запятой-оператора позволяет использовать ,в одном операторе.

Там нет концептуального обращения.

Точки с запятой в C представляют собой более крупные деления, чем запятые. Они разделяют заявления и декларации.

Основным делением в цикле for является то, что есть три выражения (или объявление и два выражения) и тело.

Запятые, которые вы видите в C для циклов for, не являются частью синтаксиса цикла for. Они просто проявления оператора запятой.

Запятые являются основными разделителями между аргументами в вызовах функций и между параметрами в объявлениях функций, но точки с запятой не используются. Цикл for - это специальный синтаксис; это не имеет ничего общего с функциями или вызовами функций.

Может быть, это что-то особенное для C / C ++, но я публикую этот ответ, потому что синтаксис описанных вами языков в основном зависит от C-синтаксиса.

Кроме того, ранее отвеченные вопросы верны, с технической точки зрения, это также потому, что в C (и C ++) запятая на самом деле является оператором , который вы можете даже перегружать . Использование точки с запятой-оператора ( operator;()) может затруднить написание компиляторов, поскольку точка с запятой - это терминатор аксиоматического выражения.

Интересным является тот факт, что запятая широко используется в качестве разделителя во всем языке. Кажется, что оператор запятой является исключением, который в основном используется для получения for-loops с несколькими работающими условиями, так в чем же дело?

Фактически, operator,он создан для того же, что и в определениях, списках аргументов и т. Д. Он был создан для разделения выражений - то, что синтаксическая конструкция ,не может сделать. Он может отделять только то, что определено в стандарте.

Однако точка с запятой не разделяется - она заканчивается . И это также то, что возвращает нас к первоначальному вопросу:

for (int a = 0, float b = 0.0f; a < 100 && b < 100.0f; a++, b += 1.0f)
    printf("%d: %f", a, b);

Запятая разделяет выражения в трех частях цикла, тогда как точка с запятой завершает часть (инициализация, условие или запоздалая мысль) определения цикла.

Более новые языки программирования (такие как C #) могут не допускать перегрузки оператора запятой, но они, скорее всего, сохранили синтаксис, потому что его изменение кажется неестественным.

Для меня они используются более менее похожим по смыслу своим языковым смыслом. Запятые используются со списками и точками с запятой с несколькими отдельными частями.

У func(a, b, c)нас есть список аргументов.

instruction1; instruction2; instruction3 это может быть список, но список отдельных и независимых инструкций.

В то время как у for ( init1, init2; condition; inc1, inc2 )нас есть три отдельные части - список инициализаций, условие и список выражений приращения.

Самый простой способ увидеть это:

for(x = 0; x < 10; x++)

является:

for(
x = 0;
x < 10;
x++
)

Другими словами, эти x = 0 вещь на самом деле является оператором / инструкциями, а не параметром. Вы вставляете туда заявление. Следовательно, они разделяются точкой с запятой.

На самом деле нет никакого способа, которым они разделяются запятой. Когда в последний раз вы вставляете такие вещи, как х <10 в качестве параметра? Вы делаете это, если хотите, чтобы компьютер x <10 один раз, и вставляете результат этой операции в качестве параметра. Так что в мире запятых вы бы поставили x <10, если хотите передать значение x <0 в функцию.

Здесь вы указываете, что программа должна проверять x <10 каждый раз, когда проходит цикл. Так что это инструкция.

х ++ это определенно другая инструкция.

Это все инструкции. Поэтому они разделены точкой с запятой.