Diese Frage stammt von
Passing eines Mitgliedsfunktionszeigers auf eine überladene Klassenmethode in eine Schablonenfunktion.
Das musst du nicht lesen, um diese Frage zu verstehen. Wahrscheinlich haben beide Fragen die gleiche Antwort.

Ich bekomme Compiler-Fehler für den folgenden einfachen Code.

#include<set>
template<typename Return, typename T>
T ReceiveFuncPtr (Return (T::*Method)(const int&))
{
  T obj;  // Found and declared an object of actual container class
  (obj.*Method)(1);  // Some processing
  return obj;  // Returned that container class object with RVO
} 
int main ()
{
  ReceiveFuncPtr(&std::set<int>::insert); // ERROR
}

Der Fehler ist interessant:

 In function 'int main()':
error: no matching function for call to 'ReceiveFuncPtr(<unresolved overloaded function type>)'
   ReceiveFuncPtr(&std::set<int>::insert); // ERROR
                                        ^   
note: candidate is: 
note: template<class Return, class T> T ReceiveFuncPtr(Return (T::*)(const int&))
 T ReceiveFuncPtr (Return (T::*Method)(const int&))
   ^   
note:   template argument deduction/substitution failed:
note:   mismatched types 'const int&' and 'std::initializer_list<int>'
   ReceiveFuncPtr(&std::set<int>::insert); // ERROR
                                        ^   
note:   mismatched types 'const int&' and 'std::set<int>::const_iterator {aka std::_Rb_tree_const_iterator<int>}'
note:   mismatched types 'const int&' and 'std::set<int>::const_iterator {aka std::_Rb_tree_const_iterator<int>}'
note:   mismatched types 'const int&' and 'std::set<int>::value_type&& {aka int&&}'
note:   couldn't deduce template parameter 'Return'

Wenn Sie sich das @ ansehHinweis genau dann scheint es, dass der Compiler mit allen anderen Methoden außer der richtigen übereinstimmt! In diesem Fall sollte der Compiler mit @ übereinstimmeinsert(const std::set<int>::value_type&) akaconst int&. Wenn ich das @ ändeReceiveFuncPtr() Um einer anderen Überladung zu entsprechen, schlägt diese erneut fehl, indem diese Überladung übersprungen wird.

Um diese Situation zu debuggen, habe ich eine handgefertigte Version von @ erstellstd::set. Aber dascompiles fine:

template<typename T, typename T2 = void>
struct MySet
{
  std::pair<T,bool> insert (const T& i) { return std::pair<T,bool>(T(),true); }
  std::pair<T,bool> insert (T&& i) { return std::pair<T,bool>(T(),true); }
  void insert (std::initializer_list<T> i) { return false; }
}
int main ()
{
  ReceiveFuncPtr(&MySet<int>::insert);  // OK
}

Nach dem Surfen bin ich auf diesen Beitrag gestoßen:
Welche Regeln gelten für Funktionszeiger und Member-Funktionszeiger auf Standardfunktionen?

Obwohl es verwandt ist, löst es das Problem nicht.

Frag: Warum schlägt die Ersetzung der Mitgliedsfunktion bei der Standardbibliotheksmethode fehl, wenn dasselbe für die handschriftliche Klassenmethode gilt?

Aktualisiere:

Nach der richtigen Antwort bin ich mir sicher, dassinsert kann nicht verwendet werden. Der einzige Weg wäre hässliches Typecasting, was ein Overkill für dieses Problem ist.
Ein elegantesLösun ist @ zu verwendstd::set<int>::emplace<const int&> das hat nurtemplated-Version im Gegensatz zu Insert, das eine Mischung aus @ htemplate und non-template versions.
ufen Sie die Funktion wie folgt auf:

ReceiveFuncPtr(&std::set<int>::emplace<const int&>);

Übercompiles fine.