g ++ từ chối functor đơn giản của tôi với "mong đợi một loại, có 'xyz'"

Question

Tôi đã chơi về với functors trong C + +. Đặc biệt, tôi đã có một vectơ cặp tôi muốn sắp xếp theo yếu tố đầu tiên của cặp. Tôi bắt đầu viết một functor hoàn toàn chuyên biệt (tức là một cái gì đó như "bool MyLessThan (MyPair & lhs, MyPair & rhs)"). Sau đó, chỉ vì loại công cụ này là thú vị, tôi muốn thử viết một "Áp dụng F cho các yếu tố đầu tiên của cặp này" functor. Tôi đã viết dưới đây, nhưng g ++ không thích nó. Tôi nhận được:

lỗi: Loại/giá trị không phù hợp với lập luận 2 trong danh sách tham số mẫu cho 'mẫu struct Pair1stFunc2' lỗi: mong đợi một loại, có 'ít'

#include <algorithm> 
#include <functional> 
#include <utility> 
#include <vector> 

template <class P, class F> 
struct Pair1stFunc2 
{ 
    typename F::result_type operator()(P &lhs, P &rhs) const 
    { return F(lhs.first, rhs.first); } 

    typename F::result_type operator()(const P &lhs, const P &rhs) const 
    { return F(lhs.first, rhs.first); } 
}; 

typedef std::pair<int,int> MyPair; 
typedef std::vector<MyPair> MyPairList; 

MyPairList pairs; 

void foo(void) 
{ 
    std::sort(pairs.begin(), 
       pairs.end(), 
       Pair1stFunc2<MyPair, std::less>()); 
} 

bất cứ ai có thể rụng bất kỳ ánh sáng trên những gì tôi đang làm sai ở đây? Tôi biết đây là ví dụ nhân tạo một chút, nhưng tôi muốn biết chuyện gì đang diễn ra, nếu chỉ để cải thiện STL-fu của tôi.

Answer 1

Bạn cần chuyên std :: ít hơn với loại so sánh bạn đang sử dụng.

Pair1stFunc2<MyPair, std::less<int> >() 

sẽ thực hiện thủ thuật. Trong toán tử của riêng bạn() bạn cũng sẽ cần phải khởi tạo một đối tượng của kiểu so sánh, vì bạn không thể chỉ gọi trực tiếp lớp đó. Ví dụ. thay đổi

return F(lhs.first, rhs.first); 

để

F func; 
return func(lhs.first, rhs.first); 

Bạn cũng có thể di chuyển chuyên môn hóa vào functor, như câu trả lời khác gợi ý.

Answer 2

Lưu ý rằng std::less chính nó là một mẫu và bạn không chỉ định thông số mẫu mẫu khi bạn gọi nó từ sốcủa hàm sort! Ở đây less là một loại không đầy đủ và do đó vấn đề.

Answer 3

Để mở rộng về câu trả lời của dirkgently, đây là một ví dụ về những gì có thể làm việc như bạn có ý định:

template <typename T, template <typename> class F> 
struct Pair1stFunc2 
{ 
    template <typename P> 
    typename F<T>::result_type operator()(P &lhs, P &rhs) const 
    { F<T> f; return f(lhs.first, rhs.first); } 

    template <typename P> 
    typename F<T>::result_type operator()(const P &lhs, const P &rhs) const 
    { F<T> f; return f(lhs.first, rhs.first); } 
}; 

void foo(void) 
{ 
    std::sort(pairs.begin(), 
       pairs.end(), 
       Pair1stFunc2<int, std::less>()); 
} 

Lưu ý rằng nó hoạt động, nhưng nó có thể không được chính xác những gì bạn có trong tâm trí.

Answer 4

Giải pháp đơn giản nhất sẽ được nêu những gì bạn muốn là một cuộc tranh cãi, một chức năng với một chữ ký phù hợp:

template<typename P, bool (*F)(P,P)> struct Pair1stFunc2 { ... } 

Trong trường hợp này, đi qua một hàm template như là đối số thứ hai sẽ gây ra độ phân giải quá tải là thực hiện trên nó với P, P là loại đối số. Này hoạt động bởi vì bạn di chuyển độ phân giải quá tải ra khỏi struct Pair1stFunc2::operator()

Bạn cũng muốn khả năng đi qua trong một functor , nhưng những người cần phải được thông qua như là một đối số mẫu loại và sau đó tạo ra bên trong nhà điều hành():

typename F::result_type operator()(const P &lhs, const P &rhs) const 
{ return F()(lhs.first, rhs.first); } 

Ở đây, F là loại functor và F() một thể hiện của functor đó.

Trường hợp thứ ba đã được đề cập trước đó, mẫu functor. std :: less là một mẫu. Trong trường hợp đó, bạn cần một đối số mẫu khuôn mẫu.

Answer 5

Tương tự như unwesen. Nhưng bạn không cần phải sử dụng mẫu template.

#include <algorithm> 
#include <functional> 
#include <memory> 
#include <vector> 

typedef std::pair<int,int> MyPair; 
typedef std::vector<MyPair> MyPairList; 
MyPairList pairs; 


// Same as original. 
template <typename T,typename F> 
struct Pair1stFunc2 
{ 
    template <typename P> 
    typename F::result_type operator()(P &lhs, P &rhs) const 
    { F f; // Just need to create an anstance of the functor to use. 
     return f(lhs.first, rhs.first); } 

    template <typename P> 
    typename F::result_type operator()(const P &lhs, const P &rhs) const 
    { F f; // Just need to create an anstance of the functor to use. 
     return f(lhs.first, rhs.first); } 
}; 


void foo(void) 
{ 
    std::sort(pairs.begin(), 
       pairs.end(), 
       Pair1stFunc2<int, std::less<int> >()); // initialize the version of less 
}