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

Недавно мне задали задачку, в обсуждении всё свелось к следующему: - есть объект, в нём есть методы. Каждый метод/ы требует загрузки какой-то логики в рантайме. Хотим точно знать - какие методы были вызваны, после в рантайме затребовать загрузки только нужной функциональности.

Фокус базируется на нескольких базовых свойствах

struct a {
  
  static inline auto x = 123;//статическая инициализация происходит
  //до старта программы, которая main
};

struct b {
  
  static bool f() {
    return true;
  }
  static inline auto x = f();
};

Здесь static inline auto x = f() - инициализация зависит от результата, значит в процессе необходимо вызвать функцию. Любые побочные эффекты в функции будут исполнены, даже несмотря на то, что там return true - это базовая семантика языка.

таким образом, подобная программа:

#include<cstdio>

struct c {
  static bool f() {
    fprintf(stderr, "%sn", __PRETTY_FUNCTION__);
    return true;
  }
  static inline auto x = f();
};


int main() {
  fprintf(stderr, "%sn", __PRETTY_FUNCTION__);
}

выведет:

static bool c::f()
int main()

Самый очевидный паттерн использования - это

template<typename> struct plugin {
  
  static bool f() {
    fprintf(stderr, "%sn", __PRETTY_FUNCTION__);
    return true;
  }
  static inline auto x = f();
};

struct my_plugin: plugin<my_plugin> {};//подобное работать не будет

Правило здесь простое - любые сущности внутри полиморного/шаблонного контекста инстанцируются лениво, т.е. только при обращении.

template<typename T> struct test {
  auto f() {
    T x = "";
  }
};

test<int> _;//никакой ошибки не будет.

Это позволяет не платить за то, что не используем

возьмём подобный пример:

template<auto x> struct integral_constant {
  constexpr operator auto() const { return x; }
  
  template<auto y> constexpr integral_constant<x % y> operator%(integral_constant<y>) const { return {};}
  template<auto y> constexpr integral_constant<x + y> operator+(integral_constant<y>) const { return {};}
};

static_assert(integral_constant<1.>{} + integral_constant<2.>{} == 3.); - не нужно реализовывать то, что мы не используем. В данном случае %

Таким образом, если в integral_constant есть operator%, а параметризуем мы её(integral_constant) double для которой % не определена - всё работает

Аналогично с остальным:

static_assert(integral_constant<3>{} % integral_constant<2>{} == 1);


constexpr auto test_mod(auto a, auto b) {
  return requires {
    a % b;
  };
}


static_assert(!test_mod(integral_constant<1.>{}, integral_constant<2.>{}));
static_assert(test_mod(integral_constant<1>{}, integral_constant<2>{}));

Есть важный момент - sfinae. Если мы хотим от подобных методов такого же поведения как у дефолтных реализация операторов, допустим для того же double - необходимо вынести все зависимости в сигнатуру. В данном случае я вынес ихтак: integral_constant<x % y> - мы не сможем инстанцировать эту сигнатуру если между x и y не определено %. Если же мы попытаемся перенести это в теле - sfinae будет пробиваться.

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

Решение проблемы выше очевидно - нужно использовать поле вне полиморфного/шаблонного контекста

struct my_plugin2: plugin<my_plugin2> {
  static inline auto x = plugin::x;//сайд-эффектом этой инициализации является вызов plugin<my_plugin2>::f.
  //То, что нам и нужно
};

Осталось лишь совместить все вместе

template<auto tag> struct registry {
  static auto push() {
    fprintf(stderr, "%sn", __PRETTY_FUNCTION__);
    return true;
  }
  static inline auto x = push();
};

#undef NDEBUG
#include<cassert>

template<typename = void> struct object {
  void a() {
    assert(registry<&object::a>::x);
  }
  void b() {
    assert(registry<&object::b>::x);
  }
};

void test_registry() {
  object o;
  o.a();//static auto registry<<anonymous> >::push() [with auto <anonymous> = &object<void>::a]
  //o.b();//static auto registry<<anonymous> >::push() [with auto <anonymous> = &object<void>::b]
}

Так же мы можем воспользоваться свойством static_assert, который требует конвертации выражения в constexpr но не требует всего выражения как constexpr

constexpr integral_constant<true> true_;

template<auto tag> struct registryv2 {
  static auto push() {
    fprintf(stderr, "%sn", __PRETTY_FUNCTION__);
    return true_;
  }
  static inline auto x = push();
};

template<typename = void> struct objectv2 {
  void a() {
    static_assert(registryv2<&objectv2::a>::x);
  }
  void b() {
    static_assert(registryv2<&objectv2::b>::x);
  }
};

void test_registryv2() {
  objectv2 o;
  o.a();//static auto registryv2<<anonymous> >::push() [with auto <anonymous> = &objectv2<void>::a]
//   o.b();//static auto registryv2<<anonymous> >::push() [with auto <anonymous> = &objectv2<void>::b]
}

template<typename T = void> void f() {
  static_assert(registryv2<&f<T>>::x);
}

void test_f() {
//   f();//static auto registryv2<tag>::push() [with auto tag = f<>]
}




int main() {
  fprintf(stderr, "%sn", __PRETTY_FUNCTION__);
}

Запретить сувать так просто в шаблон какие-то аргументы можно очень просто:

using private_unique_type = decltype([]{});

template<typename T = private_unique_type> void f2() {
  static_assert(__is_same(T, private_unique_type));
  static_assert(registryv2<&f2<T>>::x);
}


void test_f2() {
//   f2();
}

Полный текст, с которым можно поиграться.