0
Вот только кто бы это ещё поддерживал. gcc точно нет. Или уже да?

Сомневаюсь :) Оптимизация рекурсии – не самая типичная задача для структурных ЯП (в отличии от функциональных). А что у Вас за задача, которая требует рекурсивного вызова инлайн функций?
  • avatar
  • e_mc2
  • 07 апреля 2015, 22:07
+1
MySQL

Сдаюсь, коллега. У меня просто не осталось контраргументов. Признаю, синтаксис рекулярок прост и легко читается. Теперь, когда я буду разбирать очередную длинную регулярку – мне будет намного легче.
  • avatar
  • e_mc2
  • 07 апреля 2015, 19:57
0
по вашему же примеру использование макроса MIN универсально для всех типов данных, целых, вещественных числах и даже строках и структурах.

Ну, насчет строк и структур Вы перегнули (если мы не говорим о С++ с перегрузкой операторов сравнения) :) И это, как раз, может стать причиной ошибки из-за отсутствия контроля типов.
  • avatar
  • e_mc2
  • 06 апреля 2015, 22:57
+1
если прогер пишет inline — значит inline
Ну, это решили отдать на откуп компилятору (хотя да, согласен, не очень логично)

Но с макросами та же проблема — единственное что мы знаем – что препроцессор выполнит замену. Что будет дальше – зависит от компилятора.
  • avatar
  • e_mc2
  • 06 апреля 2015, 22:40
0
Я считаю, что надо послушать e_mc2

Странно, вы поддержали мое мнение сразу в 2-х топиках :) Это точно старый-добрый well-man2000 или у Вас аккаунт увели?
  • avatar
  • e_mc2
  • 06 апреля 2015, 22:13
0
инлайновая функция это вообще болезнь всех умных компиляторов. Я считаю, одна единственная уважительная причина игнорировать это требование — рекурсивный вызов.

Но совсем понял. В чем проблема с инлайн функцией и как это связанно с рекурсией?
  • avatar
  • e_mc2
  • 06 апреля 2015, 22:10
0
Ну, Вам решать.

Мой опыт диаметрально противоположен (и пример с MIN(ReadADC(), 100)
я привел из своего опыта :)

а вот с темой «слишком умного компилятора» уже знаком
С чем именно вы столкнулись? При включенной оптимизации компилятор не инлайнил функцию но инлайнил аналогичный макрос?
  • avatar
  • e_mc2
  • 06 апреля 2015, 21:23
+1
Иногда эти ну слишком умные компиляторы не хотят инлайнить функции по своему, неведомо никому усмотрению.

С макросами может произойти обратное, сначала препроцессор сделает подстановку макросов, потом «слишком умный компилятор» увидит повторяющийся однотипный фрагмент кода и вынесет его в «подпрограмму»

Макросы, хоть и похожи по синтаксису на функции, ими не являются, стоит об этом забыть, и невинный макрос
#define MIN(a,b) ((a>b)?b:a)

при определенных условиях становится жутким и трудно выявляемым багом
int I = MIN(ReadADC(), 100);


Не говоря о других проблемах, типа синтаксиса и типобезопасности.
  • avatar
  • e_mc2
  • 06 апреля 2015, 19:40
+3
Все же, коллеги, почему макросы а не энамы и инлайн фикции?
Единственный довод в пользу макросов – существуют древние компиляторы, которые эти сами энамы и инлайны не поддерживают. Но разве это актуально (для данной, STM32, платформы)?
  • avatar
  • e_mc2
  • 06 апреля 2015, 18:13
0
очевидное опровержение
Это какое? То, что «а в перле можно …» или то, что на С тоже можно писать нечитаемый код?
  • avatar
  • e_mc2
  • 06 апреля 2015, 13:35
+2
Знатока сразу видно.

:) Это называется «переубедить Вас у меня не получится, поэтому давайте сразу перейдем к оскорблениям…»

Например в перле регэкспы можно,

Коллега Vga несколькими комментариями выше показывал эти возможности в перле. Но, это не решает всех проблем синтаксиса, да и использование регеспов перлом не ограничивается.
  • avatar
  • e_mc2
  • 06 апреля 2015, 13:06
+1
Насколько «нечитаемый синтаксис» у этого ЯП?

Этот код еще относительно понять можно. Вы могли бы привести и более вырожденный случай, типа
main(int riguing,char**acters){puts(1[acters-~!(*(int*)1[acters]%4796%275%riguing)]);}

(взято из этого конкурса).

Что Вы хотите доказать вашим примером?

Язык С дает вам возможность в рамках синтаксиса делать код читаемым (осмысленное название функций, переменных, логичная декомпозиция кода и т. д.). И большинство программистов этой возможностью пользуются :) А вот синтаксис регекспа такими свойствами не обладает (ну или практически не обладает).
  • avatar
  • e_mc2
  • 06 апреля 2015, 12:47
