可以通过编译时已知的对象创建类型（或实例化模板）吗？

Question

假设我有一个模板函数：

template <typename T, T value>
auto foo(std::integral_constant<T, value>)
{
     if constexpr (value == 0)
     {
         return int{};
     }
     else
     {
         return float{};
     }
}

我想使用数字常量来调用它：

foo(4);

可以实现吗？如果没有，为什么？

我发现我可以自己创建 std::integral_constant ，但我对从对象创建类型的想法感兴趣。在上面的示例中，我将 4 作为对象，将 std::integral_constant 作为类型。

声明一些 define 来执行 if 或 switch 并不是一个解决方案 - 它会包含大量代码并且速度很慢。

Answer 1

这是函数的调用语法：

auto x = foo(std::integral_constant<int, 24>{});
// or
auto y = foo<int, 24>({});

---

但是您不需要 integral_constant。您可以简化为：

template <int value>
auto bar()
{
     if constexpr (value == 0)
         return int{};
     else
         return float{};
}

auto test()
{
    auto x = bar<24>();
}

---

但从您的描述来看，这也不是您真正想要的。虽然不是很清楚，但看起来您想要一个基于值的类型。如果是这种情况，那么您需要类型别名，而不是函数，因为函数返回值而不是类型。

这是类型别名版本：

template <int Value>
struct my_type
{
    using type = float;
};


template <>
struct my_type<0>
{
    using type = int;
};

template <int Value>
using my_type_t = typename my_type<Value>::type;


using T = my_type_t<24>;
using U = my_type_t<0>;

Answer 2

我绝对不推荐这样做，但您可以使用宏来实现您想要的语法：

template <auto value>
auto foo_impl()
{
     if constexpr (value == 0)
     {
         return int{};
     }
     else
     {
         return float{};
     }
}

#define foo(constant) foo_impl<constant>()


int main(){
    auto should_be_int = foo(0);
    static_assert(std::is_same_v<int, decltype(should_be_int)>);

    auto should_be_float = foo(1);
    static_assert(std::is_same_v<float, decltype(should_be_float)>);
}

演示

最终你最好暂时坚持bolov的答案直到constexpr 函数参数 (P1045) 已标准化（或类似的东西）。