Имеется функция:
char *StrFunc(char const *str) {}
Внутри она использует str именно как char const * (только чтение) и потом возвращает например: str+N (N - типа int).
Но в качестве вх. аргумента в неё могут передаваться как char * так и char const * - нет проблем, приведение типа делается автоматом.
Но хочется, чтобы и возвращаемое значение было того же типа, что и передано: для char * - char *, для char const * - char const *.
Чтобы не было необходимости делать: char const *s; ... ; s = (char const *)StrFunc(s);
Понятно, что можно объявить inline функцию, в которой сделать приведение к нужному типу. Но тогда, с низким уровнем оптимизации, функция не будет заинлайнена.
Или можно перегрузить эту функцию с другим типом аргумента/возвращаемого значения - опят будут две функции, выполняющие одно действие.
Может есть более элегантное решение?
Как бы так объявить алиас для данной функции с другим типом аргумента/возвращаемого значения?

Функция принимает указатель на const, возвращает указатель по сути на тот же объект, но убирает const. Это нечестно.

То есть должно быть 2 функции:

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

Проверка типов сохраняется, всё работает. Логично?

Не используйте столь низкие уровни оптимизации.

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

Я об этом и говорю.


Плохое решение. Две имени (функций) выполняющие одно и то же действие. И придётся каждый раз думать - какое имя подставить.


А как жить тогда? Ведь уже при уровне "Medium" не производится inlining, а при более высоких - отладка практически невозможна. (


Это я знаю (см. исходное сообщение). И это ведёт опять к тому-же - или два раза одно и то же тело описывать или вызывать через inline одно общее тело.
Вот если-б можно было один раз описать, а для второго списка аргументов использовать что-то типа typedef
typedef Func1 Func2;

шаблоны (template) позволяют такие выкрутасы, но ИМХО, это еще более корявая реализация, чем двойное тело функции.

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


Как жить? Жить и не тужить. Можно подумать, от того, что функция не будет заинлайнена, небо упадёт на землю. Это всё вредные предрассудки, избавляйтесь от них.

Тут есть тема (Не)доработки языков программирования, которые хотели ли бы вы
наверное надо туда тему перекинуть - пусть обмозгуют, обжуют

Отлаживайтесь в окне дизассемблера. Отладка в этом окне возможна при любом уровне оптимизации. Я делаю именно так.

Это лучше. А что, у вашего компилятор нет _Pragma("inline=forced")?

Шаблон таже двойная (энная) реализация. И ябы не сказал что корявая.
По крайней мере для простых применений (какие я пользую) - самое-то.

Вариант :


Это была больше шутка, впрочем иногда вполне годная .

Самое близкое к описанному Вами поведение даст _Generic (стандарт С1х), как-то так:

Т.е. Вашу функцию делаете в виде char* __StrFunc(const char* str), а потом везде вызываете макрос StrFunc. Поведение будет точно такое, как Вы писали:


Еще можно сделать макросы с использованием typeof или __auto_type (расширения GCC).

Что-то не понял, почему нельзя возвращать указатель на константу? Тогда оно "само" приведётся к неконстанте, если потребуется.




UPDATE. Чёрт, опять часть варнингов потерялась...

Да-а, беда. Плюсы с перезагрузкой ждут Вас :-)

https://gcc.gnu.org/onlinedocs/gcc-4.4.7/gc...r-Builtins.html

__builtin_constant_p

Вот именно.


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


У меня IAR

А вариант с union вам не подойдет ?

Какой? Возвращать union {char *; char const *;}; ?
Ну так задача-то была - чтобы при вызове не городить преобразований типов. А тут ещё более громоздкий вызов получается...

Что мешает объединить? Т.е. перегруженная функция, которая просто является inline-const-оберткой для второй? Кроме принципиального нежелания переименовывать исходник .c->.cpp других препятствий не видно. Видно стойкое желание колоться, плакать, но продолжать кушать кактус.

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

Патологический перфекционизЬм детектед! Срочно вызывайте санитаров

Под рукой нет компилятора, но, на мой взгляд, было бы хорошо подумать над передачей не указателя, а указателя на указатель:

В качестве параметров, опять же, либо char*, либо const char* - приведется автоматически, а в теле изменяете *str. В возвращаемом значении возвращаете, получилось сдвинуть или вылезли за границу строки... Оно?

P.S. Только щас обратил внимание на дату сообщения... Сорри

И сделать текст исходника ещё более громоздким? И получить более громоздкий скомпилированный код?
Если было например:
char const *s; ... ; s = (char const *)StrFunc(s + 5);
то теперь будет ещё более громоздкая запись с сохранением в промежуточную переменную перед вызовом и чтением из неё - после.
Получим гораздо более развесистый текст. А уж код какой получится!.... Вместо простого ADDS R0, Rx, #5 перед вызовом, теперь будет: выделение места на стеке + запись в стек (s+5) + чтение из памяти внутри функции + удаление стекового фрейма после вызова функции - команд получается в несколько раз больше.