在 C++ 中选择重载模板函数时的优先级

Question

我有以下问题：

class Base
{
};

class Derived : public Base
{
};

class Different
{
};

class X
{
public:
  template <typename T>
  static const char *func(T *data)
  {
    // Do something generic...
    return "Generic";
  }

  static const char *func(Base *data)
  {
    // Do something specific...
    return "Specific";
  }
};

如果我现在这样做

Derived derived;
Different different;
std::cout << "Derived: " << X::func(&derived) << std::endl;
std::cout << "Different: " << X::func(&different) << std::endl;

我明白了

Derived: Generic
Different: Generic

但我想要的是，对于从 Base 派生的所有类，都会调用特定方法。 所以结果应该是：

Derived: Specific
Different: Generic

有什么方法可以重新设计 X:func(...)s 来实现这个目标？

编辑：

假设 X::func(...) 的调用者不知道作为参数提交的类是否派生自 Base。所以铸造到基地不是一种选择。 事实上，整个事情背后的想法是 X::func(...) 应该“检测”参数是否来自 Base 并调用不同的代码。 出于性能原因，应该在编译时进行“检测”。

Answer 1

只是派生到基类的类型转换

X::func((Base*)&derived)

它有效....

Answer 2

表达式：

X::func(derived)

意味着编译器将生成一个有效地具有此签名的声明和代码：

static const char *func(Derived *data);

结果证明这比你的匹配更好：

static const char *func(Base *data);

模板函数将用于任何对 typename 合法的东西，例如您用作 T 的任何类，由于编译时策略，它将有效地排除使用您的函数的 Base 版本。

我的建议是在 X 中为您的特定类型使用specialization，即：

template <typename T>
  static const char *func(T *data)
  {
    // Do something generic...
    return "Generic";
  }

template <>
  static const char *func(Derived *data) // 'Derived' is the specific type
  {
    // Do something specific...
    return "Specific";
  }

希望有效！

Answer 3

您必须为此使用SFINAE。在以下代码中，当且仅当您传递无法（隐式）转换为Base * 的内容时，才能实例化第一个函数。第二个函数则相反。

您可能想阅读enable_if。

#include <iostream>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits.hpp>

class Base {};
class Derived : public Base {};
class Different {};

struct X
{
    template <typename T>
    static typename boost::disable_if<boost::is_convertible<T *, Base *>,
        const char *>::type func(T *data)
    {
        return "Generic";
    }

    template <typename T>
    static typename boost::enable_if<boost::is_convertible<T *, Base *>,
        const char *>::type func(T *data)
    {
        return "Specific";
    }
};

int main()
{
    Derived derived;
    Different different;
    std::cout << "Derived: " << X::func(&derived) << std::endl;
    std::cout << "Different: " << X::func(&different) << std::endl;
}

Answer 4

如果你正在使用 boost，你可以通过一些模板元编程来做到这一点：

#include <boost/type_traits/is_base_of.hpp>

class X
{
private:
    template <typename T>
    static const char *generic_func(T *data)
    {
        // Do something generic...
        return "Generic";
    }

    template <typename T>
    static const char *base_func(T *data)
    {
        // Do something specific...
        return "Specific";
    }

public:
    template <typename T>
    static const char* func(T* data)
    {
        if (boost::is_base_of<Base, T>::value)
            return base_func(data);

        return generic_func(data);
    }
};

is_base_of 元函数在编译时进行评估，优化器很可能会删除func 函数中if 的死分支。这种方法允许您拥有多个特定案例。

Answer 5

我找到了一个非常简单的解决方案！

class Base
{
};

class Derived : public Base
{
};

class Different
{
};

class X
{
private:
  template <typename T>
  static const char *intFunc(const void *, T *data)
  {
    // Do something generic...
    return "Generic";
  }

  template <typename T>
  static const char *intFunc(const Base *, T *data)
  {
    // Do something specific...
    return "Specific";
  }

public:
  template <typename T>
  static const char *func(T *data)
  {
    return intFunc(data, data);
  }
};

这很好用，而且非常纤薄！ 诀窍是让编译器通过（否则无用的）第一个参数选择正确的方法。

Answer 6

我希望设置重叠 enable_if 的优先级，特别是为了回退调用 STL 容器方法，其中我的特征是诸如 is_assignable is_insterable 之类的东西。与许多容器重叠。

我想优先分配分配，如果存在，则使用插入迭代器。这是我想出的一个通用示例（由#boost irc 频道中的一些方便的人修改为无限级别的优先级）。它作为优先级的隐式转换将重载排在另一个同样有效的选项之下 - 消除歧义。

#include <iostream>
#include <string>

template <std::size_t N>
struct priority : priority<N - 1> {};

template <>
struct priority<0> {};

using priority_tag = priority<2>;

template <typename T> 
void somefunc(T x, priority<0>)
{
    std::cout << "Any" << std::endl;
}

template <typename T> 
std::enable_if_t<std::is_pod<T>::value >
somefunc(T x, priority<2>)
{
    std::cout << "is_pod" << std::endl;
}

template <typename T>
std::enable_if_t<std::is_floating_point<T>::value >
somefunc(T x, priority<1>)
{
    std::cout << "is_float" << std::endl;
}

int main()
{
    float x = 1;
    somefunc(x, priority_tag{});
    int y = 1;
    somefunc(y, priority_tag{}); 
    std::string z;
    somefunc(z, priority_tag{});
    return 0;
}

还有人建议在 C++ 14 中我可以只使用 constexpr if 语句来实现相同的目的，如果 Visual Studio 2015 支持它们，这将更加简洁。希望这对其他人有帮助。

#include <iostream>
#include <string>

template <typename T>
void somefunc(T x)
{
    if constexpr(std::is_floating_point<T>::value) {
      static_assert(std::is_floating_point<T>::value);
      std::cout << "is_float" << std::endl;
    } else if constexpr(std::is_pod<T>::value) {
      static_assert(std::is_pod<T>::value);
      std::cout << "is_pod" << std::endl;
    } else {
      static_assert(!std::is_floating_point<T>::value);
      static_assert(!std::is_pod<T>::value);
      std::cout << "Any" << std::endl;
    }
}

int main()
{
    float x = 1;
    somefunc(x);
    int y = 1;
    somefunc(y); 
    std::string z;
    somefunc(z);
    return 0;
}

// 感谢 k-ballo @#boost！