functor 또는 함수를 인수로 전달

Question

저는 C++을 처음 접했고 현재 템플릿에 대해 더 잘 이해하고 있습니다. 다음은 내가 시험해 본 것입니다 :

#include <iostream> 
#include <typeinfo> 
using namespace std; 

template <typename T> 
class someContainer 
{ 
private: 
    T val1; 
    T val2; 
public: 
    someContainer(const T& in1, const T& in2) 
     :val1(in1), val2(in2) {} 

    template <template <typename Ty> class Comp> 
    void sort() 
    { 
     bool result = Comp<T>()(val1, val2); 
     cout << result << endl; 

     return; 
    } 
}; 

template <typename R> 
class Compare 
{ 
public: 
    bool operator() (const R& a, const R& b) 
    { 
     return a>b; 
    } 

}; 


int main() 
{ 
    someContainer<int> myCont(7,6); 
    myCont.sort<Compare>(); 


    cin.ignore(); 
    return 0; 
} 

저는 이번에는 기능에 대해 거의 같은 일을하고 싶습니다. 같은 기본적으로 뭔가 :

myCont.sort<function>(); 

그냥 확실하게 -이 원하지 않는 :

이

#include <iostream> 
#include <typeinfo> 
using namespace std; 

template <typename T> 
class someContainer 
{ 
private: 
    T val1; 
    T val2; 
public: 
    someContainer(const T& in1, const T& in2) 
     :val1(in1), val2(in2) {} 

    template <class Func> 
    void sort(Func func) 
    { 
     bool result = func(val1,val2); 
     cout << result << endl; 

     return; 
    } 
}; 

//Try for sort functor 

template <typename R> 
bool compare(const R& a, const R& b) 
{ 
    return a>b; 
} 


int main() 
{ 
    someContainer<int> myCont(7,6); 
    myCont.sort(compare<int>); 


    cin.ignore(); 
    return 0; 
} 

