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

Мне только оставалось согласиться c Вашим провалом, что я и сделал. Так что "дискуссия" с Вами завершена.

Упёртый. Ясно. А ведь убедиться, что я прав, так легко...

Ахаха! Вы такие смешные
В интернете кто-то неправ

У zltigo много безапелляционных утверждений, обычно строящихся по схеме "никто не может быть прав, если я думаю иначе", однако в этом конкретном случае хотелось бы больше деталей.
Стандарт языка С достоверный с ИСО сайта фиг достанешь, он там за деньги, а что находиться нахаляву - перепечатки и трактования. Косвенно я нашел 2 вещи, что вроде бы в С89 было function() - объявление функции возвращающей int и принимающей любое число параметров, но там и нельзя было написать function(void). А с С99 вроде бы когда появилось function(void) уже список переменных параметров задать даже через function(...) нельзя, нужен хотя бы 1 формальный параметр function(double p, ...)

Но это перепечатки и объяснения друг другу, а вот реально в документе АНСИ я что-то найти правды не смог, даже подлинного документа не смог найти....

Кто-то внесет ясность? желательно со ссылкой на ревизию стандарта.

Это собственно незачем и делать. Комитет, кроме собственно стандарта предназначенного для разработчиков компиляторов, выпустил так-же "Rationale" , AKA руководство для пользователей.

Написание function(void) именно тогда и было введено, и именно в противовес function(), которое трактовалось иногда в отсутствие стандартов, производителями компиляторов подтянувших фичи C++, и как то, что об агрументах ничего неизвесто и позволяло таким образом тупо посылать компилятор нафиг с его контролем. То есть получался не прототип функции, а отключалка контроля.

C появлением первого-же Стандарта языка, появились и прототипы, и соответственно официальный способ описать прототип функции без параметров - function(void). А не кем-то, когда-то используемый на свое усмотрение для этой цели function(). А function(); является соответственно ошибочным прототипом, на который компитяторы ругаются по умолчанию предупреждением (для обеспечения совместимости с разнообразными достандартными исходниками), как по той-же причине ругаются предупреждением, а не ошибкой, на отсутствие прототипов, котрых так-же не было у K&R.

Молодец, нашёл.

Повторяю:

Как то вяло все происходит, учитесь у профи
https://scontent-ams2-1.xx.fbcdn.net/hphoto...amp;oe=56A4AFCB

Понять бы, вообще, суть текущей переписки.

Как откусить яблоко. Сериал. Многоходовка.

IAR на прототип с пустыми скобками не ругается. И правильно делает. Если считает их однозначно пустым списком. А бэк совместимость логичнее задавать опцией компиляции.

По поводу пустых скобок в for() ошибся, т.к. никогда его не использую, он пишется for(;;).


Это криво. Неявный int тоже криво.

void, как и другие стандартные типы, при встрече в коде является началом объявления типа объекта. В пустом списке параметров нет ни одного объекта.

Ну то есть что вы сначала оспаривали мои слова, а потом с ними согласились, это мой провал? Ну ок, "гуру" меня размазал.


Неявное объявление функции при первом использовании - вот, наверное, самое отвратительное в сях.

Не утруждайтесь. Это такой стиль. Или как принято говорить: двойные стандарты. Когда я в этой теме просил "гуру" дать ссылки на подтверждение своих голословных заявлений (http://electronix.ru/forum/index.php?s=&showtopic=130098&view=findpost&p=1361284) , то "гуру" не соизволил ничего ответить по существу дела. Вместо этого "гуру" зачем-то приплёл не относящийся к делу пустой "for(;;)" прекрасно понимая что это совсем не эквивалент do-while-zero конструкции. Забавно получилось, что "гуру" вместо признания своей ошибки начал загонять себя ещё глубже, ссылаясь на "творца Си" Денниса Ритчи. Однако, "гуру" забыл что в сеть попали исходники самых первых трансляторов. По исходникам становится очевидно, что конструкция for вообще отсутствовала в первом компиляторе а для циклов "творец" использовал while.

P.S. Будьте добрее. Всем хороших выходных.

С Вашей глупостью
http://electronix.ru/forum/index.php?showt...t&p=1371217
согласиться не могу. То, что Вы сейчас пытаетесь выкручиваться делая вид, что якобы писали о чем-то другом, тоже глупо .

мне кажется вы ошибаетесь....

даже вот человек пишет

именно это и была проблема что void это как бы тип, и его только потом расширили до пустоты то есть function(void) - это такая специальная синтетическая конструкция, и появилась она не сразу, я видел это в изменениях, то есть в каких-то ново введениях.

Вам просто следовало-бы наконец понять, что "do-while-zero" является сама по себе ненужным трюком и еще в каких-то "эквивалентах" не нуждается.



Давайте начнем с того, что его не когда-то "потом расширили", а именно сразу в САМОМ ПЕРВОМ СТАНДАРТЕ языка Си, как только он в Си а не в ++ появился.
До первого стандарта было только неформальное описание языка K&R и ничего более.
До первого стандарта не было вообще прототипов функций, как и void. Как только появились стандартизированные прототипы функций, появилися прототип
function(void); прототипа function() не существовало ни у K&R ввиду отсутствия прототипов как таковых, ни в стандатах, где забит уже function(void).
Так-что прототип function() это калька писателей компиляторов в период бесстандартности, когда подтягивали безусловно эту безусловно полезнейнейшую фичу из C++.
А что Вы скажете о таком использовании void:
(void)argument;

Скажу "замечательно!"

Могу в ответ сказать, что Вы не поняли к чему и вообще о чем был задан вопрос.

Формально мой ответ соответствует вашему вопросу.
Конкретнее, "прочитать аргумент, но не использовать". Здесь главное прочитать.

Ну разве только формально, поскольку вырван из контекста.

Для "прочитать" следует просто указать имя volatile переменной, коими являются (обязаны быть объявлены) и всякие железные регистры и никакого void в Вашем примере ни нафиг не нужно. Вот такие дела.
И вопрос был об аргументие переданном функции. Чего его читать-то? Вот он уже лежит, например, в регистре.

Об аргументе функции - в этом участвовать не буду, не нахожу смысла.
О том, что написал. LCKR, естественно, volatile. И как же мне его обязательно прочитать? GPIOB->LCKR; и всё?

Смысла в чем? В раборках с концептуальной "чиcтотой" использования void, или в самой конструкции? Сама конструкция ОЧЕНЬ полезна - пользуюсь постоянно.

И все

Да, в разборках... не вижу смысла.
А когда пользуетесь "конструкцией"? Указатели обезличиваете?

Не пробовал. Проверю на досуге. Буду знать.
Я поначалу временную переменную заводил. Потом подсмотрел здесь на форуме (void), стал применять, довольный. А оно вона как, оказывается.

Приведение к void - это просто способ явно указать, что результат чтения переменной отбрасывается. Для улучшения читаемости кода и/или подавления возможных предупреждений компилятора.
Как-то даже натыкался на статейку, в которой авторы изучали разные языковые конструкции для чтения переменной и отбрасывания результата. Изучали с точки зрения совместимости с разными компиляторами. Надо сказать, протестированные компиляторы выступили хреново. Стандарт языка не оставляет сомнений (как мне кажется), что достаточно написать выражение, состоящее только из имени переменной. Далеко не все компиляторы были согласны. Но это было давно, может быть, с тех пор стало получше.

Расстроили Вы меня .
Это игнорирование неиспользуемых аргументов.

Ага .

Хорошо, а если бы LCKR не был volatile, какая разница? Задано "прочитать", пусть читает. При оптимизации такой оператор может быть выброшен, понятно. А без оптимизации, значит, прочитается?


Что это означает?

Уточните, с чем это они "не согласны"? Просто имя НЕ volatile перемеменной, это ее чтение, что есть бессмысленная операция, предупреждение и выкидывание оптимизатором, если умеет. Два других помянутых варианта совершенно однозначны.





Описка - аргументов.

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

То что нельзя оптимизировать цикл while(temp) при том что temp объявлен volatile, это скорее следствие. То есть я хочу подчеркнуть что volatile - это не запрет на оптимизацию переменный, а указание использовать ее значение из памяти, и уточнять его каждый раз когда переменная нужна.

Однако из этого не следует что встретив в тексте
temp;
мы обязательно должны его прочитать, если a=temp; то да, должны прочитать значение из памяти и пихнуть его в а, просто потому что мы указали что temp должен всегда уточняться, но если он не используется, то и читать его не надо. Так что понять компиляторы и их авторов которые такие строчки пропускали в целом можно.

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


если это было не понятно, то

прям стало супер понятно%)....

пример бы привели, а не 3 поста вокруг одного и того же...

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

1) Если в работе используется только один компилятор. (IAR к примеру)
2) Если в работе используется только одна архитектура. (ARM к примеру)
3) Если в работе участвует только один человек. (С высокой культурой программирования)
4) Если в работе не требуется следовать стандартам индустрии. (MISRA C к примеру)
5) Если в работе не требуется использовать макросы-как-функции. (Для целей отладки, например)
6) Если в работе используется компилятор с полностью отключенной оптимизацией, или настолько древний, что константы в условиях не обрабатываются на стадии компиляции.
7) Если в работе принято не признавать своих заблуждений.

Такие теледвижения свидетельствуют только о незнании и неуверености . Типа постучать в бубен, поставить свечку
Причем они все бесполезны, ибо описаные действия БЕССМЫСЛЕННЫ и ВЫКИДЫВАЮТСЯ компилятором. Проделайте все эти бессмысленые телодвижения с НЕ volatile переменой и получите пшик .
Вот и поучается, что необходимо и достаточно только упоминания имени volatile переменной.




Все мимо.



Удивился. Проверил.


На
void dummy();
не ругается. Но, зато и за прототип его НЕ признает и на функцию
void dummy()
{
}
ругается:
Error[Pa045]: function "dummy" has no prototype

Вывод - косяк в IAR , который вместо выругаться на КРИВОЙ прототип по месту его объявления, ругается на то, что отсутствует протоип по месту функции.

GCC тут поступает чуть более корректно, СРАЗУ говорит, что фигня это (в смысле вызов функции), а не прототип:
warning: function declaration isn't a prototype [-Wstrict-prototypes]

P.S.
Ну и раз уж добрался до компилятора, специально для Golikov A.

Тот самый "пшик" оставшийся от всех ненужных телодвижений.
А вот без глупостей, но с volatile:

Дык ради чего весь сыр-бор? Прочитать volatile-переменную. Вот просто не читали (если заглянуть в ассемблерный листинг).

Не знаю, что должна показать эта ссылка, у меня недостаточно прав для её просмотра. И не знаю, что это за айпишник в ссылке, он не мой.
Что я писал здесь, и с чем вы спорили, это что int function(); и int function(void); в сях - разные вещи, и что первый вариант позволяет передать функции любое число аргументов. Вы сами это позже подтвердили, так в чём же моя глупость?


Если бы её подтягивали из C++, она бы и работала как в C++ - означала бы, что функция не принимает аргументов. Нет?


Объявление функции с пустыми скобками - это не прототип по определению, но всё ещё допустимая стандартом конструкция.

Из черновика c89:
The empty list in a function declarator that is not part of a function definition specifies that no information about the number or types of the parameters is supplied.

Из черновика c11:
The empty list in a function declarator that is not part of a definition of that function specifies that no information about the number or types of the parameters is supplied.


Это если включить "require prototypes".

Я вот ни разу с 80x годов таких "компиляторов" не встречал, хотя, конечно, в те годы компиляторы багами изобиловали . Ну и кроме всего прочего, как видно из приведенного выше примера, если вдруг компилятор решил не читать переменную, то заставить его "простыми" и "понятными" методами не получится в принципе. Ну разве только отключение оптимизации начисто, да и то это не надежно. Остается только считывание в другую глобальную volatile переменную. Что есть извращение.
Но на самом деле все работает, как предписано и без всяких уродливых мер.


Утомили, глупость в том, что function(); это ВООБЩЕ НЕ СИ. И в достандартные времена в неуоторых НЕ стандартных реализациях позволял так через ануc ОТКЛЮЧАТЬ контроль за аргуметами вообше, но никак НЕ передавать любое количество аргуметов. В Си вообше нельзя передать "любое" функции с переменным числом аргументов, ибо есть совершенно обьективное ограничение - минимум один должен быть.

Подтягивали наличие прототипов, а не делали из Си С++, но в том-то и дело, что до введения стандарта, делали это как попало.

Да? А если ВЫКЛЮЧЕНО, то как тогда быть с СОБЛЮДЕНИМ Стандарта требующего наличие прототипов?
Это не говоря уже том, что СУТЬ В ТОМ что дивная дефиниция function(); игнорируется, повторяю - ИГНОРИРУЕТСЯ компилятором, и НЕ, как Вы вбили себе в голову, НЕ являтся прототипом функции с любым количеством аргументов. И эту, как Вы теперь пытаесь выкручиваться, "допустмую стандартом" неведомо для чего конструкцию, тот же GCC принимает за вызов функции и ругается на этот "прототип", что он не имеет прототипа . Ах, да, тоже можно отключить требование соблюдать стандарт и использовать прототипы.
Ну не надо принимать наличие в Си мночисленых заплаток и костылей с помощью которых стараются обеспечить компиляцию всяких разных исходников писанных неведомо когда и неведомо кем, за НОРМУ.

Такой синтаксис до сих пор разрешается стандартом, значит это си.
В си есть возможность ПЕРЕДАВАТЬ функции любое число аргументов. Как и зачем их ПРИНИМАТЬ в функции (не обязательно написанной на си, к слову) - совсем другой вопрос.


Ну покажите уж, где это он строго требует?


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


Прототипы я вообще не упоминал до прошлого сообщения.


Не "можно отключить", а "можно не включать", оно по умолчанию выключено. И не "требование соблюдать стандарт", а "строгие" требования. Ещё раз, объявление функции с пустыми скобками разрешено стандартом. С примечанием об устаревании, но разрешено.


А где я говорил, что считаю эти костыли чем-то хорошим? Оно просто есть, и я ничего с этим поделать не могу.

Из того, что Вы не написали ни разу слово "прототип", теперь вдруг следует понимать то что Вы тут, оказыватся, рассказываете о чем-то другом?
Очень хотелось-бы тогда узнать о чем? А то стало совсем нереальным понять к чему вообще тогда относится Ваше ставшее теперь совершенно загадочным утверждение с которого все и началось:

И чем, тогда по Вашему являются эти самые int function(); и int function(void);
если не прототипами?

Объявлениями (declaration) функций. Вторая из них заодно и прототип, первая - нет.

Такие телодвижения свидетельствуют об опыте работы в команде....

С меня если я напишу несколько лишних строчек, которые выкинет компилятор, при этом сделав правильный код (я кстати не говорил об отмене volatile я говорил лишь о том что явно делаю чтение) не убудет. А вот если мой коллега, чуть менее опытный или чуть более уставший занимаясь поиском непонятной ошибки потратить на разборку того что происходит на лишних 30 секунд меньше для проекта станет лучше.

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

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

Следуя вашей тактике то и асершины в коде - это баловство и бла бла бла....

Вот кстати зачем вводили воид в скобках, для явного отличия прототипа от вызова для тех кто делает все не по уставу%)

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

