ich versuche gerade den Typ der Klasse zu ermitteln, welcher zu einem bestimmten Memberfunktionspointer gehört.

Folglich

typedef void (A::*fcn)(void)

das A.

Mein bisheriger Versuch war folgender:

#include <iostream>
#include <boost/type_traits/is_same.hpp>

struct A{
    int i;
    A(int u): i(u) {}
    void foo(){
        std::cout << "A::foo() " << i << std::endl;
    }
};

typedef void (A::*fcn)(void);

struct B{
    int i;
    B(int u): i(u) {}
    void foo(){
        std::cout << "B::foo() " << i << std::endl;
    }
};

template< typename R, typename T>
T get_type(R (T::*fcn)(void));

int main(int argc, char **argv){
    A a(1);
    fcn f=&A::foo;
    (a.*f)();
    if ( sizeof(A)==sizeof(get_type(&A::foo)) )
        std::cout << "A erkannt" << std::endl;
    if ( sizeof(A)==sizeof(get_type(&B::foo)) )
        std::cout << "leider hier auch Gleichheit und A erkannt" << std::endl;
//    if ( boost::is_same< A , get_type(&B::foo)>::value )
//        std::cout << "A detected" << std::endl;
    return 0;
}

In meinem code funktioniert soweit die Rückgabe der Typs, aber leider bin ich damit nicht zufrieden, da in den if's halt B::foo zu true evaluiert und ich nicht die Möglichkeit habe den Typ irgendwie weiter zu verwenden. Denn um ein Objekt von diesem Typ anlegen zu können, müsste ich ihn ja bereits kennen und daher scheitert mein Versuch über get_type ...
boost::is_same kann ich daher auch nicht verwenden, da ich halt einen Typ direkt brauche und nicht als Rückgabewert einer Funktion. Muss halt ein konstanter Ausdruck bei Templates sein.

Mein Problem ist nun, wie bekomme ich es hin, so einen Typ zu erhalten. Ein weiterer Vorteile wäre dann auch entsprechende Objekte von diesem Typ anzulegen oder halt als weitere Eingabe in templates zu verwenden.

Danke schon mal im Voraus

In C++0x kannst du so etwas mit decltype und Variadic Templates machen:

template <typename Class, typename Retval, typename... Args>
    Class memberPointerTypeInferenceHelper (Retval (Class::*) (Args...));
template <typename Class, typename MemberType>
    Class memberPointerTypeInferenceHelper (MemberType Class::*);
#define MEMBERPOINTER_CLASSTYPE(p) decltype (memberPointerTypeInferenceHelper (p))

...

MEMBERPOINTER_CLASSTYPE (&A::foo) a; // a ist vom Typ A

typedef void (A::*fcn)(void);

fcn kann sowieso nur eine Methode zu einem Typ A aufnehmen. Wieso also noch den Typen probieren herauszufinden?

Vielleicht solltest du dein Problem ein wenig konkreter erläutern. Womöglich gibt es eine andere Möglichkeit.

Grüssli

struct A{
 void foo(){};
};

...

A a;

Delegate <void> dg; // void ist der Parameter der Funktion und void ist immer Rueckgabewert von Funktionen.
dg.bind<A, &A::foo>(&a);

dg();

Nun wollte ich den ersten Parameter halt vermeiden und diesen irgendwie erkennen lassen. Automatisch halt, weil z.B. das A ist ja schon in &A::foo drin und da dachte ich, da kommt man wohl irgendwie dran

Grüße

template<typename ResultT>
class Delegate
{
  // ...
  template<typename ClassT>
  void bind(ResultT (ClassT::*func)(), ClassT& object);
  // ...
};

// Verwendung:
Delegate<void> dg;
dg.bind(&A::foo, a);

Oder du benutzt gleich Boost.Function in Verbindung mit Boost.Bind. Erscheint mir klüger. Oder du kannst dort kopieren, wie sie es gemacht haben.

Grüssli

Nun aus oben genannten Gründen und natürlich auch aus Interesse versuche ich halt einen anderen möglichen Weg. Ich kann auch mit meiner ursprünglichen Form

db.bind<A, &A::foo>(&a);

leben, aber schöner wäre die direkte Bestimmung der Klasse aus dem Templateparameter. Wäre halt übersichtlicher meines erachtens.

@audacia
das mit dem C++0x geht. Die Frage ist, ob es auch mit den bisherigen Bortmitteln des aktuellen Standards geht.

Grüße

Seltsames bind ... Schreib das Ding doch um: [...]

Das schränkt die Möglichkeiten deutlich ein. Mit seiner bind()-Methode kann er so etwas machen:

template <typename Retval = void>
    class Delegate
{
    template <typename Class, Retval (Class::*Method) (void)>
        static Retval methodPointerInvoker (void* data)
    { return (static_cast <Class*> (data)->*Method) (); }

    Retval (*invoker) (void*);
    void* data;

public:
    template <typename Class, Retval (Class::*Method) (void)>
        void bind (Class* obj)
    {
        data = obj;
        invoker = methodPointerInvoker <Class, Method>;
    }
};

Sicher, auch das hat Nachteile, aber es macht Delegates ein gutes Stück effizienter.

Allerdings würde ich als Workaround für dieses fundamentale Sprachdefizit von C++ Fast Delegates empfehlen. boost::function ist ganz nett, aber wundervoll ineffizient.

