Trọng một chức năng templated với một đa hình một

Question

Nếu tôi có

template<class T> 
TalkyBuffer& operator<<(T const &object) { // Template 
... 
} 
TalkyBuffer& operator<<(TalkySerialisable const &object); // Override 

và một lớp

class A : public TalkySerialisable { 
...} 

Sau đó, nếu tôi thực hiện

TalkyBuffer b; 
A test; 
b << test; 

Sau đó gcc đang kêu gọi các chức năng Template khá so với hàm Ghi đè

Tuy nhiên, nếu tôi xác định cụ thể ghi đè

TalkyBuffer& operator<<(A const &object); // Override without polymorphism 

Sau đó, gcc sẽ chọn thẻ đó. Có cách nào thực tế để ghi đè lên một hàm templated với một lớp trừu tượng?

Tôi đọc điều này nhưng nó không làm sáng tỏ những gì xảy ra khi bạn ném đa hình vào hỗn hợp: http://www.gotw.ca/publications/mill17.htm Ngoài ra tôi không thể tìm thấy giải pháp ở đây nhưng có lẽ tôi đang sử dụng sai cụm từ.

Answer 1

Khi xác định các chức năng TalkyBuffer& operator<<(TalkySerialisable const &object); You are not trọng. Bạn đang quá tải hàm tmeplated.

Tuy nhiên, khi người khiếu nại thấy b << test;, công cụ tìm kiếm nhà điều hành muốn có số A. Nó có một, đó là chức năng templated mà không yêu cầu cast tự động. Đây là sự lựa chọn tốt nhất.

Chức năng quá tải đòi hỏi một diễn viên tự động (từ A đến TalkySerialisable) trên các thông số để phù hợp với việc kê khai, chứ không phải là sự lựa chọn tốt nhất.

Answer 2

Một giải pháp sử dụng Boost.enable_if:

#include <boost/utility/enable_if.hpp> 
#include <boost/type_traits/is_base_of.hpp> 

template<typename T> 
typename boost::disable_if< 
    boost::is_base_of<TalkySerializable, T>, 
    TalkyBuffer & 
>::type operator<<(T const & object) { // Template for non TalkySerializable 
... 
} 

template <typename T> 
typename boost::enable_if< 
    boost::is_base_of<TalkySerializable, T>, 
    TalkyBuffer & 
>::type operator<<(T const & object); // Template overload for TalkySerializable 

... 

TalkyBuffer b; 
A test; 
b << test; // calls operator<< <A>(A const &), which instantiates 
      // the overload for TalkySerializable 
b << 41; // calls operator<< <int>(int const &), which corresponds to 
     // the "default" overload 

Tôi không chắc chắn đây là giải pháp tốt nhất, nhưng tôi không tìm thấy một tốt hơn: chuyên cung cấp các mẫu không hoạt động hoặc.

---

Như @Matthieu ghi nhận trong các bình luận, giải pháp trước có nhược điểm lớn mà các mẫu cơ sở cần phải biết rằng nó sẽ bị quá tải, mà là một khớp nối không cần thiết mà gây cản trở khả năng mở rộng.

Để giải quyết vấn đề này, tôi đã đưa ra cách tiếp cận mới bằng cách sử dụng tag dispatching, cùng với các lớp đặc điểm và thời gian biên dịch bằng cách sử dụng Boost.MPL macros.

// TalkyBuffer.hpp 

#include <iostream> 
#include <boost/utility/enable_if.hpp> 
#include <boost/mpl/has_xxx.hpp> 

// defines a metafunction has_talky_buffer_tag<T> that allows us to know at 
// compile-time if T has a member type named talky_buffer_tag 
BOOST_MPL_HAS_XXX_TRAIT_DEF(talky_buffer_tag) 

// tag for the default case 
struct default_talky_buffer_tag {}; 

// trait class for obtaining the tag of a type 
template <typename T, typename Enable = void > 
struct talky_buffer_trait 
{ 
    typedef default_talky_buffer_tag type; 
}; 

// specialization for types that provide a nested typedef 
template <typename T> 
struct talky_buffer_trait<T, 
    typename boost::enable_if<has_talky_buffer_tag<T> >::type> 
{ 
    typedef typename T::talky_buffer_tag type; 
}; 


struct TalkyBuffer 
{ 
    // Insertion operator, which calls an implementation function that can 
    // be overloaded depending on the tag 
    template<typename T> 
    TalkyBuffer & operator<<(T const & object) 
    { 
     typename talky_buffer_trait<T>::type tag; 
     return insertionOperatorImpl(*this, object, tag); 
    } 
}; 

// default implementation 
template <typename T> 
TalkyBuffer & insertionOperatorImpl(TalkyBuffer & buf, T const & object, 
    default_talky_buffer_tag) 
{ 
    std::cout << "default"; 
    return buf; 
} 


//------- 
// TalkySerializable.hpp 

struct TalkySerializable 
{ 
    struct tag {}; 
    typedef tag talky_buffer_tag; 
}; 

// A inherits from the nested typedef 
struct A : public TalkySerializable {}; 

// implementation for TalkySerializable objects 
template <typename Serializable> 
TalkyBuffer & insertionOperatorImpl(TalkyBuffer & buf, Serializable const & object, 
    TalkySerializable::tag) 
{ 
    std::cout << "specialized"; 
    return buf; 
} 


//------- 
int main() 
{ 
    TalkyBuffer b; 
    A test; 
    b << test; // outputs "specialized" 
    b << 41; // outputs "default" 
} 

Để cung cấp triển khai mới của các nhà điều hành chèn cho một loại nhất định T, người ta cần phải cung cấp một loại mới để hoạt động như một thẻ (TypeSerializable::tag trong ví dụ của chúng tôi), cung cấp một cách để kết hợp T với thẻ mới (hoặc bằng cách sử dụng một typedef lồng nhau như trong ví dụ, hoặc bằng cách chuyên lớp đặc điểm: template <> talky_buffer_trait<T> { typedef new_tag type };), và cuối cùng quá tải chức năng thực hiện (insertionOperatorImpl trong ví dụ).

Answer 3

Tôi nghĩ rằng nó có thể sử dụng một giải pháp đơn giản function dựa, tái sử dụng chức năng quá tải cho nguồn gốc.

struct specialized {}; 
struct generic {}; 

template <class T> 
TalkyBuffer& serialize(TalkyBuffer& buffer, T const& object, generic) { 
    ... 
} 

generic dispatch(...) {} // always picked up last in overload resolution 

template <class T> 
TalkyBuffer& TalkyBuffer::operator<<(T const& object) { // Template 
    return serialize(*this, object, dispatch(object)); 
} 

Bây giờ, chúng ta hãy thực hiện lớp tùy chỉnh của bạn:

TalkyBuffer& serialize(TalkyBuffer& buffer, 
         TalkySerialisable const& object, 
         specialized); 

specialized dispatch(TalkySerialisable const&) {}  

Và tạo ra một nguồn gốc một:

class A: public TalkySerialisable {}; 

Vì vậy, những gì sẽ xảy ra?

• TalkyBuffer::operator<<(T const&) sẽ được nhặt
• khi cố gắng để giải quyết tình trạng quá tải cho serialize, nó sẽ lần đầu tiên tính toán kết quả của dispatch
• khi giải quyết hậu quả của dispatch, là một trận đấu tốt hơn so với dispath(...), do đó loại trả về là specialized
• chung serialize không thể được sử dụng (không có chuyển đổi từ specialized thành generic), do đó, thừa kế đá trong