Re[6]: готофобам к размышлению - Компьютерные священные войны

Здравствуйте, Erop, Вы писали:

E>Здравствуйте, Сыроежка, Вы писали:

С>>На С это облегчает жизнь лишь тем, кто не умеет писать программы, то есть идут по пути наименьшего сопротивления: мол, зачем думать, когда я могу вставить goto.

E>Именно эти люди и писали винду оба раза

На самом деле трудно сказать, какие люди писали, и какие люди пишут сейчас. Проект огромный и за это время сменилось уже очень много программистов, участвующих в проекте.
Как здесь правильно было замечано, старый код меняют лишь в крайнекй необходимости, коогда это вынуждено. То есть либо когда надо внести изменения в код в связи с новой функциональностью, либо когда найден баг. Кроме того, как я уже заметил, это могут быть комментарии. То есть у каждой функции стоит преамбула в виде ее описания, где могут использоваться для простоты работы алгоритма слова goto.
А самое главное — не надо наивно думать, что в софтверных фирмах работают высококвалифицированные программисты. Высококвалифицированные программисты — это небольшая прослойка. А в основном в проектах участвуют, как я их называю, пофигисты, которые пишут по принципу "тяп-ляп" — лишь бы работало.

Здравствуйте, Константин, Вы писали:

К>Думаю, измерения были бы намного интересней, если узнать

К>- Относительное количество goto к объемам исходников
К>- статистику отдельно для c/c++

сделал более детальное фильтрование

nt4 sources

$ grep -r --include=*.c -P 'goto (.+);' "C:/nt4"
result: 42538 goto

$ grep -r --include=*.{cpp,cxx,cc} -P 'goto (.+);' "C:/nt4"
result: 8236 goto

win2k sources

$ grep -r --include=*.c -P 'goto (.+);' "C:/win2k"
result: 16523 goto

$ grep -r --include=*.{cpp,cxx,cc} -P 'goto (.+);' "C:/win2k"
result: 23022 goto

Здравствуйте, jyuyjiyuijyu, Вы писали:
J>вывод ? goto сила
А то. Очень хороший способ подчищать за собой в отсутствии try/finally или raii. Вот типа того:

aquire resource

do something
if error goto release

do something else

release:
  release resource

Здравствуйте, jyuyjiyuijyu, Вы писали:

J>сделал более детальное фильтрование

тогда уже

-P 'goto +[_0-9a-zA-Z_]+;'

Здравствуйте, Mr.Cat, Вы писали:

MC>Здравствуйте, jyuyjiyuijyu, Вы писали:
J>>вывод ? goto сила
MC>А то. Очень хороший способ подчищать за собой в отсутствии try/finally или raii. Вот типа того:
MC>

MC>aquire resource

MC>do something
MC>if error goto release

MC>do something else

MC>release:
MC>  release resource
MC>

Это как раз пример того, что сттрого-настрого надо запрещать в коде!
Давайте рассмотрим ваше код.

do something
if error goto release

Обычно в начале каждой функции происходят различные проверки и запросы ресурсов, как, например, открытие файлов или выделение памяти под объекты и т.д.
Теперь представим, что ошибке в вашем коде не возникло, коогда вы делали something. значит вы продолжаете делать уже что-то другое. Получается код втда

do something
if error goto release

do something_another
if error goro // Куда goto&!!!

Так как вы уже успели затребовать новые ресурсы, то возникает вопрос, куда теперь надо передать управление в случае ошибки?

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

do something
if error goto release

do something_another
if error goro another_release

Наступает очередь третьего программиста. Его код успешно прошел все проверки и дошел до места после something и another_something. Он что-то делает в коде свое. Но ему также надо обработать ошибку. Перейти по существующим меткам он не может, так как оон уже затребовал новые ресурсы, а не используемые ресурсы, которые вы выделяли, уже подчистил. Значит они пишет такой код.

do something
if error goto release

do something_another
if error goro another_release

do something_else
if error goro else_release

Теперь задание дали четвертому программисту. надо вписать в эту функцию в определенное место некотурую функциональность. Это программист успешно ее вписывает, но у него возникает вопрос, а куда передать управление, если после выаолнения этой функциональности надо выйти из функции? И тут начинаются гадания! Этот программист плохо знает, что функция делает вцелом, так как для этого нужны знания по другим частям пронета. Тогда поразмысли, он вставляет переход на метку, которая ему кажется предпочтительной. Но, увы, он ошибся! Остался не освобожденный ресурс. Но программа-то при тестировании работает! И баг вскрывается только тогда, когда программу передают пользователю. Тогда ддля исправления бага дают поручение пятому программисту исправить его. А пятый программист хватается за голову от этого ужасного кода, так как, как говорится, без поллитра в нем не разберешься!

Когда я слышу от програмиста подобную фразу, что это "хороший способ подчистки", то делаю однозначный вывод, что этого программиста ни в коем случае нельзя брать в проект, так как оон "понадчистит", что потом придется ночами все исправлять!

Здравствуйте, jyuyjiyuijyu, Вы писали:

J>сделал более детальное фильтрование

J>

J>nt4 sources

J>$ grep -r --include=*.c -P 'goto (.+);' "C:/nt4"
J>result: 42538 goto

J>$ grep -r --include=*.{cpp,cxx,cc} -P 'goto (.+);' "C:/nt4"
J>result: 8236 goto
J>

J>win2k sources

J>$ grep -r --include=*.c -P 'goto (.+);' "C:/win2k"
J>result: 16523 goto

J>$ grep -r --include=*.{cpp,cxx,cc} -P 'goto (.+);' "C:/win2k"
J>result: 23022 goto
J>

Не ожидал. Я еще понимаю в C, но в C++ goto практически бесполезен

Здравствуйте, jyuyjiyuijyu, Вы писали:

J>вывод ? goto сила

goto средство- как и нож, не более того, а фанатиков с фгм — в топку

Здравствуйте, Mr.Cat, Вы писали:

MC>А то. Очень хороший способ подчищать за собой в отсутствии try/finally или raii. Вот типа того:
MC>

MC>aquire resource

MC>do something
MC>if error goto release

MC>do something else

MC>release:
MC>  release resource
MC>

Я вспоминаю реальный случай в проекте. Когда был убран goto, посредством замены его структурной конструкцией, то сразу же обнаружидось, что этот код с goto сожержит по крайне мере три бага! Проблема была в том, что трудно было выделить тот код, который логически относился к тому фрагменту, которым управлял goto. То есть когда есть, например, конструкция с while, товы четко видите, где онаи начинается, и где она заканчивается. В отношении с goto это сказать нельзя. Нужно изучать код, прежде чем дать ответ на вопрос.

Здравствуйте, Sni4ok, Вы писали:

S>Здравствуйте, jyuyjiyuijyu, Вы писали:

J>>вывод ? goto сила

S>goto средство- как и нож, не более того, а фанатиков с фгм — в топку

В жизни можно чего-то добиваться плохими средствами, а можно хорошими. Я предпочитаю хорошими.

Здравствуйте, Константин, Вы писали:

К>Здравствуйте, jyuyjiyuijyu, Вы писали:

J>>сделал более детальное фильтрование

J>>

J>>nt4 sources

J>>$ grep -r --include=*.c -P 'goto (.+);' "C:/nt4"
J>>result: 42538 goto