mysterio schrieb:

das mit dem C++0x geht. Die Frage ist, ob es auch mit den bisherigen Bortmitteln des aktuellen Standards geht.

Leider nicht.

Naja, man könnte ein wenig bescheissen, dann geht das auch:

template<typename FuncT, typename ClassT>
void bind(ClassT& object);

// Verwendung:
bind<&A::Foo>(a);

Grüssli

@Dravere
Doch Atmel AVR und ich werde deinen Vorschlag mal testen.

Danke nochmals für eure Hilfe

Gruß

Und zu Atmel AVR ... WAAAAAARRRRGGGHHHH
Da habe ich letztes Jahr grauenhafte Assemblererfahrungen damit gemacht

Grüssli

Naja, man könnte ein wenig bescheissen, dann geht das auch:

template<typename FuncT, typename ClassT>
void bind(ClassT& object);

// Verwendung:
bind<&A::Foo>(a);

&A::Foo ist kein Typ.

Hier der code:

template <typename Retval = void>
    class Delegate
{
    template <typename Class, Retval (Class::*Method) (void)>
        static Retval methodPointerInvoker (void* data)
    { return (static_cast <Class*> (data)->*Method) (); }

    Retval (*invoker) (void*);
    void* data;

public:
    template <typename Class, Retval (Class::*Method) (void)>
        void bind (Class* obj)
    {
        data = obj;
        invoker = methodPointerInvoker <Class, Method>;
    }
    template<typename Func, typename Class>
    void bind(Class* obj){
        data = obj;
        invoker = methodPointerInvoker <Class, Func>;
    }
};

struct A{
    void foo(){}
};

int main(int argc, char** argv){
    A a;
    Delegate<void> dg, dg1;
    dg.bind<A, &A::foo>(&a);
    dg1.bind<&A::foo>(&a);

    return 0;
}

das erste bind funktioniert und bei zweiten weiss der compiler nicht, was er machen soll

Fehlermeldung des compilers

Delegate.cc::33: error: no matching function for call to ‘Delegate<void>::bind(A*)’

über weitere Vorschläge würde ich mich freuen.

Gruß

Grüssli

Weiss nicht wozu man sich dann was eigenes stricken sollte.

Genau, so in der Art sieht mein Delegate aus und FastDelegates kenne ich auch. Habe auch schon drüber nachgedacht diese zu nutzen, aber brauchen halt auf dem AVR 33% mehr RAM. Statt 4Byte eben 6Byte. Klingt zwar erstmal nicht wirklich viel, aber wenn man mehrere hat und man bedenkt, dass manche AVR nicht mal 1kB RAM besitzen, muss man schon mal aufpassen.

#include <iostream>

template<typename RetT = void>
class Delegate
{
	// Static functions //
private:
	template<typename ClassT, RetT (ClassT::*Method)()>
	static RetT methodPointerInvoker(void* data)
	{
		return (static_cast<ClassT*>(data)->*Method)();
	}

	// Structs //
private:
	template<typename ClassT>
	class Proxy
	{
	private:
		ClassT* m_object;
		Delegate* m_delegate;

	public:
		Proxy(ClassT* object, Delegate* dg)
			: m_object(object)
			, m_delegate(dg)
		{
		}

	public:
		template<RetT (ClassT::*FUNC)()>
		void set() const
		{
			m_delegate->m_invoker = &methodPointerInvoker<ClassT, FUNC>;
		}
	};

	// Attributes //
private:
	RetT (*m_invoker)(void*);
	void* m_data;

	// Operators //
public:
	RetT operator ()()
	{
		return (*m_invoker)(m_data);
	}

	// Methods //
public:
	template<typename ClassT>
	Proxy<ClassT> const bind(ClassT* obj)
	{
		m_data = obj;
		return Proxy<ClassT>(obj, this);
	}
};

struct A
{
	void foo()
	{
		std::cout << "foo" << std::endl;
	}
};

int main()
{
	A a;

	Delegate<void> dg;
	dg.bind(&a).set<&A::foo>();

	dg();

	return 0; 
}

Grüssli

#define BIND_TO_DELEGATE(dg, obj, func) \
	dg.bind(obj).set<func>()

int main()
{
    A a;

    Delegate<void> dg;
    BIND_TO_DELEGATE(dg, &a, &A::foo);

    dg();

    return 0; 
}

Grüssli

Wenn ich es aber richtig ueberblicke, wird sich moeglicherweise nicht viel aendern, da ja nur ein temporaeres Proxy-Objekt angelegt wird und dies kann der Compiler bestimmt wegoptimieren.

Die urspruengliche Frage ist ja auch beantwortet, dass es mit dem aktuellen Standard halt nicht geht, aber im C++0X ein neues Sprachkonstrukt genau dies ermoeglicht.

Auf jeden Fall danke und ich habe mal wieder viel gelernt.

Dann habe ich auch noch Messungen mit einem avr-g++ gemacht und dort oh Ueberraschung -- beide Varianten liefern hier die gleichen Ergebnisse.

Nun weiss ich nicht ganz, ob es an der Version des Compilers liegt, da ich auf dem PC g++ in Version 4.3.2 und fuer den AVR in Version 4.2.1 benutze.

Bin sonst aber ganz zufrieden. Nochmals Danke.