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

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

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

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

Суть проблемы

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

    #define MACRO   name
    #define MACRO() name() <-  error: 'MACRO' macro redefined [-Werror,-Wmacro-redefined]

Предположим, у нас есть переменная, имя которой нужно изменять во время компиляции, например, в зависимости от каких либо условий. И в общем виде это решается элементарно #define NAME new_name. То же самое можно сделать и для функции #define FUNC(...) func_name(__VA_ARGS__). А так как имена переменных и функций должны быть уникальны в своей области видимости, то и с определениями макросов, кажется, нет каких либо проблем, т.к. уникальность имен требуется как для препроцессора, так и для компилятора.

    #define FUNC(...) func_name(__VA_ARGS__)
    int func_name=0; <- error: redefinition of 'func_name' as different kind of symbol

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

    #define NAME(...)  name(__VA_ARGS__)

    int NAME(int arg=1){
        return arg;
    }

    int res = NAME();
    auto ref = &NAME; <- error: use of undeclared identifier 'NAME'

Рабочий вариант:

    #define NAME  name

    int NAME(int arg=1){
        return arg;
    }

    int res = NAME();
    auto ref = &NAME;

Внимание, вопрос.

Как не используя макросы препроцессора С/С++ можно переопределить имя функции как при её вызове, так и для операции взятия адреса функции? Мне кажется, что я перепробовал все варианты, но решения так и не нашел.

Update 1

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

Update 2

Еще более изящное решение вообще без макросов и переопределений подсказал fk0 в своем комментарии:

Ещё может помочь опция линкера -Wl,--wrap=symbol, кстати. Все ссылки на
symbol будут вести в __wrap_symbol (который нужно определить
самостоятельно), а старую функцию можно вызвать как __real_symbol.
Такое обычно используется когда нужно переопределить библиотечную
функцию или делаются mock-функции.