Question

我正在尝试创建一个可变参数模板类，它为类型列表中的每个类提供一个方法。下面显示了一个示例，它为类型列表中的每个类创建一个print方法：

#include <iostream>
#include <string>

// Helper class providing a function call
template <typename T>
class PrintHelper
{
public:
    void print(const T& t) { std::cout << t << std::endl; }
};

// Provides a print method for each type listed
template <typename... Ts>
class Printer : public PrintHelper<Ts>...
{};

int main()
{
    Printer<int, std::string> p;
    p.print(std::string("Hello World")); // Ambiguous Call
}

注释行在注释行上导致GCC 4.6.3出错。解决歧义的正确方法是什么，或者我应该考虑不同的设计？

Answer 1

要解决歧义，可以执行

template <typename... Ts>
struct Printer : PrintHelper<Ts>...
{
    template <typename U>
    void print (const U& t)
    {
        PrintHelper<U>::print (t);
    }
};

（见an example）

但这并不像人们希望的那样强大。特别是，您无法打印可转换为类型列表中某种类型的对象。

通过一些模板元编程，可以调度到正确的打印机。为此，您必须从Ts...中选择U可转换的类型，然后调用右PrintHelper，即。

PrintHelper<typename find_convertible<U, Ts...>::type>::print (t);

其中find_convertible<U, Ts...>由

定义

template <typename U, typename... Ts>
struct find_convertible
{};

template <typename U, typename V, typename... Ts>
struct find_convertible<U, V, Ts...> :
    std::conditional<
        std::is_convertible<U, V>::value, 
        std::common_type<V>, // Aka identity
        find_convertible<U, Ts...>
    >::type
{};

（见example）

Answer 2

我不喜欢回答我自己的问题，但我从这里的评论中创建了以下解决方案。它将所有print函数放入范围，并允许对所有函数进行C ++重载解析。

#include <iostream>
#include <string>

// Helper class providing a function call
template <typename T>
class PrintHelper
{
public:
    void print(const T& t) { std::cout << t << std::endl; }
};

// Provides a print method for each type listed
template <typename... Ts>
class Printer
{};

template<typename T>
class Printer<T> : public PrintHelper<T>
{
public:
    using PrintHelper<T>::print;
};

template<typename T, typename... Ts>
class Printer<T, Ts...>: public PrintHelper<T>, public Printer<Ts...>
{
public:
    using PrintHelper<T>::print;
    using Printer<Ts...>::print;
};

int main()
{
    Printer<int, std::string> p;
    p.print("Hello World"); // Not an ambiguous Call
}

Answer 3

以下代码可以解决歧义问题：

#include <iostream>
#include <string>

// Helper class providing a function call
template <typename T>
class PrintHelper
{
  protected:
    void print_impl(const T& t) { std::cout << t << std::endl; }
};

// Provides a print method for each type listed
template <typename... Ts>
class Printer : public PrintHelper<Ts>...
{
  public:
    template <typename U>
    void print(const U& u) { 
      PrintHelper<U>::print_impl(u); 
    };
};

int main()
{
    Printer<int, std::string> p;
    p.print(std::string("Hello World")); // Ambiguous Call
}

由于要求类型U（在调用时推断）恰好是可变参数类型列表中的类型之一，因此这不是很好。你或许能够解决这个问题。有了一些模板魔法和Sfinae，你可以很容易地解决这个问题（但肯定不是那么整洁干净）。

歧义问题与模板或可变参数模板的使用无关，当然，它是成员查找规则的直接应用（标准的第10.2/2节），即经常被称为“成员隐藏规则“。如果你采用这个更简单的非模板版本，你会得到同样的歧义问题，但有一个非常简单的解决方案：

struct IntPrinter {
  void print(const int& i) { std::cout << i << std::endl; };
};

struct StringPrinter {
  void print(const std::string& s) { std::cout << s << std::endl; };
};

struct IntStringPrinter : IntPrinter, StringPrinter {
  using IntPrinter::print;       // These using-statements will solve the problem
  using StringPrinter::print;    // by importing all 'print' functions to the same 
                                 // overload resolution level.
};

所以，这里的问题实际上是在编译器甚至尝试应用正常的重载决策规则之前出现歧义，因为它首先试图找出继承的哪个分支来查找成员函数，然后，它将仅在一个继承级别解决重载。使用可变参数模板时的问题是，似乎没有任何方法可以解压缩一组“using”语句以将所有打印函数导入到相同的继承级别。如果有人知道解开这些使用陈述的方法，我会全力以赴。您可能需要回退到变量前模板解决方案（例如具有10个参数的通用模板，并专门针对所有10个版本）。

不明确的函数调用C ++基类

3 个答案: