Question

我想抽象类型接口，但我很难在概念的两种 C++ 方法和 type_traits 之间做出决定。考虑以下场景：

template <typename T>
int foo(const T& t) { return t.size() + t.size(); }

请求类型 T 提供 int T::size() const。为了创建更好的错误消息、增加客户端用户定义类型的可用性并为他提供一个明确定义的可接受类型必须具备的功能列表，可以引入一个概念：

template <typename T>
concept SizeHaving = requires(T t) {
    t.size();
}

template <SizeHaving T>
int foo(const T& t) { return t.size() + t.size(); }

但是，如果客户端类型原则上可以实现该概念，但技术上不能实现（并且无法更改，因为它可能是第三方库的一部分）怎么办？ type_trait 可以提供帮助：

struct Special {
   int Dimension() const; // logically identical to size(), but a different name
};

template <typename T>
struct Type_traits {
    static int size(const T& t) { return t.size(); }
};

template <> // user can provide the specialization for the custom type
struct Type_traits<Special> {
    static int size(const Special& c) { return c.Dimension(); }
};

template <typename T>
int foo(const T& t) {
    return Type_traits<T>::size(t) + Type_traits<T>::size(t);
}

如果 Type_trait 的标准实现不适合自定义类型（并且没有提供专业化），则会再次出现相当不幸的错误消息。 如何将概念融入到游戏中？ 我试过的是

template <typename T>
concept SizeHaving = requires(T t) {
    Type_traits<T>::size(t);
}

但是对于任何类型，无论Type_traits<T>::size()是否可以显式实例化，在技术上都将满足表达式约束，从而使这个概念无用。我能做什么？

Answer 1

你也可以限制你的特质：

template <typename T>
concept SizeHaving = requires(const T& t) {
    t.size(t);
};

template <typename T>
struct Type_traits
{
    auto size(const T& t) requires(SizeHaving<T>) { return t.size(); }
};

template <typename T>
concept TraitSizeHaving = requires(T t) {
    Type_traits<T>::size(t);
};

template <TraitSizeHaving T>
int foo(const T& t) {
    return Type_traits<T>::size(t) + Type_traits<T>::size(t);
}

然后专门针对您的自定义类型：

struct Special {
   int Dimension() const; // logically identical to size(), but a different name
};

template <> // user can provide the specialization for the custom type
struct Type_traits<Special> {
    static int size(const Special& c) { return c.Dimension(); }
};

Demo。

注意：requires(SizeHaving<T>) 应该在成员上完成，而不是在类上完成，以允许类的特化。

如何将 C++ 概念与 type_traits 结合使用？

1 个答案: