具有取决于模板参数的方法的模板类

说："如果你有方法 1，请使用这个实现，如果你有方法 2，使用另一个,...如果你没有，那么编译错误"。

我写了一篇文章，解释了如何在 C++11、C++14 和 C++17 中准确实现所需的内容：">使用 C++17 就地检查表达式有效性"。

我将在下面综合 C++11 和 C++14 解决方案 - 您可以使用它们通过将它们包装在一个"通用"接口中来规范化您正在处理的所有接口。然后，您可以在"通用"接口上实现算法。

假设您有：

struct Cat { void meow() const; };
struct Dog { void bark() const; };

并且您希望创建一个函数模板make_noise(const T& x)，如果有效，则调用x.meow()，否则x.bark()有效，否则将产生编译器错误。

在 C++11 中，您可以使用enable_if和检测习惯用法。

您需要为要检查其存在的每个成员创建一个类型特征。例：

template <typename, typename = void>
struct has_meow : std::false_type { };
template <typename T>
struct has_meow<T, void_t<decltype(std::declval<T>().meow())>>
: std::true_type { };

下面是使用enable_if和尾随返回类型的用法示例 - 此技术使用表达式 SFINAE。

template <typename T>
auto make_noise(const T& x)
-> typename std::enable_if<has_meow<T>{}>::type
{
x.meow();
}
template <typename T>
auto make_noise(const T& x)
-> typename std::enable_if<has_bark<T>{}>::type
{
x.bark();
}

在 C++14 中，您可以使用通用 lambda和static_if的实现(这是我在 CppCon 2016 上关于可能的一个演讲)来使用类似命令式语法的语法执行检查。

您需要一些实用程序：

// Type trait that checks if a particular function object can be 
// called with a particular set of arguments.
template <typename, typename = void>
struct is_callable : std::false_type { };
template <typename TF, class... Ts>
struct is_callable<TF(Ts...),
void_t<decltype(std::declval<TF>()(std::declval<Ts>()...))>>
: std::true_type { };
// Wrapper around `is_callable`.
template <typename TF>
struct validity_checker
{
template <typename... Ts>
constexpr auto operator()(Ts&&...) const
{
return is_callable<TF(Ts...)>{};
}
};
// Creates `validity_checker` by deducing `TF`.
template <typename TF>
constexpr auto is_valid(TF)
{
return validity_checker<TF>{};
}

之后，您可以在单个重载make_noise内执行所有检查：

template <typename T>
auto make_noise(const T& x)
{
auto has_meow = is_valid([](auto&& x) -> decltype(x.meow()){ });
auto has_bark = is_valid([](auto&& x) -> decltype(x.bark()){ });
static_if(has_meow(x))
.then([&x](auto)
{
x.meow();
})
.else_if(has_bark(x))
.then([&x](auto)
{
x.bark();
})
.else_([](auto)
{
// Produce a compiler-error.
struct cannot_meow_or_bark;
cannot_meow_or_bark{};
})(dummy{});
}

一些宏黑魔法和if constexpr允许你在 C++17 中写这个：

template <typename T>
auto make_noise(const T& x)
{
if constexpr(IS_VALID(T)(_0.meow()))
{
x.meow();
}
else if constexpr(IS_VALID(T)(_0.bark()))
{
x.bark();
}
else
{
struct cannot_meow_or_bark;
cannot_meow_or_bark{};
}
}

您可以通过为操作引入自己的名称来解决此问题。为此，请创建一个 trait 类并将其专用于每个库。像这样：

template <class Vector>
struct VectorTraits;
template <>
struct VectorTraits<Lib1::Vector>
{
static auto getX(const Lib1::Vector &v) { return v.GetX(); }
// ... etc.
};
template <>
struct VectorTraits<Lib2::Vector>
{
static auto getX(const Lib2::Vector &v) { return v.Get(0); }
// ... etc.
};
//Usage:
template <class vector>
auto norm2(const vector &v)
{
using V = VectorTraits<vector>;
return V::getX(v) * V::getX(v) + V::getY(v) + V::getY(v);
}

如果需要对不受支持的操作进行静态断言，可以将它们放入非专用模板中：

template <class T>
struct False : std::false_type {};
template <class Vector>
struct VectorTraits
{
static void getX(const Vector &)
{
static_assert(False<Vector>::value, "This type does not support getting x");
}
};