/편집 : 를 내가 정확히 명확하지 않았을 수 있습니다 알고 있습니다. myCont.sort<function>으로 전화를 걸고 싶습니다. 가능합니까? 나는 기능을 사용하면) (정렬 일반적인 기능을 전달하는 것이 가능하지만 클래스를 호출 할 것입니다 무엇이 아니라는 것을 깨닫게 :

#include <iostream> 
#include <typeinfo> 
using namespace std; 

template <typename T> 
class someContainer 
{ 
private: 
    T val1; 
    T val2; 
public: 
    someContainer(const T& in1, const T& in2) 
     :val1(in1), val2(in2) {} 

    template <typename Ret, typename Ty> 
    void sort(Ret (*_comp)(const Ty&, const Ty&)) 
    { 
     cout << "Comp is of type: " << typeid(_comp).name() << endl; 
     cout << _comp(val1, val2) << endl; 
     return; 
    } 
}; 

template <typename Ret, typename R> 
Ret compare(const R& a, const R& b) 
{ 
    return a>b; 
} 

int main() 
{ 
    someContainer<int> myCont(7,6); 
    myCont.sort(compare<bool,int>); 


    cin.ignore(); 
    return 0; 
} 

:

#include <iostream> 
#include <typeinfo> 
using namespace std; 

template <typename T> 
class someContainer 
{ 
private: 
    T val1; 
    T val2; 
public: 
    someContainer(const T& in1, const T& in2) 
     :val1(in1), val2(in2) {} 

    template <typename Ty> 
    void sort(bool (*_comp)(const Ty&, const Ty&)) 
    { 
     cout << "Comp is of type: " << typeid(_comp).name() << endl; 
     cout << _comp(val1, val2) << endl; 
     return; 
    } 
}; 

template <typename R> 
bool compare(const R& a, const R& b) 
{ 
    return a>b; 
} 

int main() 
{ 
    someContainer<int> myCont(7,6); 
    myCont.sort(compare<int>); 


    cin.ignore(); 
    return 0; 
} 

나는 심지어는 반환 형식을 사용자 정의 할 수 있습니다

하지만 그건 문제가 아닙니다. 나는 내가 할 수있는 최선의 방법으로 설명하지 않는다는 것을 알고있다. 그래서 내가 뭔가를 더하고 싶다면 무엇을 말해 주길 바란다. 제 아이디어는 다음과 같이 할 수 있기를 바랍니다. myControl.sort(); 또는 myContort.sort (function);

질문의 요지 : 다른 함수의 템플릿 인수로 함수 템플릿을 전달하는 방법이 있나요 - 내가 다른 함수의 템플릿 인수로 클래스 템플릿을 통과하는 것처럼 :

myCont.sort<Compare>(); // Compare is a template - not a template specialization 
//later in sort we got Comp<T>()() 

나는라는 함수 템플릿 비교있어 경우 다음 중 하나를 수행 할 수있는 방법이있다 :

myCont.sort<compare>(); 
myCont.sort(compare); 

내가 함수 템플릿 전달하려는 금지 - 비교의 전문화 - 나는 펑터로 이것을 할 수 있기 때문에, 나는 함수로 그것을 할 수 있을지 궁금하다. 나는하고 싶지 않아요 : 나는() 함수 템플릿을 다음 종류의 내부에 그것을 위해 전문화를 얻고 싶은

myCont.sort(compare<some_type>); 

.

미리 감사드립니다.

P.S : 그래서 여기 코멘트는 작은 크기가 될 수 있습니다 같아 다른 질문입니다 : 당신은이 코드 (C에서 함수 템플릿 매개 변수 ++의 디폴트 값이 있다면)이 (myCont.sort(compare)) 불가능했을 것이라고 생각하십니까?

#include <iostream> 
#include <typeinfo> 
using namespace std; 

template <typename T> 
class someContainer 
{ 
private: 
    T val1; 
    T val2; 
public: 
    someContainer(const T& in1, const T& in2) 
     :val1(in1), val2(in2) {} 

    template <typename Ret = bool ,typename Ty = T> 
    void sort(Ret (*_comp)(const T&, const T&)) 
    { 
     cout << "Comp is of type: " << typeid(_comp).name() << endl; 
     cout << _comp(val1, val2) << endl; 
     return; 
    } 
}; 

template <typename Ret, typename R> 
Ret compare(const R& a, const R& b) 
{ 
    return a>b; 
} 

int main() 
{ 
    someContainer<int> myCont(7,6); 
    myCont.sort(compare); 

    cin.ignore(); 
    return 0; 
} 

P.

Btw는 왜 내가 이걸 컴파일 할 수 없는지 궁금해했다. (확실히 someFunc가 없기 때문에.종류의 목록은 전문되는 유형)에서 someFunc의 유형을 추론 할 수 있어야한다 :

#include <iostream> 
#include <list> 
using namespace std; 

template <typename T> 
void display(const T& input) 
{ 
    for(auto i = input.cbegin(); i!=input.cend(); ++i) 
     cout << *i << ' '; 
    cout << endl; 
    return; 
} 

template <typename R> 
bool someFunc(const R& in1, const R& in2) 
{ 
    return in1>in2; 
} 

int main() 
{ 
    list<int> myList; 
    myList.push_back(5); 
    myList.push_back(137); 
    myList.push_back(-77); 
    display(myList); 

    myList.sort(someFunc); //change it to myList.sort(someFunc<int>) and it works 
    //however I believe the compiler should be able to infer the type of someFunc from 
    //the type of myList - I guess the STL just wasn't written for having template 
    //functions as a binary predicate 
    display(myList); 

    cin.ignore(); 
    return 0; 

}; 

Answer 1

C++가 과부하 기능이나 함수 템플릿의 그룹을 대표하는 모든 유형이 없습니다. 함수 그룹을 전달하는 유일한 방법은이를 포함하는 클래스입니다.

단일 함수 (템플릿 함수 인스턴스 일 수도 있음)를 전달하려는 경우 함수 포인터 (또는 아마도 참조)를 템플릿 인수로 사용할 수 있습니다. 그러나 함수의 유형을 추론 할 수는 없으며 템플릿 인수의 공식 유형과 정확히 일치해야합니다. 그리고 매개 변수가 일반 매개 변수 대신 템플릿 인수로 전달되는 것은 거의 가치가 없습니다. 매개 변수가 상수 인 경우 인라이닝 중에 좋은 컴파일러는 함수 포인터를 직접 호출에 최적화하고 인라인으로도 최적화합니다.

---

응답 편집 :

myCont.sort(compare)는 작업을 수행합니다. 방금 템플릿 입력란 Ty을 작성하여 사용하지 않고 코드에서 약간의 실수를 범했습니다. 사용하지 않은 인수는 추론 할 수 없습니다. 대신, 그런데

• http://ideone.com/NMalai

---

봐이 당신이

class Compare 
{ 
public: 
    template <typename R> 
    bool operator() (const R& a, const R& b) 
    { 
     return a>b; 
    } 

}; 

새로운 C++ 14 람다를 좋아할 것

template <typename R> 
class Compare 
{ 
public: 
    bool operator() (const R& a, const R& b) 
    { 
     return a>b; 
    } 

}; 

~을 생성하는 자동으로 operator() 템플릿.