2011-08-08 54 views
16

Có thể có nhiều phiên bản của cùng một lớp mà chỉ khác nhau về số đối số mẫu mà chúng có?Quá tải các lớp mẫu theo số tham số mẫu

Ví dụ:

template<typename T> 
class Blah { 
public: 
    void operator()(T); 
}; 

template<typename T, typename T2> 
class Blah { 
public: 
    void operator()(T, T2); 
}; 

Tôi đang cố gắng để mô hình kiểu functor điều đó có thể thực hiện một số biến của tham số (lên đến số lượng mẫu khác nhau mà được viết ra).

+0

tôi đang tự hỏi nếu bạn có thể làm điều gì đó với typelists. – john

+0

@ john đó sẽ là một ý tưởng hay nhưng tôi đang sử dụng MSVC++ 2010 không hỗ trợ chúng tôi không tin. –

+0

Thực sự tăng :: tuple có lẽ là một phiên bản dễ tiếp cận hơn của cùng một ý tưởng. Có một mẫu chung với một loại, sau đó là phiên bản chuyên biệt với các bộ dữ liệu cho hai, ba, bốn ... loại. – john

Trả lời

22

Câu trả lời đơn giản nhất là chỉ có một mẫu, với số lượng tối đa bạn muốn hỗ trợ và sử dụng khoảng trống cho loại mặc định trên tất cả trừ loại đầu tiên. Sau đó, bạn có thể sử dụng một đặc tả từng phần khi cần thiết:

template<typename T1, typename T2=void> 
struct foo { 
    void operator()(T1, T2); 
}; 

template <typename T1> 
struct foo<T1, void> { 
    void operator()(T1); 
}; 

int main() { 
    foo<int> test1; 
    foo<int,int> test2; 
    test1(0); 
    test2(1,1); 
} 
+1

Tôi không nghĩ định nghĩa 'toán tử() (T, T2, T3, T4)' sẽ hoạt động đúng nếu một số kiểu là 'void'. –

+0

@Ben bạn nói đúng, không, tôi đã thử điều đó. –

+2

@ben - Nó không hoạt động như vậy, do đó việc chuyên môn hóa một phần có hiệu quả cho việc "quá tải" về số lượng đối số mẫu – Flexo

14

Một mẫu có thể chỉ có một định nghĩa cơ bản. Nếu bạn cần một số biến đối số và bạn không muốn sử dụng cấu trúc "loại rỗng" như @awoodland gợi ý, và nếu bạn có trình biên dịch C++ 0x, thì bạn có thể sử dụng mẫu variadic:

template <typename ...Dummy> struct foo; // base case, never instantiated! 

template <typename T> struct foo<T> { /*...*/ }; // partial spec. for one parameter 
template <typename T, typename U> struct foo<T, U> { /*...*/ }; // ditto for two 
0

đây là mã chưa được kiểm tra, tôi không có một phiên bản của tăng tiện dụng, nhưng ở đây đi nào

#include "boost/tuple.h" 

template <class T> 
class Blah; 

template <class T> 
class Blah< boost::tuple<T> > 
{ 
    void operator()(T arg); 
}; 

template <class T, class U> 
class Blah< boost::tuple<T, U> > 
{ 
    void operator()(T arg1, U arg2); 
}; 

vv vv

Các vấn đề liên quan