Tôi nên làm gì thay vì chuyên môn hóa một phần các mẫu chức năng?

Question

Tôi muốn viết như sau:

template <typename S, typename T> void foo() { 
    /* code for the general case */ 
} 

template <typename T> void foo<MySType,T>() { 
    /* partially specialized code - for any kind of T, but when S is MySType */ 
} 

hoặc, trong trường hợp khác, như sau:

template <typename S, typename T> void bar(const S& a, const T& b) { 
    /* code for the general case */ 
} 

template <typename T> void bar<MySType,T>(const MySType& a, const T& b) { 
    /* partially specialized code - for any kind of T, but when S is MySType */ 
} 

C++ (11) sẽ không cho phép tôi làm điều này.

Bây giờ, tôi đã đọc this question and its answers; giả sử tôi mua giải thích lý do tại sao chúng tôi không có chuyên môn hóa từng phần (hoặc chỉ giả định rằng tôi đang sống trong thực tế và thực sự muốn viết mã). Vâng, những gì làm Tôi làm, thay vì?

Tôi thực sự không muốn bọc các chức năng này trong một lớp trừ khi đó hoàn toàn là phương sách cuối cùng của tôi.

Answer 1

Một lựa chọn khác là sử dụng một mẫu lớp helper, nơi bạn có thể làm chuyên môn hóa một phần, và giấu nó bằng cách sử dụng chức năng bao bọc mà không cần phải được chuyên phần bản thân:

#include <iostream> 

template<typename S, typename T> 
struct foo_helper { 
    void foo() { 
     std::cout << "general func" << std::endl;   
    } 
}; 

struct MyType {}; 

template <typename T> 
struct foo_helper <MyType,T> { 
    void foo() { 
     std::cout << "partially specialized code - for any kind of T, but when S is MyType" << std::endl; 
    } 
}; 

template<typename S, typename T> 
void foo() { 
    foo_helper<S, T>().foo(); 
} 

int main() { 
    foo<int, int>(); 
    foo<int, double>(); 
    foo<MyType, long>(); 
} 

Đây là C++ 98/03 hợp lệ.

Answer 2

Quá tải! Quá tải là vượt trội trong mọi cách để chuyên môn hóa. Một phần của độ phân giải quá tải là chọn quá tải chuyên biệt nhất. Chỉ cần khai báo các "chuyên ngành" là quá tải và nó sẽ hoạt động nếu chuyên môn hóa một phần sẽ có. Tuy nhiên,

Tránh các đối số mẫu rõ ràng. Thay vào đó, bạn có thể sử dụng tính năng gửi thẻ.

template< typename t > 
struct tag {}; 

template <typename S, typename T> foo(tag<S>, tag<T>) { 
    /* code for the general case */ 
} 

template <typename T> foo(tag<MyType>, tag<T>) { 
    /* partially specialized code - for any kind of T, but when S is MyType */ 
} 

Vì các thẻ trống và được truyền theo giá trị, đóng góp của chúng vào chi phí cuộc gọi chức năng có thể bị loại bỏ bởi trình biên dịch.

Answer 3

Bạn có thể một phần chuyên biệt hoá một cấu trúc helper:

#include <iostream> 

namespace Detail { 
    template <typename S, typename T> 
    struct Foo { 
     static void apply() { 
      std::cout << "general case\n"; 
     } 
    }; 
    template <typename T> 
    struct Foo<int, T> { 
     static void apply() { 
      std::cout << "specialized code\n"; 
     } 
    }; 
} 

template <typename S, typename T> 
void foo() { 
    Detail::Foo<S, T>::apply(); 
} 

int main() 
{ 
    foo<double, double>(); 
    foo<int, double>(); 
    return 0; 
}