ich wollte mal fragen, ob es irgendeine Möglichkeit gibt, ein Aufruftemplate zu schreiben, dem man einen Klassentyp und eine Methode des Klassentyps mitgeben kann, sodass dieses Template genau diese Methode der Klasse aufruft, wenn man ihm noch einen Objektzeiger und die entsprechenden Argumente übergibt.

Also Pseudocodemäßig folgendes:

template< typename Class, ??? Func >
struct caller {
    template< typename Arg1 >
    void call( Class* obj, Arg1& arg )
    {
        obj->Func( arg );
    };
};

class some {
public:
  func( int Arg1 );
};

some a;
caller<some,some::func>::call( &a, 5 );

Das würde ich verwenden wollen für die Tag-Geschichte, mit der ich mich gerade anfreunde. Speziell möchte ich für Tags eine gesonderte Klasse default_tag verwenden, welche bedeutet, dass die aufgerufene Methode keinen Tag benötigt, weil der Name eindeutig ist. Allerdings fällt mir im Moment kein Weg ein, wie man das ohne spezialisierte Duplizierung des Methodenaufrufs hinbekommt (oder mit Methodenzeigern, aber das ganze ist ja eigentlich statisch bestimmt, daher möchte ich diese nicht verwenden).

Viele Grüße,
Deci

Das funktioniert wirklich:

template< typename Class, typename Tag >
struct caller {
	template< typename Arg1, void (Class::*Func)( Arg1 ) >
	static void call( Class* c, Arg1 arg1 ) {
		(c->*Func)( arg1 );
	}
};

Entschuldigt, irgendwie hatte ich im Gedächtnis, dass ich das früher schonmal erfolglos versucht habe.

template <typename...>
struct pack;

template <typename Class, typename R, typename Args>
struct caller;

template <typename Class, typename R, typename... P, R (Class::* Ptr) (P...)>
struct caller<Class, R, pack<P...>, Ptr>
{
    template <typename... Args>
    R call(Class* obj, Args&&... args)
    {
        return (obj->*Ptr)(std::forward<Args>(args)...);
    }
};

Ungetestet.

Hier im Moment der einzige Ansatz, den ich bislang lauffähig bekommen habe:

#include <iostream>
using std::wcout;

struct default_tag {};

// 0 Arguments
template< typename Class, typename Tag = default_tag >
struct tag_call0
{
    template< typename Ret, Ret (Class::*FuncPtr)( Tag ) >
    struct intern {
        static Ret call( Class* object ) {
            return (object->*FuncPtr)( Tag() );
        }
    };
};

template< typename Class >
struct tag_call0< Class, default_tag >
{
    template< typename Ret, Ret (Class::*FuncPtr)() >
    struct intern {
        static Ret call( Class* object ) {
            return (object->*FuncPtr)();
        }
    };
};

// 1 Arguments
template< typename Class, typename Tag = default_tag >
struct tag_call1
{
    template< typename Ret, typename A1, Ret (Class::*FuncPtr)( A1, Tag ) >
    struct intern {
		template< typename Arg1 >
        static Ret call( Class* object, Arg1&& arg1 ) {
            return (object->*FuncPtr)( std::forward<Arg1>(arg1), Tag() );
        }
    };
};

template< typename Class >
struct tag_call1< Class, default_tag >
{
    template< typename Ret, typename A1, Ret (Class::*FuncPtr)( A1 ) >
    struct intern {
		template< typename Arg1 >
        static Ret call( Class* object, Arg1&& arg1 ) {
            return (object->*FuncPtr)( std::forward<Arg1>(arg1) );
        }
    };
};

struct tag {};

class some {
public:
	int func1() {  wcout << L"Called non-tagged method #1.\n"; return 1; }
	int func1( tag ) { wcout << L"Called tagged method #1.\n"; return 1; }

	int func2( float ) {  wcout << L"Called non-tagged method #2.\n"; return 1; }
	int func2( float, tag ) { wcout << L"Called tagged method #2.\n"; return 1; }

};

int main()
{
    some a;
    tag_call0< some, tag         >::intern< int, &some::func1 >::call( &a );
	tag_call0< some, default_tag >::intern< int, &some::func1 >::call( &a );

	tag_call1< some, tag         >::intern< int, float, &some::func2 >::call( &a, 4.0f );
	tag_call1< some, default_tag >::intern< int, float, &some::func2 >::call( &a, 4.0f );
}

Was ich mir noch funktionierend vorstellen könnte wäre soetwas wie:

tag_call< some, tag, decltype(&some::func) >::intern< &some_func >::call( &a );

Dann müsste man wenigstens nichtmehr die Argumente und Return-Types angeben, also könnte ein einziges äußeres template für alle Methoden mit 0-n Argumenten verwenden, muss dafür aber zweimal die Funktion angeben -.-

EDIT: Das mit dem decltype funktioniert so natürlich auch nicht, wenn die Funktion überladen ist, also muss man auch dort den vollen Prototypen angeben. Und das funktioniert natürlich nicht, weil man da den tag-dekorierten Typ schon braucht und das template soll ja den Aufruf erst mit dem Tag dekorieren, falls kein default_tag angegeben war. -.-

Sehe ich hier den Wald vor lauter Bäumen nicht mehr?

Viele Grüße,
Deci

#include <iostream>
using namespace std;

struct tag {}; 
struct default_tag {}; 

class some 
{
	public:

    	int func1() {  wcout << L"Called non-tagged method #1.\n"; return 1; } 
    	int func1( tag ) { wcout << L"Called tagged method #1.\n"; return 1; } 

    	int func2( float ) {  wcout << L"Called non-tagged method #2.\n"; return 1; } 
    	int func2( float, tag ) { wcout << L"Called tagged method #2.\n"; return 1; } 

}; 

template<bool Tagged>
struct Caller;

template<>
struct Caller<true>
{
	template<typename Class, typename FunPtrTyp>
	static int call(Class& obj, FunPtrTyp funPtr)
	{
		return (obj.*funPtr)(tag());
	}
};

template<>
struct Caller<false>
{
	template<typename Class, typename FunPtrTyp>
	static int call(Class& obj, FunPtrTyp funPtr)
	{
		return (obj.*funPtr)();
	}
};

template<typename Class, typename Tag, typename ReturnType>
struct caller_0
{
	typedef ReturnType (Class::*DefaultFunPtr)();
	typedef ReturnType (Class::*TaggedFunPtr)(tag);

	static const bool is_tagged = is_same<Tag, tag>::value;  
	typedef typename conditional<is_tagged, TaggedFunPtr, DefaultFunPtr>::type FunPtrTyp;	

	static ReturnType call(Class& obj, FunPtrTyp funPtr)
	{
		return Caller<is_tagged>::call(obj, funPtr);
	}

};

template<typename Tag, typename Class, typename ReturnType>
ReturnType callMe(Class a, ReturnType (Class::*fun)())
{
	// Edit: Ups, geht ja noch einfacher:
    return caller_0<Class, Tag, ReturnType>::call(a, &Class::func1);

    //return caller_0<Class, Tag, decltype((((Class*)nullptr)->*fun)())>::call(a, &Class::func1);
}

int main()
{
	some a;	

	callMe<tag>(a, &some::func1);
	callMe<default_tag>(a, &some::func1);
}

Ich glaub ohne variadic templates oder Ellipsen, kommst du nicht bequem so einfach dran vorbei mehrere Argumente zu übergeben.

Edit: Ich sehe gerade nen Fehler in Zeile 64. &Class::func1 ... Naja, jetzt ist es schon zu spät.