J>>$ grep -r --include=*.{cpp,cxx,cc} -P 'goto (.+);' "C:/nt4"
J>>result: 8236 goto
J>>

J>>

J>>win2k sources

J>>$ grep -r --include=*.c -P 'goto (.+);' "C:/win2k"
J>>result: 16523 goto

J>>$ grep -r --include=*.{cpp,cxx,cc} -P 'goto (.+);' "C:/win2k"
J>>result: 23022 goto
J>>

К>Не ожидал. Я еще понимаю в C, но в C++ goto практически бесполезен

Практическое применение при желании можно найти, но это говорит о том, что человек ничего не понимает в ООП.

Здравствуйте, Сыроежка, Вы писали:

С>Когда я слышу от програмиста подобную фразу, что это "хороший способ подчистки", то делаю однозначный вывод, что этого программиста ни в коем случае нельзя брать в проект, так как оон "понадчистит", что потом придется ночами все исправлять!

А как иначе сделать без оверхида? Не скажу, что такой код прямо лучше

  /* code */

  r1 = alloc_resource1();
  if (error) 
  {
    return FAIL;
  }

  /* code */

  r2 = alloc_resource2();
  if (error)
  {
    free_resource(r1);
    return FAIL;
  }   
 
  /* code */

  r3 = alloc_resource3();
  if (error)
  {
    free_resource(r2);
    free_resource(r1);
    return FAIL;
  }   

  /* code */

  free_resource(r3);
  free_resource(r2);
  free_resource(r1);
  return OK;

Здравствуйте, Сыроежка, Вы писали:

С>В жизни можно чего-то добиваться плохими средствами, а можно хорошими. Я предпочитаю хорошими.

как-то вы так хорошо свяазали goto с успехами в жизни, и как успех уже близок?

Здравствуйте, Сыроежка, Вы писали:

С>Здравствуйте, Sni4ok, Вы писали:

S>>Здравствуйте, jyuyjiyuijyu, Вы писали:

J>>>вывод ? goto сила

S>>goto средство- как и нож, не более того, а фанатиков с фгм — в топку

С>В жизни можно чего-то добиваться плохими средствами, а можно хорошими. Я предпочитаю хорошими.

Уважаемый, ну может все же снизойдете и дадите хотя бы намек, как же в С (не С++) "изящно" освобождать ресурсы?
А насчет 1-2-3 программист пришел поставил "гоуту не туда" — нефиг катать функции листингом как все исходники Винды. Тогда и goto дам будет адын.

Здравствуйте, Mystic, Вы писали:

M>Здравствуйте, Сыроежка, Вы писали:

С>>Когда я слышу от програмиста подобную фразу, что это "хороший способ подчистки", то делаю однозначный вывод, что этого программиста ни в коем случае нельзя брать в проект, так как оон "понадчистит", что потом придется ночами все исправлять!

M>А как иначе сделать без оверхида? Не скажу, что такой код прямо лучше

M>

M>  /* code */

M>  r1 = alloc_resource1();
M>  if (error) 
M>  {
M>    return FAIL;
M>  }

M>  /* code */

M>  r2 = alloc_resource2();
M>  if (error)
M>  {
M>    free_resource(r1);
M>    return FAIL;
M>  }   
 
M>  /* code */

M>  r3 = alloc_resource3();
M>  if (error)
M>  {
M>    free_resource(r2);
M>    free_resource(r1);
M>    return FAIL;
M>  }   

M>  /* code */

M>  free_resource(r3);
M>  free_resource(r2);
M>  free_resource(r1);
M>  return OK;
M>

В общем случае этот подход значительно лучше. То есть вы знаете. если условие не выполнено, то вам не надо просматривать всю функцию до ее завершения. А самое главное — этот код поддается улучшению, так как сами ресурсы могут управлять освобожлением других ресурсов, если им самим не удалось создаться. например, resource3 из вашего примера знает, что его можно выделять лишь при условии, что уже выдеен resource2, а потому при своем неуспехи, оон может освободить resurce2. То есть вступает в игру ООП.
Проблема с goto помимо прочих недостатков заключается в том, что другие программисты уже должны подчиняться этому дизайну и вставлять свои goto в тело функции. В противном случае либо надо целиком пересматривать дизайн функции, лиюо начнется дублирование кода, и функция будет разрастаться.

Здравствуйте, Сыроежка, Вы писали:

С>Здравствуйте, Mystic, Вы писали:

> ... skip

M>>А как иначе сделать без оверхида? Не скажу, что такой код прямо лучше

M>>

M>>  /* code */

M>>  r1 = alloc_resource1();
M>>  if (error) 
M>>  {
M>>    return FAIL;
M>>  }

M>>  /* code */

M>>  r2 = alloc_resource2();
M>>  if (error)
M>>  {
M>>    free_resource(r1);
M>>    return FAIL;
M>>  }   
 
M>>  /* code */

M>>  r3 = alloc_resource3();
M>>  if (error)
M>>  {
M>>    free_resource(r2);
M>>    free_resource(r1);
M>>    return FAIL;
M>>  }   

M>>  /* code */

M>>  free_resource(r3);
M>>  free_resource(r2);
M>>  free_resource(r1);
M>>  return OK;
M>>

С>В общем случае этот подход значительно лучше. То есть вы знаете. если условие не выполнено, то вам не надо просматривать всю функцию до ее завершения. А самое главное — этот код поддается улучшению, так как сами ресурсы могут управлять освобожлением других ресурсов, если им самим не удалось создаться. например, resource3 из вашего примера знает, что его можно выделять лишь при условии, что уже выдеен resource2, а потому при своем неуспехи, оон может освободить resurce2. То есть вступает в игру ООП.
Вы знаете, на ... вертеть такой "мощный" выход "ООП" на арену.

Здравствуйте, DarkTranquillity, Вы писали:

DT>Здравствуйте, Сыроежка, Вы писали:

С>>Здравствуйте, Sni4ok, Вы писали:

S>>>Здравствуйте, jyuyjiyuijyu, Вы писали:

J>>>>вывод ? goto сила

S>>>goto средство- как и нож, не более того, а фанатиков с фгм — в топку

С>>В жизни можно чего-то добиваться плохими средствами, а можно хорошими. Я предпочитаю хорошими.

DT>Уважаемый, ну может все же снизойдете и дадите хотя бы намек, как же в С (не С++) "изящно" освобождать ресурсы?
DT>А насчет 1-2-3 программист пришел поставил "гоуту не туда" — нефиг катать функции листингом как все исходники Винды. Тогда и goto дам будет адын.

Из вашего сообщения можно лишь сделать однозначный вывод, что вы в крупных проектах не работали. Так, пишите какой-то местечковый код, а потому и мировоззрение в программировании у вас крайне ограниченное.
Чтобы вам было понятно насчет "катать функции", то я вам скажу, что в проектах бывает около тысячи модулей. Проект с общим числом около 400-500 модуллей считается маленьким для софтверных компаний. проектам обычно десять а то и более лет. За это время выпустилось уже с десяток релизов проекта. Одну и ту же функцию могут писать и модифицировать за время существования проекта человек тридцать. причем даже одна строчка в функции может меняться по десять раз. Более того многие из программистов, которые модифицировали функцию даже толком сказать не в состоянии, что она делает. Чтобы было понятно, то, допустим, заказчик присылает сообщение об ошибке, а вмесет с ним либо журнал ошибок, либо дамп памяти. Начинается анализ дампа. Находится место ошибки на уровне ассемблерного кода. находите функцию, которой принадлежит этот ассемблерный код. И начинаете анализировать тот фрагмент кода, а не всю функцию, которое стало причиной ошибки. исправляете его. В итоге получается код, в котором заплата нашита на заплату, так как нет средств и возможностей переписать функцию заново. Это можно сделать лишь в плановом порядке, когда будет делаться следующий релиз, и так повезет, что эта функция войдет в перечень тех функций, которые нужно модифицировать. Многие программисты увольняются, многие поступают на работу и, практически, ни один человек не значет всех тонкостей проекта. Есть лишь отдельные люди, которые отвечают за некоторую логику проекта и проектировщики, которые код не знают, но зато знают структуру проекта и взаимосвязи между частями на логическом уровне.

Что касается примеров, как исправить код с goto, то таких примеров у меня много. Но это надо проводить целую лекцию: брать из проекта примеры кода с goto, показывать их недостатки, и как они теперь выглядят без gotо.
онимание этого как раз и определяет квалификацию программиста. А если возникают вопросы, то значит вам следует набираться опыта и повышать свою квалификацию.

Что касается языка С, то вы наверное даже и не догадываетесь, что на нем можно и не только можно, а просто нужно писать объектно-ориентированные программы. Потому что объектно-оирентированное программирование — это стиль программирования, а не технические средства. Технические средства лишь помогают вам более наглядно выразить этот стиль.
Что такое объектно-ориентированное программирование? Оно базируется на двух принципах. Первое — на построение абстракций, то есть от перехода от частного к общему и обобщеннному. Второе — каждый код должен отвечать за то, в чем ему предоставлены полномочия и компетенция.
На С это легко нарушить, так как средства инкапусляции, средства доступа, средства полиморфизма крайне ограничены. И многие программисты на С, которые не встречают преград со стороны языка часто не просто нарушают эти принципы, а даже не догадываются о них. Поэтому очень часто клиентский код лезет в реализацию серверного кода, удаляет ресурсы тот код, который не имеет компетенции это делать, реализация одной абстракции размазана по различным частям кода, что эхту абстракцию трудно выделить и увидеть. В том числе и используют goto, так как так "проще". Все это оборачивается плохим плохочитаемым кодом с многочисленными багами и непонятной логикой.

Мой вам совет: пишите на С в объектно-ориентированном стиле, и тогда у вас подобных вопросов даже не возникнет!

Здравствуйте, Сыроежка, Вы писали:

С>Здравствуйте, Mystic, Вы писали:

M>>Здравствуйте, Сыроежка, Вы писали:

С>>>Когда я слышу от програмиста подобную фразу, что это "хороший способ подчистки", то делаю однозначный вывод, что этого программиста ни в коем случае нельзя брать в проект, так как оон "понадчистит", что потом придется ночами все исправлять!

M>>А как иначе сделать без оверхида? Не скажу, что такой код прямо лучше

С>В общем случае этот подход значительно лучше. То есть вы знаете. если условие не выполнено, то вам не надо просматривать всю функцию до ее завершения. А самое главное — этот код поддается улучшению, так как сами ресурсы могут управлять освобожлением других ресурсов, если им самим не удалось создаться. например, resource3 из вашего примера знает, что его можно выделять лишь при условии, что уже выдеен resource2, а потому при своем неуспехи, оон может освободить resurce2. То есть вступает в игру ООП.

При последовательном применении идиомы 'goto cleanup' просматривать всю функцию точно также нет необходимости. А где Вы увидели зависимости между ресурсами вообще непонятно, во всяком случае, в приведенном фрагменте кода их нет, также как и ООП.

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

феерично. Добавил выделение, для тех, кто ~~в танке~~ не заметил дублирования кода в варианте без goto.

Скрытый текст

M>>

M>>  /* code */

M>>  r1 = alloc_resource1();
M>>  if (error) 
M>>  {
M>>    return FAIL;
M>>  }

M>>  /* code */

M>>  r2 = alloc_resource2();
M>>  if (error)
M>>  {
M>>    free_resource(r1);
M>>    return FAIL;
M>>  }   
 
M>>  /* code */

M>>  r3 = alloc_resource3();
M>>  if (error)
M>>  {
M>>    free_resource(r2);
M>>    free_resource(r1);
M>>    return FAIL;
M>>  }   

M>>  /* code */

M>>  free_resource(r3);
M>>  free_resource(r2);
M>>  free_resource(r1);
M>>  return OK;
M>>

Ниже пример смешивания подходов без пересмотра дизайна функции, дублирование кода, присущее подходу без goto, разумеется осталось.

Скрытый текст

  /* code */

  r1 = alloc_resource1();
  if (error) 
  {
    result = FAIL;
    goto cleanup;
  }

  /* code */

  r2 = alloc_resource2();
  if (error) 
  {
    result = FAIL;
    goto cleanup;
  }
 
  /* code */

  r3 = alloc_resource3();
  if (error) 
  {
    free_resource(r2);
    free_resource(r1);
    return FAIL;
  }

  /* code */

  result = OK;

cleanup:
  free_resource(r3);
  free_resource(r2);
  free_resource(r1);

  return result;

Итого, чуть менее чем всё Вами сказанное, действительности не соответствует.

Здравствуйте, Сыроежка, Вы писали:

С>Как здесь правильно было замечано, старый код меняют лишь в крайнекй необходимости, коогда это вынуждено. То есть либо когда надо внести изменения в код в связи с новой функциональностью, либо когда найден баг. Кроме того, как я уже заметил, это могут быть комментарии. То есть у каждой функции стоит преамбула в виде ее описания, где могут использоваться для простоты работы алгоритма слова goto.
Как интересно, в описании алгоритма, значит, слово goto упрощает, а в коде нет?

С>А самое главное — не надо наивно думать, что в софтверных фирмах работают высококвалифицированные программисты. Высококвалифицированные программисты — это небольшая прослойка. А в основном в проектах участвуют, как я их называю, пофигисты, которые пишут по принципу "тяп-ляп" — лишь бы работало.

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

Здравствуйте, Сыроежка, Вы писали:

а потому и мировоззрение в программировании у вас крайне ограниченное.

"Критикуя, критикуй мнение, а не его автора." Леонардо да Винчи

Здравствуйте, Сыроежка, Вы писали:

С>Здравствуйте, Mr.Cat, Вы писали:

MC>>Здравствуйте, jyuyjiyuijyu, Вы писали:
J>>>вывод ? goto сила
MC>>А то. Очень хороший способ подчищать за собой в отсутствии try/finally или raii. Вот типа того:

С>Теперь представим, что ошибке в вашем коде не возникло, коогда вы делали something. значит вы продолжаете делать уже что-то другое. Получается код втда

С>do something
С>if error goto release

С>do something_another
С>if error goro // Куда goto&!!!

С>Так как вы уже успели затребовать новые ресурсы, то возникает вопрос, куда теперь надо передать управление в случае ошибки?

Туда же куда и раньше: goto release. Соответственно, последующий вывод и всё остальное неверно.

Здравствуйте, Сыроежка, Вы писали:

С>А самое главное — этот код поддается улучшению, так как сами ресурсы могут управлять освобожлением других ресурсов, если им самим не удалось создаться. например, resource3 из вашего примера знает, что его можно выделять лишь при условии, что уже выдеен resource2, а потому при своем неуспехи, он может освободить resurce2. То есть вступает в игру ООП.

Не приведи господь работать с таким кодом

Здравствуйте, Erop, Вы писали:

E>Здравствуйте, Сыроежка, Вы писали:

С>>Как здесь правильно было замечано, старый код меняют лишь в крайнекй необходимости, коогда это вынуждено. То есть либо когда надо внести изменения в код в связи с новой функциональностью, либо когда найден баг. Кроме того, как я уже заметил, это могут быть комментарии. То есть у каждой функции стоит преамбула в виде ее описания, где могут использоваться для простоты работы алгоритма слова goto.
E>Как интересно, в описании алгоритма, значит, слово goto упрощает, а в коде нет?

Описание алгоритма — это несколько иное. Там нет деталей. Там может быть просто фраза, "если что-то не выполнилось, то переходим (или идем, или вообще просто goto to #3) к другому пункту". Или "если это не выполнилсоь, то идем на начало". Но "идием на начало" — это совершенно не означает, что используемп goto. Для программиста это может означать, что используется while, for или do-while.

С>>А самое главное — не надо наивно думать, что в софтверных фирмах работают высококвалифицированные программисты. Высококвалифицированные программисты — это небольшая прослойка. А в основном в проектах участвуют, как я их называю, пофигисты, которые пишут по принципу "тяп-ляп" — лишь бы работало.

E>Винда -- это весьма успешный проект, с очень многолетней историей развития и успешной историей поддержки. И goto им не помешал... А есть просто куча мегаверно написанного кода, который умер не родившись...
E>И это таки повод задуматься о верности своих идеалов

У вас с логикой проблемы. То, что проект успешный, еще не означает, что goto им не мешал! Может быть как раз очень даже мешал! Возьмите для примера MS VC++ 2010. Там столько багов, что мало не покажется. И почему вы так уверенно считаете, что причиной этих багов не является goto, если там таковые имеются?!

Что касается хорошего кода, который "умер, не родившись", то это совершенно не связано с тем, что хороший код мешал развитию проекта. Хорошему проекту мешает сомнительная логика, которая имеется в ваших рассуждениях.

Здравствуйте, k.o., Вы писали:

KO>Здравствуйте, Сыроежка, Вы писали:

С>>Здравствуйте, Mystic, Вы писали:

M>>>Здравствуйте, Сыроежка, Вы писали:

С>>>>Когда я слышу от програмиста подобную фразу, что это "хороший способ подчистки", то делаю однозначный вывод, что этого программиста ни в коем случае нельзя брать в проект, так как оон "понадчистит", что потом придется ночами все исправлять!

M>>>А как иначе сделать без оверхида? Не скажу, что такой код прямо лучше

С>>В общем случае этот подход значительно лучше. То есть вы знаете. если условие не выполнено, то вам не надо просматривать всю функцию до ее завершения. А самое главное — этот код поддается улучшению, так как сами ресурсы могут управлять освобожлением других ресурсов, если им самим не удалось создаться. например, resource3 из вашего примера знает, что его можно выделять лишь при условии, что уже выдеен resource2, а потому при своем неуспехи, оон может освободить resurce2. То есть вступает в игру ООП.

KO>При последовательном применении идиомы 'goto cleanup' просматривать всю функцию точно также нет необходимости. А где Вы увидели зависимости между ресурсами вообще непонятно, во всяком случае, в приведенном фрагменте кода их нет, также как и ООП.

При "последовательном применении "goto cltanup" вы только последовательно пичкаете вашу программу операторами goto и принуждаете других программистов использовать goto, так как им уже без этого не обойтись благодаря вашей плохой структуре программы. Это всего лишь последовательное ухудшение дизайна функции.

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

KO>феерично. Добавил выделение, для тех, кто ~~в танке~~ не заметил дублирования кода в варианте без goto.

Так это и говорит, что вы не понимаете, о чем идет речь. В этом и проблема всех начинающих программистов: крайне местечковое мировоззрение. Дело в том, что если при вашей структцуре функции с goto человек начент писать в объектно-ориентированном стиле, то без ваших goto, то ему придется либо переписывать всю функцию заново, либо дуюлировать код. либо есть третий вариант, о котором я уже постоянно вам втолковую, писать свои goto.

KO>

Скрытый текст

M>>>

M>>>  /* code */

M>>>  r1 = alloc_resource1();
M>>>  if (error) 
M>>>  {
M>>>    return FAIL;
M>>>  }

M>>>  /* code */

M>>>  r2 = alloc_resource2();
M>>>  if (error)
M>>>  {
M>>>    free_resource(r1);
M>>>    return FAIL;
M>>>  }   
 
M>>>  /* code */

M>>>  r3 = alloc_resource3();
M>>>  if (error)
M>>>  {
M>>>    free_resource(r2);
M>>>    free_resource(r1);
M>>>    return FAIL;
M>>>  }   

M>>>  /* code */

M>>>  free_resource(r3);
M>>>  free_resource(r2);
M>>>  free_resource(r1);
M>>>  return OK;
M>>>

KO>Ниже пример смешивания подходов без пересмотра дизайна функции, дублирование кода, присущее подходу без goto, разумеется осталось.
KO>

Скрытый текст

KO>

KO>  /* code */

KO>  r1 = alloc_resource1();
KO>  if (error) 
KO>  {
KO>    result = FAIL;
KO>    goto cleanup;
KO>  }

KO>  /* code */

KO>  r2 = alloc_resource2();
KO>  if (error) 
KO>  {
KO>    result = FAIL;
KO>    goto cleanup;
KO>  }
 
KO>  /* code */

KO>  r3 = alloc_resource3();
KO>  if (error) 
KO>  {
KO>    free_resource(r2);
KO>    free_resource(r1);
KO>    return FAIL;
KO>  }

KO>  /* code */

KO>  result = OK;

KO>cleanup:
KO>  free_resource(r3);
KO>  free_resource(r2);
KO>  free_resource(r1);

KO>  return result;
KO>

KO>Итого, чуть менее чем всё Вами сказанное, действительности не соответствует.

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

То, что вы тут начинаете заниматься демагогией, это уже давно в истории программирования пройденный этап. Но всегда появляются люди с недостаточной квалификацией, которые начинают этот путь проходить заново. Таков общий путь развития познания. Образно говоря, сначала люди видят, что Солнце встает и закаьтывается, а потому с пеной у рта доказывают, что Солнце вертется вокруг Земли. Нужно еще приобрести много знаний, чтобы понять, что это Земля вертится вокруг Солнца, а не наоборот. То же самое и в программировании. Человек, освоивший оператор goto, и не мыслящий в объектно-ориентированном стиле, будет с пеной у рта доказывать, насколько хорош goto. И ему бесполезно что-то объяснять, пока он не подымется на новую ступень познания. Все приходит с опытом и со знаниемями. Некоторые правда так и остаются на уровне идиомы goto всю свою профессиональную жизнь.

Здравствуйте, k.o., Вы писали:

KO>Здравствуйте, Сыроежка, Вы писали:

С>>Здравствуйте, Mr.Cat, Вы писали:

MC>>>Здравствуйте, jyuyjiyuijyu, Вы писали:
J>>>>вывод ? goto сила
MC>>>А то. Очень хороший способ подчищать за собой в отсутствии try/finally или raii. Вот типа того:

С>>Теперь представим, что ошибке в вашем коде не возникло, коогда вы делали something. значит вы продолжаете делать уже что-то другое. Получается код втда

С>>do something
С>>if error goto release

С>>do something_another
С>>if error goro // Куда goto&!!!

С>>Так как вы уже успели затребовать новые ресурсы, то возникает вопрос, куда теперь надо передать управление в случае ошибки?

KO>Туда же куда и раньше: goto release. Соответственно, последующий вывод и всё остальное неверно.

Забавно! А там снова надо делать теже самые проверки и осуществлять переход. Получается замкнутый круг. То есть вы просто из одного места goto перенесли в другое место.

"Бездельника хлебом не корми, а дай порассуждать, да и в умении очернить других ему не откажешь. Он всегда готов найти оправдание собственной никчёмности." Леонардо да Винчи

Здравствуйте, Сыроежка, Вы писали:

KO>>Итого, чуть менее чем всё Вами сказанное, действительности не соответствует.
С>Не смешите. О какой действительности вы говорите? О том, что вы не умете писать программы в объектно-ориентированном стиле?

Речь идёт о действительности, в которой существует такая компания как Microsoft. Я вам напомню, село Редмонд с населением 45256 человек, западное побережье одного северного континента. Там пишут вполне местечковый код. Про объектно-ориентированный стиль видимо не знают, так как часто используют goto.

Здравствуйте, Сыроежка, Вы писали:

С>Описание алгоритма — это несколько иное. Там нет деталей. Там может быть просто фраза, "если что-то не выполнилось, то переходим (или идем, или вообще просто goto to #3) к другому пункту". Или "если это не выполнилсоь, то идем на начало". Но "идием на начало" — это совершенно не означает, что используемп goto. Для программиста это может означать, что используется while, for или do-while.

Я, всё-таки, скромно надеюсь, что в коде винды на английском, а там "идём туда-то" пишут таки с пробелом: "go to tudato"...

С>У вас с логикой проблемы. То, что проект успешный, еще не означает, что goto им не мешал! Может быть как раз очень даже мешал! Возьмите для примера MS VC++ 2010. Там столько багов, что мало не покажется. И почему вы так уверенно считаете, что причиной этих багов не является goto, если там таковые имеются?!

Я уверен, что если и мешал то не так сильно, чтобы винда загнулась...

Значит проблема, если и есть, то не смертельная

С>Что касается хорошего кода, который "умер, не родившись", то это совершенно не связано с тем, что хороший код мешал развитию проекта. Хорошему проекту мешает сомнительная логика, которая имеется в ваших рассуждениях.

Мои проекты пока живут...

Значительная часть винды написана на C. Для C goto — единственный способ обеспечить cleanup.
Для C и C++ goto — единственный способ выйти из вложенного цикла (кроме функций, плодить которые в ряде случаев совсем не хочется).

Здравствуйте, Сыроежка, Вы писали:

С>>>В общем случае этот подход значительно лучше. То есть вы знаете. если условие не выполнено, то вам не надо просматривать всю функцию до ее завершения. А самое главное — этот код поддается улучшению, так как сами ресурсы могут управлять освобожлением других ресурсов, если им самим не удалось создаться. например, resource3 из вашего примера знает, что его можно выделять лишь при условии, что уже выдеен resource2, а потому при своем неуспехи, оон может освободить resurce2. То есть вступает в игру ООП.

KO>>При последовательном применении идиомы 'goto cleanup' просматривать всю функцию точно также нет необходимости. А где Вы увидели зависимости между ресурсами вообще непонятно, во всяком случае, в приведенном фрагменте кода их нет, также как и ООП.

С>При "последовательном применении "goto cltanup" вы только последовательно пичкаете вашу программу операторами goto и принуждаете других программистов использовать goto, так как им уже без этого не обойтись благодаря вашей плохой структуре программы. Это всего лишь последовательное ухудшение дизайна функции.

Аргументов мы от Вас не дождёмся? goto использовать плохо потому, что это плохо, да?

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

KO>>феерично. Добавил выделение, для тех, кто ~~в танке~~ не заметил дублирования кода в варианте без goto.

С>Так это и говорит, что вы не понимаете, о чем идет речь. В этом и проблема всех начинающих программистов: крайне местечковое мировоззрение. Дело в том, что если при вашей структцуре функции с goto человек начент писать в объектно-ориентированном стиле, то без ваших goto, то ему придется либо переписывать всю функцию заново, либо дуюлировать код. либо есть третий вариант, о котором я уже постоянно вам втолковую, писать свои goto.

Как я уже продемонстрировал, моя структура функции, не требует от других использовать goto. И не надо ничего втолковывать, просто покажите код.

KO>>

Скрытый текст

M>>>>

M>>>>  /* code */

M>>>>  r1 = alloc_resource1();
M>>>>  if (error) 
M>>>>  {
M>>>>    return FAIL;
M>>>>  }

M>>>>  /* code */

M>>>>  r2 = alloc_resource2();
M>>>>  if (error)
M>>>>  {
M>>>>    free_resource(r1);
M>>>>    return FAIL;
M>>>>  }   
 
M>>>>  /* code */

M>>>>  r3 = alloc_resource3();
M>>>>  if (error)
M>>>>  {
M>>>>    free_resource(r2);
M>>>>    free_resource(r1);
M>>>>    return FAIL;
M>>>>  }   

M>>>>  /* code */

M>>>>  free_resource(r3);
M>>>>  free_resource(r2);
M>>>>  free_resource(r1);
M>>>>  return OK;
M>>>>

KO>>Итого, чуть менее чем всё Вами сказанное, действительности не соответствует.

С>Не смешите. О какой действительности вы говорите? О том, что вы не умете писать программы в объектно-ориентированном стиле?

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

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

С>То, что вы тут начинаете заниматься демагогией, это уже давно в истории программирования пройденный этап. Но всегда появляются люди с недостаточной квалификацией, которые начинают этот путь проходить заново. Таков общий путь развития познания. Образно говоря, сначала люди видят, что Солнце встает и закаьтывается, а потому с пеной у рта доказывают, что Солнце вертется вокруг Земли. Нужно еще приобрести много знаний, чтобы понять, что это Земля вертится вокруг Солнца, а не наоборот. То же самое и в программировании. Человек, освоивший оператор goto, и не мыслящий в объектно-ориентированном стиле, будет с пеной у рта доказывать, насколько хорош goto. И ему бесполезно что-то объяснять, пока он не подымется на новую ступень познания. Все приходит с опытом и со знаниемями. Некоторые правда так и остаются на уровне идиомы goto всю свою профессиональную жизнь.

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

К>Не ожидал. Я еще понимаю в C, но в C++ goto практически бесполезен

Ответ тривиален. В рамках переезда с С на С++ берётся файл *.c и переименовывается в .cpp без изменения содержания. Так мозила делает, например.

С>В общем случае этот подход значительно лучше.

Офигеть, чем же он лучше?
Кстати, хочу напомнить, что в С переменные описываются в начале функции.

