Question

我正在尝试编写一个接受变量类型的可变数量参数的函数。类型将永远是POD，除了一个将有POD列表的情况。我通过参数包扩展和递归模板函数调用实现了这一点。

该函数目前适用于具有模板特化的POD的所有覆盖，但我想为List创建模板特化，但保持列表模板化。我知道这可能是不可能的，因为这在功能层面实际上是部分专业化。我想知道这种情况的解决方法。

这就是我正在做的事情。

template<typename T, typename ...TArgs> 
void Params2(T value, TArgs... args) {
        Params2(value);
        Params2(args...);
}
template<typename T>
inline void Params2(T c) { //invalid msg }

template <> inline void Params2<unsigned char>(unsigned char c) { //do something with char }
template <> inline void Params2<char>(char c) { //do something with uchar }
template <> inline void Params2<unsigned short>(unsigned short c) { //do something with short }
template <> inline void Params2<short>(short c) { //do something with ushort }

// more POD overrides

如果我执行以下操作，它会起作用，因为我已经完全定义了列表的类型：

template <>  
inline void Params2< libfc::List<int> >(libfc::List<int> l) 
{ 
    for (auto itt = l.Begin(); itt != l.End(); ++itt) 
    { 
        //do something with each int
    } 
}

我希望能够做的是：

template <>
template <typename R>
inline void Params2<libfc::List<R> >(libfc::List<R>) { 
    //do something with for each element of type R
}

我不想对函数可以采用的每种类型的List进行覆盖，但如果没有更好的选择，我可以接受。

编辑：调用应用程序将调用此功能（不是有效代码，只是示例）：

Params2(10, 25, "test", List<int> { 5, 10 }, List<double> { 3.14, 9.81 } );

Answer 1

使用重载而不是专业化

HasKey()

或使用泛型方法和类专门化

adb version
Android Debug Bridge version 1.0.31
wget -O - https://skia.googlesource.com/skia/+archive/cd048d18e0b81338c1a04b9749a00444597df394/platform_tools/android/bin/linux.tar.gz | tar -zxvf - adb
sudo mv adb /usr/bin/adb
sudo chmod +x /usr/bin/adb
adb version
Android Debug Bridge version 1.0.32

Answer 2

使用std::enable_if()，您可以制作模板，这些模板将混合使用原始数据和＆＃34;列表＆＃34;原始数据。这里的诀窍是，任何具有const_iterator类型和begin()方法返回可转换为该类型的类型的东西都将被视为列表，其他所有内容都将被路由到适当的重载。

void foo(const int& t) { std::cout << "int: " << t << std::endl; }
void foo(const double& t) { std::cout << "double: " << t << std::endl; }

template<typename T,
         typename std::enable_if<
             std::is_convertible<
                 decltype(std::declval<const T&>().begin()),
                 typename T::const_iterator
             >::value
         >::type* = nullptr>
void foo(const T& t) {
    auto begin = t.begin();
    for(;begin != t.end(); ++begin) {
        foo(*begin);
    }
}

template<typename T,
         typename... TArgs>
void foo(const T& first, TArgs... args) {
    foo(first);
    foo(args...);
}

int main() {
    std::list<int> asdf{3, 4, 5};
    std::vector<double> vec{7, 8, 9};
    foo(1, 2.0, asdf, 6, vec);
}

输出：

int：1
  double：2
  int：3
  int：4
  int：5
  int：6
  双：7
  双：8
  双倍：9

c ++函数模板专业化

2 个答案: