确定两种向量类型或一种向量类型与标量类型之间二元运算结果的正确大小类型

Question

请考虑以下代码sn-p：

template<class E>
class vector_expression {};

template<class Tuple>
class vector
    : public vector_expression<vector<Tuple>>
{
public:
    using value_type = typename Tuple::value_type;
    using size_type = typename Tuple::size_type;
};

namespace detail
{
    template<class E>
    constexpr bool is_vector_expression_v = std::is_base_of_v<vector_expression<std::decay_t<E>>, std::decay_t<E>>;

    template<class E, class = void>
    struct value_type { using type = std::decay_t<E>; };
    template<class E>
    struct value_type<E, std::enable_if_t<is_vector_expression_v<E>>> { using type = typename std::decay_t<E>::value_type; };

    template<class E>
    using value_type_t = typename value_type<E>::type;

    template<class E1, class E2, class BinaryOperation>
    class vector_binary_operation
    {
    public:
        using value_type = std::result_of_t<BinaryOperation(value_type_t<E1>, value_type_t<E2>)>;
    };
}

E1 和 E2 可能是派生自 vector_expression 的类型或用作 vector 的 value_type 的任何类型。

需要谨慎选择与vector_binary_operation 的结果相对应的vector 类型。它的value_type 等于被调用的BinaryOperation 的结果类型是完全有道理的。

但是，正确的size_type 更难推断。这是我想做的：

• 如果E1和E2是vector_expressions，那么让size_type = std::conditional_t< std::numeric_limits<typename std::decay_t<E1>::size_type>::max() < std::numeric_limits<typename std::decay_t<E2>::size_type>::max(), typename std::decay_t<E1>::size_type, typename std::decay_t<E2>::size_type>>>;
• 如果E1 或E2（比如E1）不是vector_expression，那么让size_type = typename std::decay_t<E2>::size_type

E1 和 E2 都不是 vector_expressions 不会发生。但是，（将其作为次要问题）我应该将class = std::enable_if_t<is_vector_expression_v<E1> || is_vector_expression_v<E2>> 添加到vector_binary_operation 的模板参数列表中吗？

主要问题是：如何定义size_type 如上所述？

Answer 1

一种方法是使用额外的特征或丰富您当前的特征：

您可以创建一个特征，将sizeof(E1::size_type) 用于vector_expression 和0 用于

template<class E, class = void>
struct value_type {
    using type = std::decay_t<E>;
    using size_type = char; // or better some dummy type
    static constexpr std::size_t size = 0; // To be the minimal size
};
template<class E>
struct value_type<E, std::enable_if_t<is_vector_expression_v<E>>> {
    using type = typename std::decay_t<E>::value_type;
    using size_type = typename std::decay_t<E>::size_type;
    static constexpr std::size_t size = std::numeric_limits<size_type>::max();
};

然后

template<class E1, class E2, class BinaryOperation>
class vector_binary_operation
{
public:
    using value_type = std::result_of_t<BinaryOperation(value_type_t<E1>,
                                                        value_type_t<E2>)>;
    using size_type = std::conditional_t<(value_type<E1>::size < value_type<E2>::size),
                                         typename value_type <E1>::size_type,
                                         typename value_type <E2>::size_type>>>;
};

Answer 2

通常我发现在这种情况下，通常最简单的方法是定义一组重载auto Foo(E1,E2) -> ResultType 来进行实际操作，然后设置vector_binary_operation::size_type = decltype(Foo(E1,E2))。

在您的特定情况下，您将拥有三个重载：对于 E1、E2 或两者都是 vector_expression。

在这种特殊情况下，我看到了另一种选择。介绍一个具有专业化 template<typename T> class sizer<vector_expression<T>> { const int max = std::numeric_limits<typename std::decay_t<E1>::size_type>::max() ; } 的助手 template<typename T> class sizer { const int max = 0; }。

这背后的想法很简单。您的一般表达式比较来自两个向量表达式的两个属性，并选择该属性最大的类型。通过将此属性定义为所有其他类型的零，所有其他类型的排名低于您的 vector_typs 并且不会被选中。