Лучше команду подтягивать под свой гениальный уровень, чем опускаться до уровня быдлокоманды. Я за перфекционизмъ.

Черт! Вот они правильные слова. Действительно за использованием прототипов я начисто забыл, что раньше по совершенно объективной необходимости знать, что возвращает функция, если она возвращает не int по умолчанию, надо было это как-то указывать. Так-что int function(); действительно не протип, а декларация возвращемемого значения.


Так в том-то и проблема, приведенного Вами примера, что все Ваши "лишние строчки", НИКАК НЕ СПОДВИГЛИ компилятор слелать "правильный код". Что я и нагляднейшим образм показал на компиляции Вашего примера.

А что должен подумать я, чуть более опытный, читая эту билеберду в поиске ошибки? Я ведь буду тратить время на поиск смысла, а что хотел сказать автор этим кодом? Может он хотел что-то сделать, но ошибся? B главное все признаки на это указывают - что-то написано, но это ничего не делает полезного? Лучше напишите для своего коллеги не понимающего азы языка, комментарий! Он хоть чему-то научится, вместо того, что бы "научится" тиражировать эту бесполезную муть.

Читайте выше НЕ для этого. Для отличия от декларирования возвращаемого функцией значения. Которое, теперь сдедует признать, было сделано изначально через анус . Логичнее было что-нибудь в общем стиле:
extern int function();
хотя и так "по правильному" можно писать, но проблема в том, что можно и без extern , что и создает путаницу в отличие от декларирования, например, переменных.


Именно так - c комментарием для незнающих языка, НО только (void) категорически лишний. Он никак не способствует чтению и только приносит вред МАСКИРУЯ выброс компилятором чтения, если вдруг по ошибке переменная окажется не volatile.

Ну это дело вкуса, как и while (1). Можете спорить до посинения, но я никогда не соглашусь, что while (1) - это какое-то вселенское зло, то же самое и (void)

Я более, чем прямо написал почему он ВРЕДНЫЙ, и это совершенно НЕ дело вкуса. Что не понятно-то?


1) Это не вселенское зло.
2) Просто "привычный" мусор .

ну, ну.... чуть более опытный не будет спорить до посинения, не слушая аргументы других людей....




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


что есть

Аргументы, были не только выслущены, но и разбиты с приведеним даже результатов того, как Вас понял компилятор. Спорить вообше не о чем.





Все уже предельно ясно бвло написано в первом абзаце:

Что конкретно не понятно? Что существует декларация функции, которая хоть де-факто отмерла с появлением прототипа функции, но все-же требуется необходимость их отличать друг от друга и от определения функции?

только не были понятыми, ну да ладно....


было непонятно
прототип
декларация
определение
у меня 2 из них как бы одно, примерчик бы с текстом и указанием где кто из них кто....

Меня можете не понимать, но то, что Вам сказал компилятор понимать просто ОБЯЗАНЫ. А компилятор Вам сказал, что Ваши пляски с бубном ему фиолетовы и он их выбросил и переменную читать не стал, а что делать при простом упоминании volatile переменной ему, напротив, совершенно понятно.


Это, не одно и тоже. Прототипы появились позже. А необходимость декларировать тип возвращаемого значения функции таки была всегда.
Так-что прототип это декларация, но декларация это не протототип

Дык, те самые две неоднократно упоминаемые строчки.

Вы даже не поняли что меня не поняли ...

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

чтение из temp думаю знают процентов 10 если не меньше
а вот строку вида

правильно интерпретируют 99% (на вас я 1% запас)

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



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

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

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

char *function();
...
extern char *ptr;
...
ptr = function();
...
...

Двоечников всегда было больше... и что теперь... таблицу умножения переписывать заново... под каждого???

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

но старые исходники все еще живут. Если не быть "чукча писатель", то читать и понимать написанное, тоже надо уметь.