void* resource1 = NULL;
void* resource2 = NULL;
void* resource3 = NULL;
int result_error_code = 0;

...
if (!some_check1)) {
  result_error_code = 1;
  goto exit_label;
}
resource1 = malloc(100);

if (!some_check2()) {
  result_error_code = 2;
  goto exit_label;
}
resource2 = malloc(100);

if (!some_check3()) {
  result_error_code = 3;
  goto exit_label;
}
resource3 = malloc(100);

...
exit_label:
if (resource1) free(resource1);
if (resource2) free(resource2);
if (resource3) free(resource3);

Это, имхо, наилучшее решение задачи. Множественные выходы из функции без автоматического освобождения ресурсов — к беде.

Здравствуйте, Евгений Коробко, Вы писали:

ЕК>Это, имхо, наилучшее решение задачи. Множественные выходы из функции без автоматического освобождения ресурсов — к беде.
+100!

Альтернаиива, собственно, только одна. В том редком случае, когда ресурс не указатель и просто так его не проинициализируешь и инициализированность не проверишь, делают как-то так:

ЕК>

ЕК>Resource1 resource1;
ЕК>Resource2 resource2;
ЕК>Resource3 resource3;
ЕК>int result_error_code = 0;

ЕК>...
ЕК>if( !initRes1(&resource1) ) {
ЕК>  result_error_code = 1;
ЕК>  goto exit_after_resource1;
ЕК>}

ЕК>if( !initRes2(&resource2) ) {
ЕК>  result_error_code = 2;
ЕК>  goto exit_after_resource2;
ЕК>}

ЕК>if( !initRes3(&resource3) ) {
ЕК>  result_error_code = 3;
ЕК>  goto exit_after_resource3;
ЕК>}


ЕК>...
ЕК>  freeRes3(&resource3);
ЕК>exit_after_resource3: 
ЕК>  freeRes2(&resource2);
ЕК>exit_after_resource2: 
ЕК>  freeRes1(&resource1);
EK>exit_after_resource1: ;
ЕК>

реальная жизнь сурова

смотрите функцию copy_process

http://lxr.linux.no/#linux+v3.2.5/kernel/fork.c


bad_fork_free_pid:
        if (pid != &init_struct_pid)
                free_pid(pid);
bad_fork_cleanup_io:
        if (p->io_context)
                exit_io_context(p);
bad_fork_cleanup_namespaces:
        exit_task_namespaces(p);
bad_fork_cleanup_mm:
        if (p->mm)
                mmput(p->mm);
bad_fork_cleanup_signal:
        if (!(clone_flags & CLONE_THREAD))
                free_signal_struct(p->signal);
bad_fork_cleanup_sighand:
        __cleanup_sighand(p->sighand);
bad_fork_cleanup_fs:
        exit_fs(p); /* blocking */
bad_fork_cleanup_files:
        exit_files(p); /* blocking */
bad_fork_cleanup_semundo:
        exit_sem(p);
bad_fork_cleanup_audit:
        audit_free(p);
bad_fork_cleanup_policy:
        perf_event_free_task(p);
#ifdef CONFIG_NUMA
        mpol_put(p->mempolicy);
bad_fork_cleanup_cgroup:
#endif
        if (clone_flags & CLONE_THREAD)
                threadgroup_fork_read_unlock(current);
        cgroup_exit(p, cgroup_callbacks_done);
        delayacct_tsk_free(p);
        module_put(task_thread_info(p)->exec_domain->module);
bad_fork_cleanup_count:
        atomic_dec(&p->cred->user->processes);
        exit_creds(p);
bad_fork_free:
        free_task(p);
fork_out:
        return ERR_PTR(retval);
}

Здравствуйте, jyuyjiyuijyu, Вы писали:

J>реальная жизнь сурова

J>смотрите функцию copy_process

J>http://lxr.linux.no/#linux+v3.2.5/kernel/fork.c

И что тут не прнятно?..

Думаешь с флажками или с дублированием очистки на каждый выход, было бы лучше?

Здравствуйте, jyuyjiyuijyu, Вы писали:

J>реальная жизнь сурова
J>смотрите функцию copy_process

Придраться можно только вот к этому куску:
J>

J>bad_fork_cleanup_policy:
J>        perf_event_free_task(p);
J>#ifdef CONFIG_NUMA
J>        mpol_put(p->mempolicy);
J>bad_fork_cleanup_cgroup:
J>#endif
J>        if (clone_flags & CLONE_THREAD)
J>                threadgroup_fork_read_unlock(current);
J>        cgroup_exit(p, cgroup_callbacks_done);
J>        delayacct_tsk_free(p);
J>        module_put(task_thread_info(p)->exec_domain->module);
J>

Остальное всё вполне понятно, типичный паттерн "goto cleanup", просто громоздкий.

Здравствуйте, Erop, Вы писали:

E>И что тут не прнятно?..

E>Думаешь с флажками или с дублированием очистки на каждый выход, было бы лучше?

да я как бы за goto просто пример из реальной жизни я к тому что как сильно это расходится с заявлениями некоторых типа "юзает goto значит не умеет по другому" стоить еще учесть раньше оптимизаторы не такие крутые были и реально может код выигрывал по скорости от такой организации а так то конечно можно было бы наверное разбить на десяток функций и почти избавиться от всех goto но во первых когда этот код писался отимизаторы были не такие крутые а во вторых разбиение одной задачи на десять подзадач только усложнит понимание

Здравствуйте, jyuyjiyuijyu, Вы писали:

J>Всем привет

J>инструменты:

J>шелл Cygwin Terminal из пакета Cygwin
J>утилита grep из пакета Cygwin

J>(кстати рекомендую всем у кого еще не установлен пакет Cygwin обязательно поставить получите юникс шелл и юникс утилиты)

J>жертва сорцы nt4

J>запускаем
J>

J>$ grep -r --include=*.{c,cpp,cxx,cc,h,hpp,hxx} 'goto' "C:/nt4"
J>result: 54760 goto
J>

J>жертва сорцы win2k

J>запускаем
J>

J>$ grep -r --include=*.{c,cpp,cxx,cc,h,hpp,hxx} 'goto' "C:/win2k"
J>result: 40460 goto
J>

J>вывод ? goto сила

А сколько goto из этого числа входят в состав кода, сгенерированного YACC ?

J>вывод ? goto сила
Сила. Но сила эта слабеет. Человеку с внутренней дисциплиной не подобает писать код с goto

Здравствуйте, jyuyjiyuijyu, Вы писали:

J>вывод ? goto сила

grep -e "Jump off the cliff" 1_million_lemmings

Ну ты понял, да?

Здравствуйте, Eye of Hell, Вы писали:

EOH>Для C и C++ goto — единственный способ выйти из вложенного цикла (кроме функций, плодить которые в ряде случаев совсем не хочется).
Нормальные люди из вложенных циклов выходят по условиям, ибо даже break/continue -- это тот же goto.

Здравствуйте, jyuyjiyuijyu, Вы писали:

J>Всем привет

J>вывод ? goto сила

Всё дело в том, что большая часть готофобов стала таковой из-за Дейкстры с его goto considered harmful. Правда дальше названия они ниасилили, так как там много букв и стиль текста сложный — иначе бы они поняли что не всякий goto плох. В частности goto considered harmful не относится к break, continue и cleanup'ам так как их использование не усложняет поиск "meaningful set of coordinates" и не является "The unbridled use of the go to statement".

