Loại xung đột trong quá tải nhà điều hành mẫu

Question

Tôi xin lỗi điều này nghe có vẻ giống như một câu hỏi phổ biến, tôi không thể tìm thấy câu trả lời cho vấn đề của mình như tôi thấy. Bài đăng gần nhất sẽ là bài đăng này: Template Specialization for basic POD only

Giả sử tôi có một lớp template <class T> class A {...}; và tôi muốn quá tải toán tử + làm toán tử nhị phân nội bộ (hai đối tượng loại A) và làm toán tử hỗn hợp A và số POD loại).

Lý tưởng nhất, những gì tôi muốn viết là:

#include <type_traits> 
using namespace std; 

// Declare/fine template 
template <class T> class A {...}; 

// Internal binary operator 
template < class T, class U > 
    A< typename common_type<T,U>::type > 
operator+ (const A<T> &a, const A<U> &a) { ... } 

// Mixed binary operator 
template < class T, class U > 
    A< typename common_type<T,U>::type > 
operator+ (const A<T> &a, const U &b) { ... } 

Nhưng sau đó nó có vẻ như định nghĩa thứ hai là mâu thuẫn với cái đầu tiên. Sử dụng định nghĩa thứ hai, tôi biết làm thế nào để đảm bảo U là một loại POD số, ​​đó không phải là vấn đề. Nếu tôi đi theo cách đó, vấn đề là tôi không có cách nào để biết loại mẫu cơ bản nào được bao bọc trong U nếu đó là một số A.

Hãy cho tôi biết nếu câu hỏi của tôi không rõ ràng và cảm ơn trước! :)

EDIT: Các đặc điểm kỹ thuật mẫu đã bị xóa bởi bộ lọc HTML, trong câu cuối cùng của tôi "U nếu nó là một số A<T>". Tóm lại, tôi nói T bị ẩn.

Answer 1

Bạn có thể làm cho nó làm việc với một đặc điểm helper ít để phân biệt chuyên ngành của A từ các loại tổng quát hơn:

#include <type_traits> 


// "A" template  

template <typename> class A {}; 


// Traits for "A-ness": 

template <typename> struct is_a : std::false_type { }; 
template <typename T> struct is_a<A<T>> : std::true_type { }; 


// Operators: 

template <class T, class U> 
A<typename std::common_type<T, U>::type> 
operator+(const A<T> & a, const A<U> & b); 

template <class T, class U, 
      typename = typename std::enable_if<!is_a<U>::value>::type> 
A<typename std::common_type<T, U>::type> 
operator+(const A<T> & a, const U & b); 

này không bao gồm sự quá tải thứ hai từ tập hữu hiệu ngay lập tức, và do đó vấn đề xác định sự trở lại loại quá tải thứ hai không bao giờ xuất hiện khi chỉ có cái đầu tiên được mong muốn.

(Đây là một ví dụ của việc sử dụng enable_if trong lập luận mẫu mặc định để kiểm soát các thiết lập tình trạng quá tải.)

Answer 2

Bạn có thể viết một SFINAE thân thiện common_type - Tôi cá nhân trong trại mà những đặc điểm nên hầu như luôn luôn SFINAE . Để wit:

// Black hole metafunction that eats everything 
template<typename...> struct void_ { using type = void; }; 

template<typename... T> 
using Void = typename void_<T...>::type; 

// Due to std::common_type being variadic we need to 
// pass a variadic pack around 
template<typename... T> struct list {}; 

// Actually defined, but with no member types for SFINAE purposes 
template<typename Sequence, typename Sfinae = void> 
struct common_type_impl {}; 

template<typename... T> 
struct common_type_impl<list<T...>, Void<typename std::common_type<T...>::type>> 
: std::common_type<T...> {}; 

template<typename... T> struct common_type: common_type_impl<list<T...>> {}; 

Bây giờ, khi không có loại phổ biến giữa A<T> và U sự quá tải sẽ bị xoá khỏi danh sách các ứng cử viên thay vì ồn ào phàn nàn.

Cũng có thể thay thế std::common_type hoàn toàn do kết quả tính toán có vấn đề riêng của mình, như được ghi trong DR 2141. Tôi sẽ không phác thảo một sự thay thế bởi vì nó không rõ ràng những gì một giải pháp tốt hơn là, đặc biệt tôi xem xét rằng độ phân giải đề xuất của DR là tồi tệ hơn.