我可以在编译时检测作为编译时常量的“函数参数”吗

Question

能否在编译时检测“函数参数”¹ 是否为编译时常量？

例如一个函数print(int i)，如果调用为print(5)，则可以打印"constant 5"，但如果调用为print(i)，则"non-constant 5"，其中i是一些非常量变量。特别是，在“恒定”分支中，我应该能够将 i 视为 constexpr，包括将其用于模板参数等。

宏技巧、模板元编程和 SFINAE 技巧都可以。理想情况下，它是可移植的，但特定于编译器的解决方案总比没有好。

如果存在“假阴性”也没关系 - 即，如果常量值有时被检测为非常量（例如，当某些优化被禁用时）。

如果解决方案可以检测到常量值何时间接传递给函数（例如，当常量值传递给调用print 并且随后内联将常量暴露给print 的中间函数时），则加分.最后一种行为显然取决于优化。

如果自然扩展到多个参数，则加倍加分。

如果可以有带和不带constexpr 参数的函数的重载版本，这可能很简单，但是you can't。

---

¹ 我在这里将“函数参数”放在引号中，因为该解决方案并不严格要求在函数内（或在调用者/被调用者边界使用特殊参数检测此状态） - 它只需像函数一样出现在调用者面前，但可以使用宏或其他技巧，例如带有 operator() 等的静态对象。

Answer 1

它不必是一个普通的函数 void print(int i) - 它可以是一个类似函数的宏，它在它的参数上做一些魔术，并根据它是一个常量还是调用一个不同的函数可能是一些模板魔术

你说的“类函数宏”？

嗯...首先我要警告你，C 风格的类函数宏是危险的。蒸馏邪恶，恕我直言。

这么说，如果你真的接受基于宏的解决方案，我想将它与constexpr 方法、模板struct、static 局部变量和SFINAE 结合起来......

如果定义如下模板PrintStructstruct

template <typename T>
struct PrintStruct
 {
   template <bool>
   static void func (...) 
    { std::cout << "func non-const: " << T::func(true) << std::endl; }

   template <bool b, int I = T::func(b)>
   static void func (int) 
    { std::cout << "func const:     " << I << std::endl; }
 };

和下面的 C 风格函数类宏，它定义了一个 foo 本地 struct 并将其作为模板参数传递给 PrintStruct 以激活 SFINAE 以选择所需的 func()（并调用 @ 987654331@，显然）[EDIT：由 jxh 改进的宏以使其扩展为语句；谢谢！] [EDIT 2：在观察 OP 后修改了宏以接受表达式]

#define Print(i)                          \
[&]()                                     \
 {                                        \
   static int const printLocalVar { i };  \
                                          \
   struct local_foo                       \
    {                                     \
      static constexpr int func (bool b)  \
       { return b ? printLocalVar : 0; }  \
    } ;                                   \
                                          \
   PrintStruct<local_foo>::func<true>(0); \
 }                                        \
()

观察打印的值，在PrintStruct::func()的const版本中，是一个模板整数值； so 也可用于模板参数、C 样式数组维度、static_assert()s 测试等。

不确定这是完全标准的（我不是真正的专家）并且可以做你真正想要的，但以下是一个完整的工作示例

#include <iostream>

template <typename T>
struct PrintStruct
 {
   template <bool>
   static void func (...) 
    { std::cout << "func non-const: " << T::func(true) << std::endl; }

   template <bool b, int I = T::func(b)>
   static void func (int) 
    { std::cout << "func const:     " << I << std::endl; }
 };


#define Print(i)                          \
[&]()                                     \
 {                                        \
   static int const printLocalVar { i };  \
                                          \
   struct local_foo                       \
    {                                     \
      static constexpr int func (bool b)  \
       { return b ? printLocalVar : 0; }  \
    } ;                                   \
                                          \
   PrintStruct<local_foo>::func<true>(0); \
 }                                        \
()

int main()
 {
   constexpr int  i { 2 };
   int const      j { 3 };
   int            k { 4 };
   int const      l { k+1 };

   Print(1);    // print func const:     1
   Print(i);    // print func const:     2
   Print(j);    // print func const:     3
   Print(k);    // print func non-const: 4
   Print(l);    // print func non-const: 5
   Print(2+2);  // print func const:     4
 }

Answer 2

为了检测constexpr 的适用性，可以考虑这个GCC-only suggestion from @JohannesSchaub-litb（有关限制，请参阅链接答案）：

template<typename T> 
constexpr typename remove_reference<T>::type makeprval(T && t) {
  return t;
}

不同案例的工作示例读取

#include <iostream>

////////////////////////////////////////////////////////////////////////////////

// https://stackoverflow.com/a/13305072/2615118

template<class T>
constexpr std::remove_reference_t<T> makeprval(T&& t) {
  return t;
}

#define isprvalconstexpr(e) noexcept(makeprval(e))

////////////////////////////////////////////////////////////////////////////////

template<bool is_constexpr, class Lambda>
struct HybridArg {
  using T = std::invoke_result_t<Lambda>;

  Lambda lambda_;
  constexpr operator T() const { return lambda_(); }// implicit conversion
};

template<bool is_constexpr, class Lambda>
constexpr auto make_hybrid_arg(Lambda lambda) {
  return HybridArg<is_constexpr, Lambda>{lambda};
}

#define WRAP_ARG(arg)                     \
  make_hybrid_arg<isprvalconstexpr(arg)>( \
    [&] { return arg; }                   \
  )                                       \

////////////////////////////////////////////////////////////////////////////////

template<int i>
void print_impl_constexpr() {
  std::cout << i << ": ";
  std::cout << __PRETTY_FUNCTION__ << std::endl;
}

void print_impl_fallback(int i) {
  std::cout << i << ": ";
  std::cout << __PRETTY_FUNCTION__ << std::endl;
}

////////////////////////////////////////////////////////////////////////////////

// option 1 (for choosing implementation):
// compile-time introspection

template<class Arg>
struct is_constexpr_arg : std::false_type {};

template<class Lambda>
struct is_constexpr_arg<
  HybridArg<true, Lambda>
> : std::true_type {};

template<class Arg>
void print_by_introspection(Arg arg) {
  if constexpr(is_constexpr_arg<Arg>{}) {
    print_impl_constexpr<arg>();
  }
  else {
    print_impl_fallback(arg);
  }
}

////////////////////////////////////////////////////////////////////////////////

// option 2 (for choosing implementation):
// overload

void print_by_overload(int arg) {
  print_impl_fallback(arg);
}

template<class Lambda>
void print_by_overload(HybridArg<true, Lambda> arg) {
  print_impl_constexpr<arg>();
}

////////////////////////////////////////////////////////////////////////////////

template<class Arg>
void indirection(Arg arg) {
  print_by_introspection(arg);
  print_by_overload(arg);
}

void bad_indirection(int arg) {
  print_by_introspection(arg);
  print_by_overload(arg);
}

////////////////////////////////////////////////////////////////////////////////

int main() {
  {
    int i = 0;
    indirection(i);
  }
  {
    int i = 1;
    indirection(WRAP_ARG(i));
  }
  {
    constexpr int i = 2;
    indirection(WRAP_ARG(i));
  }
  {
    constexpr int i = 3;
    bad_indirection(WRAP_ARG(i));
  }
}

用 GCC 编译后的输出：

0: void print_impl_fallback(int)
0: void print_impl_fallback(int)
1: void print_impl_fallback(int)
1: void print_impl_fallback(int)
2: void print_impl_constexpr() [with int i = 2]
2: void print_impl_constexpr() [with int i = 2]
3: void print_impl_fallback(int)
3: void print_impl_fallback(int)