如何通过编译时"if"返回 T 值？

How to return T value through a compile-time "if"?

本文关键字：返回 if 编译 何通过      更新时间：2023-10-16

我想做一些类似的事情：

template<typename T>
T func()
{
    if(T is int)
        return 1;
    if(T is std::string)
       return std::string("hello");//this line will not be able to compile if T is int
}

有人能告诉我怎么解决这个问题吗？THX很多。

例如使用模板专用化。。。

template<typename T>
T func();
template<>
int func() { return 1; }
template<>
std::string func() { return "hello"; }

或者使用CCD_ 1。

template<typename T>
typename std::enable_if<std::is_same<T, int>::value, int>::type func()
{
   return 1;
}
template<typename T>
typename std::enable_if<std::is_same<T, std::string>::value, std::string>::type 
func()
{
   return "hello";
}

如果您不仅需要int/string，还需要可以构造int/string的类型，那么可以使用decltype。

template<typename T>
auto func() -> decltype(int{std::declval<T>()})
{
   return 1;
}
template<typename T>
auto func() -> decltype(std::string{std::declval<T>()})
{
   return "hello";
}

clang编译得很好，但是gcc 4.8不能并且由于内部编译器错误而中断。

#include <iostream>
#include <string>
template<class T>
struct CommonTraits {
    static T Return(){
    }
};
template<>
struct CommonTraits<int>{
    static int Return(){
        return 1;
    }
};
template<>
struct CommonTraits<std::string>{
    static std::string Return(){
        return std::string("hello");
    }
};
int main ()
{
    std::cout<<CommonTraits<std::string>::Return()<<std::endl;
    std::cout<<CommonTraits<int>::Return()<<std::endl;
}

这是我能想到的最好的。。它使用C++14。

template<typename T, typename Tupple, size_t... index>
constexpr T construct_type(Tupple&& params, std::index_sequence<index...>)
{
    return T(std::get<index>(std::forward<Tupple>(params))...);
}
template<typename T, typename Tupple>
constexpr T construct(Tupple&& params)
{
    return construct_type<T, Tupple>(std::forward<Tupple>(params), std::make_index_sequence<std::tuple_size<typename std::decay<Tupple>::type>::value>{});
}
template<bool cond, typename T, typename F>
struct cond_if
{
    template<typename FirstArgs, typename SecondArgs>
    constexpr T value(FirstArgs&& first, SecondArgs&& second) {return construct<T>(first);}
};
template<typename T, typename F>
struct cond_if<false, T, F>
{
    template<typename FirstArgs, typename SecondArgs>
    constexpr F value(FirstArgs&& first, SecondArgs&& second) {return construct<F>(second);}
};

template<typename T>
constexpr auto func()
{
    return cond_if<std::is_same<T, int>::value, int, std::string>().value(std::make_tuple(1), std::make_tuple("Hello"));
}
template<typename T>
constexpr auto func2()
{
    return cond_if<std::is_same<T, int>::value, int, const char*>().value(std::make_tuple(1), std::make_tuple("Hello"));
}

int main()
{
    static_assert(func<int>() == 1, "NOT COMPILE TIME -- 1");
    static_assert(func2<char>() == "Hello", "NOT COMPILE TIME -- 2");
    static_assert(func<char>() == "Hello", "NOT COMPILE TIME -- 3");
}

输出：

NOT COMPILE TIME -- 3 - Non-constant condition for static assertion.

由于正在使用std::string，第三个实例不是编译时。

相关文章：