Для сравнения, PR команда лиспа вместо неудобочитаемых текстов использует красочные обложки(SICP) и даже пляшущих девочек(http://lambda.bugyo.tk/cdr/mwl/) и как результат — фанклуб у лиспа гораздо более развит чем у гото.

Здравствуйте, B0FEE664, Вы писали:

BFE>Я вам напомню, село Редмонд с населением 45256 человек, западное побережье одного северного континента.
Наверняка, кода писали винду, там жило 40460 человек.

Здравствуйте, quwy, Вы писали:

Q>Здравствуйте, Eye of Hell, Вы писали:

EOH>>Для C и C++ goto — единственный способ выйти из вложенного цикла (кроме функций, плодить которые в ряде случаев совсем не хочется).
Q>Нормальные люди из вложенных циклов выходят по условиям, ибо даже break/continue -- это тот же goto.

э-э-э... даешь мастер-класс?

for() {
  ...
  for() {
    ...
    for() {
      ...
      if (condition1) goto out;
      ...
      if (condition2) goto out;
      ...
    }
    ...
  }
  ...
}
out:

Продемонстрируешь, как "нормальные люди выходят по условиям" из таких вложенных циклов? (многоточия — это значимый код)

У меня в текущем проекте 1 гото, он в матеметике. Остальное ГУИ там вообще не надо думать про структуру отдельной функции, правда вот где ловить какое нибудь событие это загадка, иногда приходится выискивать по форумам ибо из документации не следует. Дело все в том как видит человек алгоритм. Ведь может увидеть не только скипы назад, но и вперед откатится к новой попытке.

....
l1:
....
l2:
....
if() goto l1;
....
if() goto l2;
.....

или в виндовс такие алгоритмы что писатели их так увидели или мозги у этих писателей такие были

.

Дейстра доказал что можно без гото. Это великая теорема структурного программирования, вроде недавно ктото спрашивал про нее. И тогда начинали писать структуратор, незнаю есть ли гденибудь сейчас готовый. Алгоритм такой
1 — заменяем switch() на if()
2 — заменяем циклы на if() goto;
3 — заменяем if на if() goto;
После этого только if() goto остались
4 — заменяем if() goto Lx; на variant=()?PC+1:Lx; break;
5 — рекомендуется перетасовать полученные секции как следует.

6 — вся программу преобразуем к одному

for(;;)
switch(variant)
{  ....
  case N:
   ....
   variant= ;
   break;
  case N:
   ....
   variant= ;
   break;
}

нето что вложенные if() не нужны if вообще не нужны как и гото. Вложенные циклы тоже не нужны.

Здравствуйте, Mr.Cat, Вы писали:

MC>Здравствуйте, jyuyjiyuijyu, Вы писали:

MC>А то. Очень хороший способ подчищать за собой в отсутствии try/finally или raii. Вот типа того:
MC>

MC>aquire resource

MC>do something
MC>if error goto release

MC>do something else

MC>release:
MC>  release resource
MC>

Вот такой вот C маст дай.

Здравствуйте, jazzer, Вы писали:

Нормальные люди заворачивают эту кашу в отдельную функцию, и выходятъ по ретурну из вложенного цылка.

Здравствуйте, vpchelko, Вы писали:

V>Здравствуйте, jazzer, Вы писали:

V>Нормальные люди заворачивают эту кашу в отдельную функцию, и выходятъ по ретурну из вложенного цылка.

особенно хорошо "эта каша" заворачивается в отдельную функцию, если у тебя в функции штук 20 локальных переменных.

Здравствуйте, TimurSPB, Вы писали:

TSP>Сила. Но сила эта слабеет. Человеку с внутренней дисциплиной не подобает писать код с goto

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

Здравствуйте, jazzer, Вы писали:

J>особенно хорошо "эта каша" заворачивается в отдельную функцию, если у тебя в функции штук 20 локальных переменных.

Я не знаю и знать не хочу такие функции. Если есть логически связанный набор переменных — их заворачивают в структуру. Если они не связаны логически

, то нехрен им делать в одной функции.

Здравствуйте, jazzer, Вы писали:

J>особенно хорошо "эта каша" заворачивается в отдельную функцию, если у тебя в функции штук 20 локальных переменных.

Это уже говнокод

Здравствуйте, jazzer, Вы писали:

J>э-э-э... даешь мастер-класс?
Цикл for существует для вполне определенного количества итераций, принудительный выход из такого цикла вообще дурной тон. Но если руки чешутся, то сишный фор отлично завершается по флажку:

for(i = 0; i < 10 && !stop; ++i)

Здравствуйте, vpchelko, Вы писали:

V>Здравствуйте, jazzer, Вы писали:

J>>особенно хорошо "эта каша" заворачивается в отдельную функцию, если у тебя в функции штук 20 локальных переменных.

V>Я не знаю и знать не хочу такие функции. Если есть логически связанный набор переменных — их заворачивают в структуру. Если они не связаны логически

, то нехрен им делать в одной функции.

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

Я даже боюсь себе представить, как будет выглядеть какой-нть вычислительный алгоритм (пуассон/лаплас на конечных элементах, скажем) в твоем исполнении

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

Здравствуйте, quwy, Вы писали:

Q>Здравствуйте, jazzer, Вы писали:

J>>э-э-э... даешь мастер-класс?
Q>Цикл for существует для вполне определенного количества итераций, принудительный выход из такого цикла вообще дурной тон. Но если руки чешутся, то сишный фор отлично завершается по флажку:
Q>

Q>for(i = 0; i < 10 && !stop; ++i)
Q>

ты мой цикл перепиши таким вот образом, вместе посмеемся, ага.

PS если тебе нужно из середины цикла выйти, на условие же придется переходить через, прости господи, continue, а это ж, прости господи, замаскированный goto

Здравствуйте, TimurSPB, Вы писали:

J>>вывод ? goto сила
TSP>Сила. Но сила эта слабеет. Человеку с внутренней дисциплиной не подобает писать код с goto

Пусть это делает компилятор и прочие?

Здравствуйте, maykie, Вы писали:

M>Всё дело в том, что большая часть готофобов стала таковой из-за Дейкстры с его goto considered harmful. Правда дальше названия они ниасилили, так как там много букв и стиль текста сложный — иначе бы они поняли что не всякий goto плох.

Он имел ввиду "фортрановский стиль"...

MC>aquire resource

MC>do something
MC>if error goto release

MC>do something else

MC>release:
MC>  release resource
MC>

судя по книге Хелен Кастлер Windows NT Inside причем буквально в первых главах было обоснование языка программирования (мажорного, никто не говорит, что на нем все написано внутри): язык C стандарта такого-то с расширениями для поддержки исключений (насколько понял, речь идет о SEH а не плюсовых)

Здравствуйте, jazzer, Вы писали:

Только почему-то сколько я пишу код, и не разу не появлялось желание использовать goto. Хз как-так получается...

Здравствуйте, vpchelko, Вы писали:

V>Только почему-то сколько я пишу код, и не разу не появлялось желание использовать goto. Хз как-так получается...

а меня всегда удивляло как у кого то может никогда не возникать желания заюзать goto он иногда очень очень к месту даже сейчас выкопаю код и приведу пример минутку..
вот например из одной утилиты (кто не узнал это linux списки linux/list.h)
конечно если бы в этой задаче с самого начала использовались деревья то
этой процедуры и вовсе не было бы но мы тут рассматриваем язык а не архитектурные
решения так что считаю уместный пример

static VOID CheckUnique(list_head *liblist, list_head *apilist)
{
again_scan:
    apiitem *apiel;
    list_for_each_entry(apiel, apilist, link)
    {
        libitem *libel;
        list_for_each_entry(libel, liblist, link)
        {
            apiitem *apiuniqel;
            list_for_each_entry(apiuniqel, &libel->apilist, link)
            {
                if (!strcmp(apiuniqel->szApi, apiel->szApi))
                {
                    ...processing...
                    goto  again_scan;

ну тут даже флажок не влепиш так что тут выход один разбить на несколько функций но это связано с некоторыми проблемами о которых уже упоминали 1) передача контекста туда сюда 2) только усложняет понимание так как задача одно целое дальнейшее дробление бессмысленно
я не говорю что не надо делить большую задачу на подзадачи надо но есть грань при переходе которой дробление будет только усложнять восприятие

Здравствуйте, vpchelko, Вы писали:

V>Только почему-то сколько я пишу код, и не разу не появлялось желание использовать goto. Хз как-так получается...
Ну кто ж тебя знает, какой ты там код пишешь, может, базы данных и гуй, там заковыристых двойных циклов и не бывает.
А если посмотришь на любые вычматы — там куча всего кэшируется в локальных переменных, чтоб по нескольку раз не считать, поэтому их так много.

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

Ну и послушай себя — вот у тебя была функция с двойным циклом, полностью тебя устраивала и все хорошо работало.
Вдруг в один прекрасный момент тебя осеняет, что если внутри цикла выполняется определенное условие, то можно дальше не считать и цикл прервать.
Я в таком случае поставлю goto на после цикла и горя знать не буду, а что сделаешь ты?
Выделишь цикл в отдельную функцию, начнешь возиться с локальными переменными, изобретать какие-то левые структуры — и все для чего? Столько "риска и романтики" — и всего лишь для того, чтоб не написать goto?

Здравствуйте, jyuyjiyuijyu, Вы писали:

J>Здравствуйте, vpchelko, Вы писали:

J>а меня всегда удивляло как у кого то может никогда не возникать желания заюзать goto он иногда очень очень к месту даже сейчас выкопаю код и приведу пример минутку..
J>вот например из одной утилиты (кто не узнал это linux списки linux/list.h)
J>конечно если бы в этой задаче с самого начала использовались деревья то
J>этой процедуры и вовсе не было бы но мы тут рассматриваем язык а не архитектурные
J>решения так что считаю уместный пример
J>

J>static VOID CheckUnique(list_head *liblist, list_head *apilist)
J>{
J>again_scan:
J>    apiitem *apiel;
J>    list_for_each_entry(apiel, apilist, link)
J>    {
J>        libitem *libel;
J>        list_for_each_entry(libel, liblist, link)
J>        {
J>            apiitem *apiuniqel;
J>            list_for_each_entry(apiuniqel, &libel->apilist, link)
J>            {
J>                if (!strcmp(apiuniqel->szApi, apiel->szApi))
J>                {
J>                    ...processing...
J>                    goto  again_scan;
                
J>

J>ну тут даже флажок не влепиш так что тут выход один разбить на несколько функций но это связано с некоторыми проблемами о которых уже упоминали 1) передача контекста туда сюда 2) только усложняет понимание так как задача одно целое дальнейшее дробление бессмысленно
J>я не говорю что не надо делить большую задачу на подзадачи надо но есть грань при переходе которой дробление будет только усложнять восприятие

Ужас, тяжело читать такой код.

Здравствуйте, vpchelko, Вы писали:

V>Ужас, тяжело читать такой код.

сам в шоке )) линукс списки и венгерская нотация это аццкий венегрет и имена переменных адские

Хм... Lua — крайне консервативный, лаконичный и стройный язык: ни грамма лишнего. И только совсем недавно за столько лет специально ввели goto в язык — толп с плакатами в Бразилии замечено не было...

MC>aquire resource
MC>do something
MC>if error goto release

MC>do something else

MC>release:
MC>  release resource
MC>

Сравним:

aquire resource
do something
switch(1) case 1: default:
{
  if error break;

  do something else break;
}
release resource

Здравствуйте, jyuyjiyuijyu, Вы писали:

J>вывод ? goto сила

Сила. Если мне вдруг внезапно понадобиться наваять достаточно крупный проект на голом С ~~то я напишу его на Objective-C, там рантайм не такой уж и тяжелый, можно и на железку затянуть~~ впишу его в проектный гайдлайн и буду использовать для очистки ресурсов в обязательном порядке. Все юноши с горящим взором и прочие снобы идут лесом.

Здравствуйте, Vain, Вы писали:

V>Сравним:
Жуть — я про изнасилование switch'а.

Здравствуйте, jazzer, Вы писали:

J>Ну и послушай себя — вот у тебя была функция с двойным циклом, полностью тебя устраивала и все хорошо работало.
J>Вдруг в один прекрасный момент тебя осеняет, что если внутри цикла выполняется определенное условие, то можно дальше не считать и цикл прервать.
J>Я в таком случае поставлю goto на после цикла и горя знать не буду, а что сделаешь ты?
J>Выделишь цикл в отдельную функцию, начнешь возиться с локальными переменными, изобретать какие-то левые структуры — и все для чего? Столько "риска и романтики" — и всего лишь для того, чтоб не написать goto?

Сколько я такие циклы пишу, на VB, на java на powershell — чет аналогов goto не приходилось использовать.

Здравствуйте, vpchelko, Вы писали:

J>>Выделишь цикл в отдельную функцию, начнешь возиться с локальными переменными, изобретать какие-то левые структуры — и все для чего? Столько "риска и романтики" — и всего лишь для того, чтоб не написать goto?

V>Сколько я такие циклы пишу, на VB, на java на powershell — чет аналогов goto не приходилось использовать.
Попробуй написать что-нибудь, связанное со сложными вычислениями.

Здравствуйте, Cyberax, Вы писали:

C>Попробуй написать что-нибудь, связанное со сложными вычислениями.

Библиотеку OpenCV юзал. Но тоже не приходилось.

Здравствуйте, Cyberax, Вы писали:

V>>Сравним:
C>Жуть — я про изнасилование switch'а.
уж лучше чем goto.

Здравствуйте, Vain, Вы писали:

V>>>Сравним:
C>>Жуть — я про изнасилование switch'а.
V>уж лучше чем goto.
Чем? Это goto просто с другим синтаксисом.

Могу ещё предложить такой вариант:

#define unicorn goto

...
   unicorn err_exit;
...
err_exit:
....

Тоже лучше goto!

Здравствуйте, Сыроежка, Вы писали:

С>На С это облегчает жизнь лишь тем, кто не умеет писать программы, то есть идут по пути наименьшего сопротивления: мол, зачем думать, когда я могу вставить goto.

такую лабуду пишут кто не в курсе что компьютер — это конечный автомат. Т.е. не от большого ума и с низкой квалификацией.

Здравствуйте, Vain, Вы писали:

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