Каким должен быть язык программирования? Анализ и критика Описание языка Компилятор
Отечественные разработки Cтатьи на компьютерные темы Компьютерный юмор Прочее

Циклы

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

  • Универсальный:
    for (int i=0; i < lenght; i++)
    {	// тело цикла
    }
    
  • Универсальный в BASIC-стиле:
    FOR I=1 TO LENGHT STEP 1
       // тело цикла
    NEXT
    
  • Цикл «пока»:
    while (условие)
    {	// тело цикла
    }
    
  • Цикл с проверкой в конце:
    do
    {	// тело цикла
    } while (условие)
    
  • Цикл «for each»:
    for each (некое множество)
    {	// тело цикла
    }
    
        С одной стороны, программисты хотят иметь удобные циклы на все случаи жизни, что поощряет их разнообразие в языках программирования. С другой стороны, существует универсальный оператор цикла, который может заменить собой многие из этих циклов. Он же универсален! Интересный взляд на циклы можно обнаружить в статье Андрея Андреева.

        Надо заметить, что мысли о большей роли универсального цикла имеет под собой прочные и обосноснованные аргументы. Именно поэтому не стоило перечислять все виды циклов в начале статьи. Мы должны придумать такой оператор цикла, который действительно позволит заменить собой все остальные. Можно заметить, что универсальный оператор цикла C/C++ имеет недостаток. С его помощью нельзя проверить условие в конце цикла. Это проблему надо решить.

        Для начала рассмотрим подробнее устройство цикла в C/C++:
универсальный цикл в C и C++
        Действия, выполняемые в цикле, графически можно изобразить так:
Схема действий в цикле с проверкой вверху


        «Допиливаем» этот оператор, за основу берём придуманный нами «симметричный скобочный» стиль. Си-шный стиль меняем на свой:
(for int i=0; i < lenght; i++
	// тело цикла         )
        А потом пристально его рассмотрим. В универсальном цикле после ключего слова идут выражения, инициализирующие цикл. Количество этих выражений может быть равным нулю, единице и больше. Далее — условие продолжения цикла. Количество условий — ноль или единица. Далее — выражения, выполняющиеся в конце цикла. Количество этих выражений — нуль, единица и больше.

        Первым делом в этом цикле хочется заменить ключевое слово «for» («для»). Для программ, которые пишутся на русском языке, самое уместное ключевое слово — это слово «цикл». Просто называем вещи своими именами. Что наиболее подходит для английского языка? В языке Ada используют ключевое слово «loop» («петля»). Не знаю, почему там не прижилось «cycle».

        Далее перемещаем это ключевое слово и размещаем между выражениями инициализации цикла и условием продолжения цикла. Ведь так гораздо логичнее. Ведь первым выражением, которое циклически выполняется, является проверка условия. Инициализация же выполняется лишь одиножды. Как ещё объявить и инициализировать переменые, область видимости которых ограничена рамками цикла? Помещая ключевое слово после этой инициализации, мы подчеркиваем роль кода перед этим словом и после его.

        Ну и третий момент — заменяет «i++» на «++i» по причинам, которые объясняются в другой статье. В итоге получаем:
(int i=0 loop i < lenght; ++i
	// тело цикла         )
        Или в более общем виде:
(инициализирующие выражения loop условие; выражения в конце цикла
	// тело цикла         )
        Изобразим это графически:
цикл с проверкой вверху
        Суть этого цикла та же, что и в Си. Отличаются они лишь синтаксисом, внешним видом, семантика на 100% та же. Наша гипотетическая среда разработки могла бы отобразить это так:

(       int i=0 loop  i < L;  ++i  
  // ...  
 
(       int j=0  loop  j < M; ++j  
  // ...  
 
(       int k=0  loop  k < N; ++k  
  // ... )

            А как должен выглядеть цикл «пока»? От универсального цикла его отличает отсутствие инициализирующих выражений и выражений, которые выполняются в конце цикла. В C/C++ такое «обрезание» универсального цикла выглядит так:
for (;условие;)
            Этой кошке можно отрезать хвост по частям до полного его исчезновения:
for (инициализирующ.выр-я; условие; выр-я в конце цикла) // исходный вид
for (; условие; выражения в конце цикла)                 // нет инициализации
for (инициализирующ.выр-я;; выр-я в конце цикла)         // нет условия
for (инициализирующ.выр-я; условие;)                     // нет выр-й в конце
for (инициализирующ.выр-я;;)                             // только инициализация
for (; условие;)                                         // подобен while(условие)
for (;; выр-я в конце цикла)                             // только выр-я в конце
for (;;)                                                 // вообще пусто
        А теперь то же, но в «симметричном скобочном» стиле:

(       инициализирующ.выр-я loop условие; выр-я в конце цикла  
  // ...  
 
(       loop условие; выр-я в конце цикла  
  // ...  
 
(       инициализирующ.выр-я loop ; выр-я в конце цикла  
  // ...
(       инициализирующ.выр-я loop условие;  
  // ... )
)

(       инициализирующ.выр-я loop ;  
  // ...  
 
(       loop условие;  
  // ...  
 
(       loop ; выр-я в конце цикла  
  // ...
(       loop ;  
  // ... )
)

            Гибкость — не меньшая, чем в C/C++, но при большей лаконичности. Это гибкость — ещё и в том, что мы собираемся применять этот цикл вместо того, что называют «циклом с проверкой в конце». Чем отличается цикл «do {тело цикла} while (условие)» от цикла «while (условие) {тело цикла}»? Да тем, что во втором случае решение о продолжении цикла принимается в конце цикла, а впервом случае — в начале. Об этом нам недвусмысленно говорит фраза «while (условие)»: если она стоит вначале, то и проверка вначале. Если в конце, то и проверка в конце.

            Универсальный же цикл «for (выражения инициализации; условие; выражения в конце цикла» не похож на циклы «while» и «do while» тем, что содержит выражения, нарушающие порядок «слева направо, сверху вниз». Если считать этот вид цикла некой функций с тремя операндами, то третий операнд (выражения в конце цикла) выбивается из общего ряда. Эта особенность привычна программистам и ни у кого не вызывает отторжения.

            Наша идея состоит в том, чтобы переместив строку с «операндами» цикла в конец, заставить его работать как цикл «do {тело цикла} while (условие)»:
(  // тело цикла
   инициализирующ.выр-я loop условие; выр-я в конце цикла)
            Графически это можно изобразить так:
цикл с проверкой вверху
            Ниже — действия, которые в этом цикле выполняются:
Схема действий в цикле с проверкой внизу
            Непривычно? Только на первый взгляд. Это всё тот же универсальный цикл, вот только условие теперь проверяется не в начале, а в конце. А вот первый «операнд» (инициализирующие выражения) выполняется единожды перед тела выполнением цикла — как обычно. И третий операнд выполняется как обычно в конце. Так что такие циклы не вызовут аллергии у программистов. А среда разработки поможет своей графикой разобраться, где мухи, а где котлеты:

( // тело цикла
(    
  // ...  
 
( // ...
( // ...  
      loop ; )
 
  // ...  
      loop ; выр-я в конце цикла )
 
  // ...  
        инициализирующ.выр-я loop условие; выр-я в конце цикла )
 
  // ...  
        инициализирующ.выр-я loop условие; выр-я в конце цикла )


            Получился вполне себе симпатичный цикл с проверкой внизу. Если не ограничивать свою фантазию, можно сделать аналогичный цикл с проверкой условия в средине! Вот такой:
цикл с проверкой в средине цикла
            А это — действия в нём:
Схема действий в цикле с проверкой в средине
            Среда разработки покажет программисту примерно такое:

( // тело цикла
(    
  // вложенный цикл с проверкой условия в средине  
   
        инициализирующ.выр-я loop условие; выр-я в конце цикла  
  // продолжение тела вложенного цикла )
 
  // ...  
        инициализирующ.выр-я loop условие; выр-я в конце цикла  
  // ...  
  // продолжение тела цикла )


            Зачем это надо? Так ведь нередки циклы, где проверка условия выхода проверяется где-то внутри цикла. Допусти, так:
for (;;)
{     // тело цикла
     if (условие)
        break;
     // продолжение тела цикла
}
            Мы же, перемещая строку с описанием цикла в средину, позволить сэкономить на операторе «if». Так что нами описан не только рабочий, но и интересный вариант. Выгоды от применения от такого цикла очевидна: его параметры записываются унифицированным способом. Меняется только место проверки условия, которое совпадает с положением управляющей строки цикла. А какие проблемы могут от этого возникнуть?
  • Непривычная для программистов вид цикла, когда он употреблён в конце или средине.
  • Усложнение компилятора. Ему надо будет научиться находить ключевое слово «loop» в самых разных местах цикла. Компилятор должен будет «заглядывать» далеко вперёд в поисках «loop»:
    (
        // куча операторов
        // ..
       ... loop  ... )
    
            Всё ли описано? Нет, ещё предстоит рассмотреть цикл «для каждого» («for each»), а так же операторы «продолжение цикла» и «выход из цикла».

Цикл «для каждого»

        Этот вид циклов описывает циклически выполняющиеся действия для каждого элемента некого множества. Почему этот цикл отсутствует в C/C++? На это есть несколько причин. Они касаются особенно C, потому что в C++ появились некоторые «костыли», которые позволяют в некоторых случаях заиметь в своём распоряжении «for each».
  • Во-первых, в C нет такой абстракции, как «множество». В языке нет возможности передать некий объект, не заботясь о его сущности. Массив ли это, список, стек или дерево — как язык поможет определить конкретный вид множества, если, к примеру, указатель на него был передан в функцию?
  • Во-вторых, как определить количество элементов в этом множестве?
  • В-третьих, каким образом перебрать все элементы этого множества?
            От этих вопросов нельзя отмахнуться, как от несущественных. Но они связаны м понятием множества, которые мы ещё не рассмотрели. Поэтому этот вид цикла рассмотрим позже, в статье о цикле «для каждого» («for each»).

            P.S. Ответ на комментарий Михаила. Позвольте процитировать Википедию: «Цикл Дейкстры удобен при реализации некоторых специфических повторяющихся вычислений». Конструкции, которыми можно применять во всех ситуациях или их большинстве предпочтительнее тех, которые решают специфичные задачи. Особенно если первые просты и наглядны. Цикл
for (инициализация; проверка условия в начале; действия в конце цикла)
{ тело цикла}
легко меняется на цикл
(инициализация loop проверка условия в начале; действия в конце цикла
  тело цикла)
Цикл
while do (проверка условия в начале)
{ тело цикла}
соответственно меняется на цикл
(loop проверка условия в начале
  тело цикла)
Цикл
repeat until (проверка условия в конце)
{ тело цикла}
соответственно меняется на цикл
( тело цикла
loop проверка условия в конце)
В итоге имеем цикл, который, будучи универсальным, не становится громоздким. Всё просто и элегантно. При этом циклы могут досрочно прерываться, для этого имеются конструкции, которые перекрывают все потребности.

            «Цикл-паук» всё же очень громоздок. Некрасиво. Кажется неслучайным, что он не воплощён в каком-либо языке программирования.

Что ещё почитать на эту тему

Последняя правка: 2015-01-23    06:31

ОценитеОценки посетителей
   ██████████████ 1 (33.3%)
   ██████████████ 1 (33.3%)
   ██████████████ 1 (33.3%)
   ▌ 0

Отзывы

     2013/04/14 10:25, Михаил

Неудачная идея, сделать один универсальный цикл. Лучше несколько разных циклов с разной семантической нагрузкой. Например так:

циклы с одной точкой выхода
for (фиксированное число повторений)
while do (цикл с предусловием)
repeat until (цикл с постусловием)

циклы с несколькими точками выхода
loop ... exit ... exit ... end; (бесконечный цикл + оператор его прерывания)
цикл паук, цикл дейкстры и пр.

     2013/04/14 13:29, Автор сайта

Ответ читайте выше.

     2013/04/18 20:13, Михаил

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

     2013/04/19 13:45, Автор сайта

Вопрос и ответ перенес в ветку по теме: Синтаксический сахар

     2013/04/18 20:22, Михаил

Вы, фактически, повторили решение для языка С.
Цикла с фиксированным числом итераций у Вас нет.
Досрочно прерывать циклы с фиксированным числом повторений, пред- и постусловием считаю не правильным. Для прерываемого цикла должна быть отдельная конструкция, например бесконечный цикл.

     2013/04/19 14:07, Автор сайта

Повторили решение Си авторы C++, C#, Java, Perl, PHP, D, Cyclone, Rust и многих других. Я же творчески переработал. Переместил ключевое слово внутри «параметров» цикла, предложил использовать его не только в начале цикла, но и в конце и даже в средине. Т.е. это ещё большая универсализация.

Цикл с фиксированным числом повторений есть:
( i=0 loop i < 100; ++i
тело цикла)
Этот цикл выполнится фиксированное число раз, а именно 100.

Отдельная конструкция с прерываемым циклом не нужна. Если универсальный цикл записать так:
(loop
    (if a>b
          exit)
тело цикла)

То это выглядит так, как Вы этого хотите. Желаемая цель достигается.

А зачем бороться с «break» и «continue»? Ведь это не «goto»! Более того, отказ от «break» как провоцирует употребление «goto».

     2013/04/23 11:45, Михаил

Пусть так, но зачем повторять не очень удачное решение примененное в Си? Вы ведь не хотите повторять составной оператор, которой применен в Си, С++, С# и т.д.

Это цикл while с помощью которого вы сделали цикл с фиксированным повторением. Представьте что на месте выражения i<100 стоит некоторое сложное выражение, причем функции, входящие в него, могут иметь побочный эффект. Выражение у Вас будет вычисляться на каждой итерации, а у цикла с фиксированным числом повторений это не так, число повторений вычисляется только один раз.

Желаемой цели (реализации алгоритма) можно достичь с помощью всего двух операторов: if и goto. Я же о семантике. Ваш вариант не обеспечивает фиксированной семантики для конструкции, что затрудняет её понимание.

continue очень вредный и ненужный оператор, лучше использовать if для обхода.
break вполне допустим, но не везде. Можно разрешить его использование внутри только прерываемого цикла, тоже самое касается и goto. Это не нарушит семантики.

Если по алгоритму Вам нужен цикл наиболее общего вида, то его и используйте, а не вводите в заблуждение других людей используя для этого специализированные циклы вроде while do или do while.

     2013/04/25 11:58, Автор сайта

«break» и «continue» помогают исключить из языка «goto», вред которого теоретически доказан. Не могли бы Вы дать ссылку на авторитетные источники, где обоснован вред «continue»?

С помощью «if» можно обойтись без «continue». Но заменить «continue N» сложнее, появятся лишние операторы.

«break» не предлагается к использованию в других местах, кроме циклов. В операторе «switch» его предлагается исключить, т.к. он провоцирует появление «спагетти-кода».

В Паскале цикл с фиксированным числом повторений выглядит так:

for V:= E1 to E2 do S, где E1 и E2 – выражения, которые могут иметь побочные эффекты.

Чтобы избежать побочного эффекта при каждой итерации, нужно просто E2 вычислить однократно до начала цикла. В C++ это можно сделать так:

for (int i=E1, int N=E2; i<=N; ++i) S;.

Если E2 – константа или переменная, то побочных эффектов не будет. Но это частный случай. Но стоит ли делать 2 цикла,

for V:= CV1 to CV2 do S, где CV1 и CV2 – константа или переменная, и
for V:= E1 to E2 do S, где E1 и E2 – выражения?

Вам известны языки программирования, грамматика которых запрещала бы использование выражений для задания числа повторенний?

     2014/01/16 11:20, Pensulo

Теоретически, инициализатор можно вынести за скобки самого цикла (выполнить инициализацию переменных задействованных в самом цикле перед начальной конструкцией цикла).
Сам цикл действительно напоминает замкнутую петлю (loop) бесконечно выполняемого блока действий из которой (петли) есть возможность выйти принудительно, приняв решение об этом где-то внутри самого цикла. Анализ необходимости выхода можно при этом проводить в любом месте и сколько угодно раз, т.е. и в начале и в середине и в конце блока вычислений цикла.
Тогда конструкция циклического исполнения программного блока могла бы выглядеть, например, следующим образом:

  <инициализация_цикла>
(loop
  if пред_условие leave
    <часть_тела_цикла_1>
  if сред_условие levae
    <часть_тела_цикла_2>
  if пост_условие leave
)

Где leave по-сути тот же самый exit, что и в ваших примерах, но тогда сохраняется возможность осуществлять досрочный выход из функции с помощью служебного слова exit.
Размещать анализаторы выхода if .. leave можно в любом месте внутри циклических скобок (loop .. ) и в любом количестве.

А вот с предоставлением возможности выхода из объемлющего цикла, морально ОЧЕНЬ трудно согласиться.

     2014/01/16 12:15, Автор сайта

А зачем инициализатор выносить за скобки цикла? В том то вся выгода, что вся конструкция цикла (впрочем – любая конструкция) находится внутри скобок. Мы что инициализируем, переменные цикла? Значит это надо сделать внутри конструкции цикла. Но это не значит, что до открывающей скобки ничего нельзя делать. Просто находящийся внутри скобок инициализатор подчеркивает, что он относится именно к циклу.

А какая альтернатива выходу из объемлющего цикла? Только «goto». Поэтому «exit 2» можно читать как «goto label2». Только первый способ короче.

     2014/04/23 02:40, 85.192.188.252

Тогда конструкция циклического исполнения программного блока могла бы выглядеть, например, следующим образом:
<инициализация_цикла>
(loop
if пред_условие leave
<часть_тела_цикла_1>
if сред_условие leave
<часть_тела_цикла_2>
if пост_условие leave
)
Такой цикл уже придуман в Scheme (диалект Lisp'а). Аналогично там есть сложный составной условный оператор.

     2015/05/27 08:25, Алексей Яковлев

А не будет loop теряться в коде, если он в середине или в конце?
И еще, как отделить инициализацию от тела цикла, если loop опять же в середине или конце?

     2015/05/27 15:15, Автор сайта

IDE должна выделять ключевые слова: его символы должны быть жирными, иметь другой цвет. Можно поставить перед «loop» пиктрограмму. Блок, из которого состоит цикл, можно обрамлять специальной рамкой. Много способов обратить внимание на то, что это цикл.
Инициализирующие выражения располагаются на той же строке, что и ключевое слово и стоят перед ним – что в начале, что в средине, что в конце цикла. В дополнение к этому IDE должна его как-то выделять.

     2016/03/25 06:43, rst256

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

«640 килобайт хватит всем» http://lurkmore.to/640_килобайт
Конструкции, которые априори перекрывают все потребности, — это if-goto, но его давно репрессировали (кстати, почему он тогда не пропадает, а наоборот возникает там, где его раньше небыло? Например в lua(с v.5.3), php(хотя пеха ладно,это не язык)).
if-goto[1] - самый гибкий, у него 3 степени свободы (условие, позиция в коде, адрес перехода);
циклы while/repeat - 1 (условие);
с проверкой "в середине" (при условии что середина — это также начало с концом) - 2 (условие, позиция)

Последний вариант и правда "самый"[1] гибкий, хороший цикл с итераторами годен к употреблению.

     2016/08/22 17:33, xDDGx

Идея, конечно, интересная, но синтаксис ужасен:
(int i=0 loop i < lenght; ++i
...
)
Чем это хуже традиционного for?
for(int i; i<length; ++i){
...
}
Во-первых, ключевое слово for стоит первым — оно сразу бросается в глаза, мы сразу понимаем, что перед нами цикл, а не что-то другое. То же касается while и do-while (ключевое слово do используется только в этой конструкции, так что мы сразу понимаем, что перед нами цикл do-while, а не что-то другое). В вашем варианте всё смешалось — слово loop может стоять в середине строки, а то и вовсе в конце всего блока или даже где-то в его середине.

Аргумент "с этим поможет ИДЕ" на данном этапе несерьёзен. Обычно сперва появляется язык (компилятор — а это уже громадный объём работы), затем — средства разработки, а не наоборот. К тому же, далеко не все и не всегда используют продвинутые ИДЕ, и, в принципе, программа, написанная на ЯП, близком к идеалу, должна быть читаемой и понятной в самом примитивном виде — в виде простого текста. Текущий синтаксис loop вредит читаемости.

Во-вторых, традиционный цикл for хорош тем, что мы сразу видим, где находятся параметры цикла, а где — его тело, нет неоднозначности. Всё единообразно — каждый параметр отделяется от другого точкой с запятой, выражения в списках — запятой. Вы сами приводили примеры в стиле "Мама зпт я хочу есть воскл Мы скоро пойдём домой вопр", доказывая необходимость "знаков препинания" в тексте программы, и сами же нарушили этот принцип. В (int i=0 loop i < lenght; ++i) мы видим, что после инициализирующего выражения (а если их несколько? как они отделяются друг от друга?) через пробел идёт ключевое слово loop, затем через пробел условие, а затем, через точку с запятой — действия конца итерации (и опять-таки, а если нам нужно в этом месте несколько выражений?).
Как мы (или даже компилятор), в данной конструкции можем однозначно понять, что является выражением (-ями) инициализации, что — условием, что — действиями в конце?
(
int i=0 loop i<length
++i
...
)
Правильно ли я понимаю, что такая конструкция будет аналогична самой первой? А такая?
(
int i=0
loop i<length
++i
...
)
А это — будет ли правильным циклом с двумя телами?
(
...
int i=0
loop i<length
++i
...
)
Как компилятор или человек разберётся, где начинаются (заканчиваются) блоки инициализации, условия и т. д.? В то же время, C/C++ позволяет нам написать, например, такое:
for(
int a=1,
b=0;
a<argc;
++a,
b+=2
){
...
}
Это может пригодиться в случае больших списков или сложных условий для улучшения читаемости.

Повторюсь: идея интересная, но я сомневаюсь, что многим понравится такой синтаксис. И я не думаю, что это принципиально, один у нас цикл или их несколько. Типовые сценарии использования всё равно придётся запоминать. Со своей стороны могу предложить такой синтаксис. Прямой аналог цикла for:
(loop (int i=0) i<length (++i)
...
)
Скобки обязательны. Если какие-то поля не нужны, просто оставляем их пустыми:
(loop () ()
...
)
Аналог цикла с двумя телами:
(do
...
loop (int i=0) i<length (++i)
...
)
Если второе тело (после строки с loop) не нужно, просто оставляем его пустым (получится продвинутый аналог цикла do-while, "do-for" так сказать. Мои варианты, конечно, тоже далеки от идеала, особенно последний, но, по крайней мере, мы будем уверены, что раз есть do — где-то должен быть loop.

Написать отзыв

Написать автору можно на электронную почту mail(аt)compiler.su

Авторизация

Регистрация

Выслать пароль

Карта сайта


Каким должен быть язык программирования?

Анализ и критика

Устарел ли текст как форма представления программы

Русский язык и программирование

Многоязыковое программирование

Синтаксис языков программирования

Синтаксический сахар

Некоторые «вкусности» Алгол-68

«Двухмерный» синтаксис Python

Почему языки с синтаксисом Си популярнее языков с синтаксисом Паскаля?

Должна ли программа быть удобочитаемой?

Стиль языка программирования

Тексто-графическое представление программы

●  Разделители

●  Строки программы

●  Слева направо или справа налево?

Комментарии

●  Длинные комментарии

●  Короткие комментарии

●  Комментарии автоматической генерации документации

●  Нерабочий код

Нужны ли беззнаковые целые?

Шестнадцатиричные и двоичные константы

Условные операторы

Переключатель

Циклы

●  Продолжение цикла и выход из него

Некошерный «goto»

Операции присвоения и проверки на равенство. Возможно ли однаковое обозначение?

Так ли нужны операции «&&», «||» и «^^»?

Постфиксные инкремент и декремент

Почему в PHP для конкатенации строк используется «.»?

Указатели и ссылки в C++

Использование памяти

Почему динамическое распределение памяти – это плохо

Как обеспечить возврат функциями объектов переменной длины?

●  Типы переменного размера (dynamically sized types, DST) в языке Rust

●  Массивы переменной длины в C/C++

●  Размещение объектов в стеке, традиционный подход

●  Размещение объектов переменной длины с использованием множества стеков

●  Размещение объектов переменной длины с использованием двух стеков

●  Реализация двухстековой модели размещения данных

●  Двухстековая модель: тесты на скорость

●  Размещение объектов переменной длины с использованием одного стека

Можно ли забыть о «куче», если объекты переменной длины хранить в стеке

Безопасность и размещение объектов переменной длины в стеке

Массивы, структуры, типы, классы переменной длины

О хранении данных в стеке, вместо заключения

Описание языка

Компилятор

Отечественные разработки

Cтатьи на компьютерные темы

Компьютерный юмор

Прочее

Последние комментарии

2018/04/16 15:09, Олег
Русский язык и программирование

2018/04/02 22:42, rst256
Программирование без программистов — это медицина без врачей

2018/03/25 21:14, Денис Будяк
Энтузиасты-разработчики компиляторов и их проекты

2018/03/21 23:37, Marat
Почему обречён язык Форт

2018/03/10 20:05, Comdiv
«Двухмерный» синтаксис Python

2018/02/24 14:51, Эникейщик
Русской операционной системой должна стать ReactOS

2017/12/12 13:32, Comdiv
Отечественные разработки

2017/11/05 17:26, rst256
Электроника без электронщиков