確定正確的尺寸類型兩個向量類型或一個向量類型以及標量型

Question

請考慮下面的代碼片斷之間的二進制運算的結果：

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_expression S，然後讓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_expression s。但是，（作爲第二個問題）我應該添加一個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 { const int max = 0; }與專業template<typename T> class sizer<vector_expression<T>> { const int max = std::numeric_limits<typename std::decay_t<E1>::size_type>::max() ; }。

這背後的想法很簡單。您的一般表達式比較兩個向量表達式中的兩個屬性，並選擇該屬性最大的類型。通過將此屬性定義爲所有其他類型的零，所有其他類型的排名低於vector_typs，並且不會被選中。