Class method pointer

[Reginald L. (Firma: HEGRO GmbH) (reggie)]

Huhu!

ich versuche ein Pointer-Array zu erstellen, welche verschiedene 
Methoden unterschiedlicher Klassen aufnimmt. Allerdings scheitert es 
schon daran, eine Methode einer einzigen Klasse aufzunehmen.

  void (GUI::Widget::TextBox::*asdf)() = NULL;
  asdf = &GUI::Widget::TextBox::Update;

  if (asdf != &GUI::Widget::TextBox::Update)
    int b = 1;
  else
    int c = 2;

        bool d = asdf;

Der Code kompiliert ohne zu meckern, allerdings wird Update() nicht 
angesprungen. Auch stimmen die Adressen nicht überein. Update hat bspws 
0x8004a34 und asdf 0x8004a35. Das ist auch durchgehend so, die Pointer 
haben immer die Adresse der Funktion + 1.

Habe auch schon gegoogelt, aber hat anscheinend nicht viel geholfen.

Hat jemand eine Idee? Ich benutze GCC 5.3.0 + GDB. Programm läuft auf 
einem STM32F4.

[tictactoe (Gast)]

Reginald L. schrieb:
> bool d = asdf;

bool d = irgendein_gui_widget_textbox_ptr->*asdf();

könnte helfen.

Die Sache mit Adresse+1 ist kein Grund zur Sorge. Das ist 
Compiler-interne Angelegenheit.

[tictactoe (Gast)]

tictactoe schrieb:
> bool d = irgendein_gui_widget_textbox_ptr->*asdf();
> könnte helfen.

Unsinn. Die Funktion hat ja keinen Rückgabewert. Daher nur:

irgendein_gui_widget_textbox_ptr->*asdf();

[Reginald L. (Firma: HEGRO GmbH) (reggie)]

Sry, Copy&Paste Fehler, Rückgabewert ist natürlich bool.

Allerdings will er so auch nicht:

  TextBox* consoletb = new TextBox();
  consoletb->Create(consolewnd, 0, 0, TFT_PHYSICAL_WIDTH, TFT_PHYSICAL_HEIGHT,
    Color::Green, Color::WhiteSmoke, Memory::Resource::Object::GetFont((char*)"MS Sans Serif 12pt"));
  consoletb->Show();

  bool (GUI::Widget::TextBox::*asdf)() = NULL;
  asdf = &GUI::Widget::TextBox::Update;
  bool b = consoletb->*asdf();

 error : must use '.*' or '->*' to call pointer-to-member function in 
'asdf (...)', e.g. '(... ->* asdf) (...)'
1>    bool b = consoletb->*asdf();

Die Meldung verstehe ich allerdings nicht.

EDIT: Du bist ein Schatz, da muss eine Klammer hin :>
  bool b = (consoletb->*asdf)();

[Reginald L. (Firma: HEGRO GmbH) (reggie)]

Achso, es geht noch weiter :)

Erst mal danke, da saß ich gestern ein paar Stunden dran, du hast es mit 
deinem 3 Zeiler geschafft mein Problem in einer Minute zu lösen :>

Ist es möglich auch Methoden verschiedener Klassen in einen Pointer zu 
packen? So etwas in Richtung void? Warscheinlich eher weniger, soweit 
ich mich informieren konnte?

[Rolf M. (rmagnus)]

Reginald L. schrieb:
> Ist es möglich auch Methoden verschiedener Klassen in einen Pointer zu
> packen?

Ja, wenn die Klassen von einer gemeinsamen Basisklasse abgeleitet sind. 
Oder du musst mit Templates arbeiten. Kommt halt drauf an, wofür das 
ganze gut sein soll. Willst du so eine Art Nachbau eines 
signal/slot-Mechanismus machen?

> So etwas in Richtung void? Warscheinlich eher weniger, soweit ich mich
> informieren konnte?

Dann würde ja die ganze Typsicherheit flöten gehen.

[Mark B. (markbrandis)]

Reginald L. schrieb:
> ich versuche ein Pointer-Array zu erstellen, welche verschiedene
> Methoden unterschiedlicher Klassen aufnimmt.

Darf man fragen, was der Sinn der Sache ist?

[Niklas G. (erlkoenig)]

Reginald L. schrieb:
> Ist es möglich auch Methoden verschiedener Klassen in einen Pointer zu
> packen?
Ja, das geht in gewissen Grenzen, indem man std::bind oder Lambdas 
nutzt. Hierbei muss man allerdings bei der Zuweisung direkt die Instanz 
mitgeben. Das Ergebnis ist sozusagen ein polymorpher Funktionszeiger:

#include <iostream>
#include <functional>

class A {
  public:
    void foo (int x) { std::cout << "A::foo(" << x << ")\n"; }
};

class B {
  public:
    void foo (int x) { std::cout << "B::foo(" << x << ")\n"; }
};

// Variante 1: std::bind
void test1 () {
  // Instanzen der Klassen
  A a;
  B b;
  
  // "Polymorpher" Funktionspointer
  std::function<void(int)> fun;
  
  // Weise A::foo zu, mit Instanz a
  fun = std::bind (&A::foo, &a, std::placeholders::_1);
  
  // Rufe auf
  fun (42);
  
  // Weise B::foo zu, mit Instanz b
  fun = std::bind (&B::foo, &b, std::placeholders::_1);
  
  // Rufe auf
  fun (84);
}

// Variante 2: Lambda
void test2 () {
  // Instanzen der Klassen
  A a;
  B b;
  
  // "Polymorpher" Funktionspointer
  std::function<void(int)> fun;
  
  // Weise A::foo zu, mit Instanz a
  fun = [&a] (int x) { a.foo (x); };
  
  // Rufe auf
  fun (42);
  
  // Weise B::foo zu, mit Instanz b
  fun = [&b] (int x) { b.foo (x); };
  
  // Rufe auf
  fun (84);
}

int main() {
  test1 ();
  test2 ();
  return 0;
}

Die Ausgabe ist:

A::foo(42)
B::foo(84)
A::foo(42)
B::foo(84)

Siehe:
http://ideone.com/3DAA7L
http://en.cppreference.com/w/cpp/utility/functional/bind
http://en.cppreference.com/w/cpp/utility/functional/function

[Tom (Gast)]

>Ist es möglich auch Methoden verschiedener Klassen in einen Pointer zu
packen?

Das geht, wird aber beliebig hässlich und wackelig.

Wenn man die Klassen, auf deren Methoden man zugreifen will, nicht 
selbst schreibt und so keine Interfaces einführen kann, kann man mit 
std::function und std::bind etwas bauen:

#include <iostream>
#include <functional>
#include <vector>

class Foo
{
public:
    Foo(const std::string& s) : s_(s)
    {
    }

    void doit() const
    {
        std::cout << "Foo(" << s_ << ")\n";
    }

    int bla()
    {
        std::cout << "Foo::bla()\n";
        return 23;
    }

private:
    std::string  s_;
};


class Bar
{
public:
    Bar() : i_(23)
    {
    }

    void prnt() const
    {
        std::cout << "Bar(" << i_ << ")\n";
    }

    void set(int i)
    {
        i_ = i;   
    }

private:
    int i_;
};



int main()
{
    typedef std::function<void(void)> VoidVoidFunc; 
    
 
    Foo foo1{"foo1"};
    Foo foo2{"foo2"};
    Bar bar;

    std::vector<VoidVoidFunc> functions;

    functions.push_back( std::bind(&Foo::doit, &foo1) );
    functions.push_back( std::bind(&Foo::doit, &foo2) );
    functions.push_back( std::bind(&Bar::prnt, &bar) );
    functions.push_back( std::bind(&Bar::set, &bar, 1111) );
    functions.push_back( std::bind(&Bar::prnt, &bar) );
    functions.push_back( std::bind(&Foo::bla, &foo2) );

    for (auto& f: functions)
    {
        f();
    }
}

Nachtrag: Zu langsam getippt ;)

[Reginald L. (Firma: HEGRO GmbH) (reggie)]

Hui! Vielen lieben Dank dafür! Ich fang gleich mal an mich 
reinzuarbeiten!

[Tom (Gast)]

Die Lambdas sind etwas netter als std::bind, weil damit auch solche 
Schweinereien ganz einfach funktionieren:

  functions.push_back( [&foo1, &bar]() {int tmp = foo1.bla();  bar.set(tmp);} );

Bei all diesen Features muss man sehr darauf achten, sie nicht 
übertrieben einzusetzen. Die Möglichkeiten sind verlockend, aber man 
kann sehr leicht völlig undurchdringliche Programmstrukturen bauen. 
std::function ist auch nichts für extrem performancekritische 
Anwendungen.

[Reginald L. (Firma: HEGRO GmbH) (reggie)]

Schweinereien find ich toll :D.
Die Performance ist mir lediglich beim Zugriff auf die Memberfunktion 
wichtig, da, bei Bedarf, in der Mainloop darauf zugegriffen wird. Die 
Initialisierungen finden beim Programmstart statt.

Von std::function habe ich auch schon gehört, heute wirds mir aber schon 
zu spät, morgen ist auch noch ein Tag.

[Reginald L. (Firma: HEGRO GmbH) (reggie)]

So, ich habe mich jetzt ein wenig in std:function eingelesen,
Tom schrieb:
> std::function ist auch nichts für extrem performancekritische
> Anwendungen.
und das gefällt mir nicht so ganz. Gibt es noch andere Möglichkeiten? Es 
geht lediglich um statische Methoden einer Klasse die in die Interrupts 
eingebunden werden sollen. So eine Art lookuptable die der Interrupt 
durchrennt.

[Niklas G. (erlkoenig)]

Reginald L. schrieb:
> Es
> geht lediglich um statische Methoden einer Klasse die in die Interrupts
> eingebunden werden sollen.
Ach statische Funktionen! Das macht die Sache viel einfacher. Da 
kannst du ordinäre Funktions-Pointer nutzen, denn statische 
Member-Funktionen verhalten sich effektiv wie freie Funktionen:

#include <iostream>

class A {
  public:
    static void foo (int x) { std::cout << "A::foo(" << x << ")\n"; }
};

class B {
  public:
    static void foo (int x) { std::cout << "B::foo(" << x << ")\n"; }
};

// Definiere Funktionspointer-Typ
using fun_t = void (*) (int);

int main () {
  fun_t f = &A::foo;
  f (42);
  f = &B::foo;
  f (33);
}

[Reginald L. (Firma: HEGRO GmbH) (reggie)]

Gerade habe ich einfach mal so folgendes gemacht und es scheint zu 
funktionieren:

class IRQ
{
public:
        init(void(*irq_handler_func)(void))
{
 exti_handler[0] =  irq_handler_func;
};
private:
  static void (*exti_handler[5])(void);

  friend void ::EXTI0_IRQHandler();
};

extern "C" void EXTI9_5_IRQHandler()
{
  Stm32::IRQ::exti_handler[0]();
  asm("bkpt 255");
}

inline void Stm32::Ethernet::temp()
{
  int x = 1;
}

Allerdings verstehe ich von der Materie zu wenig, als dass ich sagen 
könnte ob die Methode ansatzweise elegant ist.

[Reginald L. (Firma: HEGRO GmbH) (reggie)]

Niklas G. schrieb:
> Das macht die Sache viel einfacher. Da
> kannst du ordinäre Funktions-Pointer nutzen, denn statische
> Member-Funktionen verhalten sich effektiv wie freie Funktionen:
Hui ging ja fix! Gerade erst gelesen.
Das mit dem Funktionspointer-Typ finde ich zumindest schonmal eleganter, 
danke erstmal, ich mach mich ran :)

Niklas G. schrieb:
> Ach statische Funktionen!
Ja, ich stehe gerade vor einer anderen Aufgabe, dachte nur, es wäre 
unsinnig einen neuen Thread zu eröffnen, da das hier ganz gut reinpasst. 
Das Problem mit der GUI Klasse ist geblieben, aber momentan noch auf 
Eis.

Danke nochmal!

[Niklas G. (erlkoenig)]

Reginald L. schrieb:
> init(void(*irq_handler_func)(void))
Fehlt da nicht der Rückgabe-Typ...

Reginald L. schrieb:
> Das mit dem Funktionspointer-Typ finde ich zumindest schonmal eleganter,
Ja das erhöht die Lesbarkeit enorm...

Reginald L. schrieb:
> als dass ich sagen
> könnte ob die Methode ansatzweise elegant ist.
So ist die Anzahl Callbacks halt auf 5 beschränkt... Etwas schlauer wäre 
es, eine intrusive verkettete Liste zu machen. Der Benutzer legt dann 
pro Callback-Funktion eine globale Instanz von Observer an:

#include <iostream>

// Funktionszeiger-Typ definieren für Callback-Funktion
using IrqHandlerFun = void (*) ();

class Publisher;

// Element der verketteten Liste (intrusive List)
class Observer {
  public:
    constexpr inline Observer (IrqHandlerFun f) : function (f), next (nullptr) {}
    // Alternative: Direkt registrieren
    Observer (IrqHandlerFun f, Publisher& pub);
    // Funktionszeiger
    IrqHandlerFun function;
    // Zeiger auf nächstes Element
    Observer* next ;
};

// Für jeden Interrupt wird ein Publisher angelegt
class Publisher {
  public:
    // Observer hinzufügen und verketten
    void addObserver (Observer* o) {
      if (first)
        o->next = first;
      else
        o->next = nullptr;
      first = o;
    }
    // Alle Funktionszeiger aufrufen
    void call () {
      for (Observer* scan = first; scan; scan = scan->next) {
        scan->function ();
      }
    }
  private:
    Observer* first = nullptr;
};

Observer::Observer (IrqHandlerFun f, Publisher& pub) : function (f), next (nullptr) {
  pub.addObserver (this);
}


// Publisher für IRQ's anlegen

Publisher pubIRQ_EXTI9_5;

extern "C" void EXTI9_5_IRQHandler() {
  // Alle Funktionszeiger aufrufen
  pubIRQ_EXTI9_5.call ();
}

Publisher pubIRQ_TIM3;

extern "C" void TIM3_IRQHandler() {
  // Alle Funktionszeiger aufrufen
  pubIRQ_TIM3.call ();
}


// === User Code ===


// Eine statische Member-Funktion
class MyHandler1 {
  public:
    static void handlerFun () {
      std::cout << "MyHandler1::handlerFun\n";
    }
};
Observer MyHandler1_Observer { &MyHandler1::handlerFun };


// Eine freie Funktion
void OtherHandlerFun () {
  std::cout << "OtherHandlerFun\n";
}

// Automatische Registration nutzen
Observer OtherHandler_Observer { &OtherHandlerFun, pubIRQ_EXTI9_5 };


int main () {
  pubIRQ_EXTI9_5.addObserver (&MyHandler1_Observer);
  
  // Simuliere Interrupts
  EXTI9_5_IRQHandler ();
  TIM3_IRQHandler ();
}

Noch eleganter ist dann das komplette Observer-Pattern:

#include <iostream>

class Publisher;

// Abstrakte Basisklasse für Handler-Klassen
class Observer {
  friend class Publisher;
  public:
    virtual void event () = 0;
  private:
    Observer* next;
};

class Publisher {
  public:
    // Observer hinzufügen und verketten
    void addObserver (Observer* o) {
      if (first)
        o->next = first;
      else
        o->next = nullptr;
      first = o;
    }
    // Alle Funktionszeiger aufrufen
    void call () {
      for (Observer* scan = first; scan; scan = scan->next) {
        scan->event ();
      }
    }
  private:
    Observer* first = nullptr;
};

// Publisher für IRQ's anlegen

Publisher pubIRQ_EXTI9_5;

extern "C" void EXTI9_5_IRQHandler() {
  // Alle Funktionszeiger aufrufen
  pubIRQ_EXTI9_5.call ();
}

Publisher pubIRQ_TIM3;

extern "C" void TIM3_IRQHandler() {
  // Alle Funktionszeiger aufrufen
  pubIRQ_TIM3.call ();
}

// === User Code ===

class Handler1 : public Observer {
  public:
    virtual void event () {
      std::cout << "Handler1::event\n";
    }
} handler1;

class Handler2 : public Observer {
  public:
    virtual void event () {
      std::cout << "Handler2::event\n";
    }
} handler2;

int main () {
  pubIRQ_EXTI9_5.addObserver (&handler1);
  pubIRQ_TIM3.addObserver (&handler2);

  pubIRQ_EXTI9_5.call ();
  pubIRQ_TIM3.call ();
}

So muss man gar nicht mehr mit Funktionspointern herumhantieren sondern 
nutzt das wohlbekannte Observer Pattern. Einzige Modifikation ist hier 
der "next" Pointer, um eine Liste aufzubauen.

Implementierung von Funktionen zum Entfernen von Observern sind dem 
Leser überlassen ;-)

[Reginald L. (Firma: HEGRO GmbH) (reggie)]

Niklas G. schrieb:
> Fehlt da nicht der Rückgabe-Typ...
Ich war schlampig beim umtippen. Entschuldigung :P

Na da hasste mir ne Steilvorlage geliefert, da muss ich ja gar nicht 
mehr nachdenken ;)