+1
Я: Синтаксис регулярок не читаем …
Вы: Не согласен…
Я: ну так прочитайте…
Вы: Для начала пусть автор напишет комментарии о том, что этот регэксп делает …

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

Если автор напишет комментарии, в которых все распишет, а еще лучше выступит с докладом «как прочитать мою регулярку» — то да, все понятно. Только к читабельности самого регекспа это не имеет отношения. Если исходный код на Brainfack снабдить множеством комментариев – то в программе вполне можно разобраться. Но это не делает Brainfack читабельным ЯП.
  • avatar
  • e_mc2
  • 06 апреля 2015, 12:16
0
А я не говорил, что это просто. Как раз таки я согласен, что длинный регэксп проще написать, чем прочитать.

Эх, коллега, тогда зря Вы поторопились с ответом :) Я хотел услышать комментарии от людей, которые утверждают, что регулярки читать легко (а эта регулярка, хоть и не тривиальна, но не является специально подобранным примером нечитабельности, просто аналогичную по функциональности я когда-то применял в проекте)

ИМХО – у регулярок есть 2 плюса:
— их синтаксис стандартизирован, они поддерживаются практически везде (иногда на уровне самого ЯП)
— они позволяют заменить «десятки строк» простого и примитивного кода на ЯП на одну строку с нечитаемой регуляркой (здесь каждый решает для себя, когда нужно отказаться от «обычного» кода и прибегнуть к регуляркам).

Но для меня странно, что люди не согласны с тем, что синтаксис не читаем, нет нормальных механизмов отладки и т. д. Так можно и Brainfack выставить в лучшем свете, главное «писать надо нормально и комментировать»
  • avatar
  • e_mc2
  • 05 апреля 2015, 21:56
+1
Я ковырял минут 15. При этом я нашел «ошибку», которой там на самом деле нет. После комментария EW1UA пересмотрел снова, и понял, что был неправ. Вот по этому я и не люблю регэкспы :)
  • avatar
  • e_mc2
  • 04 апреля 2015, 12:01
0
я быдлокодер и так и не научился читать регекпы :)
  • avatar
  • e_mc2
  • 04 апреля 2015, 11:30
0
Нет, мы не согласны. Писать надо нормально и комментировать.

:) Ну ОК, только как «писать нормально» в рамках синтаксиса регексп и как комментировать?

Возьмем практический пример. В выражении

^(((0[1-9]|[12]\d|3[01])\.(0[13578]|1[02])\.((19|[2-9]\d)\d{2}))|((0[1-9]|[12]\d|30)\.(0[13456789]|1[012])\.((19|[2-9]\d)\d{2}))|((0[1-9]|1\d|2[0-8])\.02\.((19|[2-9]\d)\d{2}))|(29\.02\.((1[6-9]|[2-9]\d)(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00))))$

(а это просто проверка даты с учетом высотных годов) есть 2 ошибки (одна из них критическая, вторую можно игнорировать). Если Вы настолько легко читаете регексп выражения – для вас не составит труда выявить эти ошибки. Если вы их выявите – я признаю, что я быдлокодер и так и не научился читать регекпы :)
  • avatar
  • e_mc2
  • 04 апреля 2015, 01:07
0
Не понял, что вы хотите сказать данными цитатами.

Повторюсь, Вы согласны с тем, что синтаксис регулярок начитаем?

И дело не в изучении. Изучить синтаксис не проблема, по отдельности он достаточно прост, но как только появляются сложные регулярки – начинаются проблемы. Иногда требуется куча времени, чтобы разобрать регулярку, которую ты же писал год назад…
  • avatar
  • e_mc2
  • 03 апреля 2015, 12:11
0
А кто их использует — говнокодеры и лохи. Нормальный программист не будет себя утруждать их изучением и напишет свой велосипед.

Нет, вы неправильно сделали вывод из моих слов. Я сам их иногда использую, но стараюсь этого избегать.

Я просто говорю, что их синтаксис не читаем, отлаживать их тяжело. Или Вы с этим не согласны?

Если простую регулярку еще можно понять достаточно быстро, то с такой как я привел выше – без 100 грамм не разобраться (и, боюсь, 100 грамм будет мало). Иногда проще написать свою регулярку с нуля, чем пытаться найти ошибку в существующей (что и есть write only)
  • avatar
  • e_mc2
  • 03 апреля 2015, 11:25
0
Да, как по мне, ASM по сравнению с регулярками – вообще милое дело. И комментарии, и код достаточно просто (на уровне синтаксиса) разделить на отдельные операции, которые выполняются последовательно…
  • avatar
  • e_mc2
  • 03 апреля 2015, 01:31