AVR C++ Template Klasse

[markus (Gast)]

Hallo,

ich brauche eure Hilfe um den Knoten im meinem Kopf zu entwirren.

Ich wage gerade die ersten Schritte mit C++ auf dem AVR. Es stehen zwei 
Klassen für die Ausgabe von Werten zur Verfügung UART und LCD.  Über 
eine Template Klasse soll nun die Ausgabe gesteuert werden. Jede Klasse 
hat den Operator write implementiert. Mit Hilfe der Wrapper Klasse soll 
dann zur Laufzeit die Ausgabe auf das entsprechende Device umgeschaltet 
werden.
Der Compiler beschwert sich beim Bauen mit dieser Fehlermeldung

Error: cannot call member function `void UART::write(uint8_t)’ without object

Ich denke das Problem liegt daran, dass ich in der Wrapper methode die 
Klasse UART angebe anstelle der Instanz von UART. Wie komme ich jetzt an 
die Instanz von UART heran?

Ich hoffe, dass ich es möglichst verständlich erklärt habe. Vielleicht 
gelingt es ja jemanden meinen Knoten im Kopf zu entwirren. Oder gibt es 
noch einen einfacheren Ansatz zur Lösung dieses Problems?

merci für eure Inputs schon einmal!

markus

class UART0 {
  void write(uint8_t c) {
    write to uart
}
};
class LCD {
  void write{uint8_t c) {
    write to LCD
}
} ;

template <class T>
class Wrapper {
public:
  Wrapper(const T& device){}
  virtual void write(uint8_t){
    T::write();
  }
};

void main() {
UART uart0(9600);
Wrapper<UART> device(uart0);
device.write ‘A’ ;

[Oliver S. (oliverso)]

Bist du dir mit dem "virtual" in den Template sicher?

Oliver

[Maximilian (Gast)]

Indem du dir im Konstruktor der Wrapperklasse eine Referenz auf das 
übergebene Objekt merkst.

[Marco M. (marco_m)]

Du musst die Referenz auf die betreffende Objektinstanz im Konstruktor 
von Wrapper auch speichern, dann kommst du da auch wieder ran.

template <class T>
class Wrapper {
 T &m_device; 
public:
  Wrapper(T& device) : m_device(device) {}
  virtual void write(uint8_t){
    m_device::write();
  }
};

Aber Achtung: Wie du siehst habe ich hier kein 'const T&' mehr stehen. 
Warum? Die Methode write() die du in UART0 und LCD aufrufen willst sind 
nicht als const deklariert, aber nur solche Methoden kannst du mit einem 
konstanten Objekt aufrufen.

Ich verstehe allerdings nicht, warum deine ersten Schritte in C++ gleich 
mit Templates zu tun haben. Das ist so als würde man auf dem Hochseil 
laufen lernen.

[Karl H. (kbuchegg)]

Marco M. schrieb:

> Ich verstehe allerdings nicht, warum deine ersten Schritte in C++ gleich
> mit Templates zu tun haben. Das ist so als würde man auf dem Hochseil
> laufen lernen.

Ich versteh in erster Linie nicht, wozu dieses Template überhaupt gut 
sein soll. Ob man die virtuelle FUnktion im Template hat, oder ob man 
UART0 und LCD von einer gemeinsamen OutputDevice Klasse herleitet, kommt 
sich aufs gleiche raus.

class OutputDevice
{
  public:
    virtual ~OutputDevice() {};

    virtual void Write( uint8_t value ) = 0;
};

class UART0 : public OutputDevice
{
  public:
    virtual void write( uint8_t c )
    {
      write to uart
    }
};

class LCD : public OutputDevice
{
  public:
    virtual void write( uint8_t c )
    {
      write to LCD
    }
};


void foo( OutputDevce* pWhere )
{
  pWhere->write( 'a' );
}

int main()
{
  UART0 theUart;
  LCD   theLcd;

  foo( &theUart );    // foo gibt jetzt auf der UART aus
  foo( &theLcd );     // und jetzt landet die Ausgabe von Foo auf dem LCD
}

stink normale Polymorphie.
Genau das richtige um ...
> ... dann zur Laufzeit die Ausgabe auf das entsprechende
> Device umgeschaltet werden.
Genau dafür ist sie erfunden worden.

[Stefan H. (stefan_h16)]

markus schrieb:
> Mit Hilfe der Wrapper Klasse soll
> dann zur Laufzeit die Ausgabe auf das entsprechende Device umgeschaltet
> werden.

Ich glaube du Vererbung und virtuelle Methoden sind eher das wonach du 
suchen solltest.

class output
{
   public:
   virtual void write(char c);
}
class Uart : public output
{
   public:
   virtual void write( char c);
}
class LCD: public output
{
   public:
   virtual void write( char c);
}


void main()
{
 Uart u;
 LCD l;
 output * o;

 o = &u;
 o->write('a');
 o = &l;
 o->write('c');
}

(Entschuldigt bitte mein C++, ich programmiere zurzeit fast nur noch C).

Damit kannst du wirklich zur Laufzeit was umschalten. Templates sind 
Spielen nur während der Compilierung eine rolle.

Edit: Zu spät

[Klaus W. (mfgkw)]

Nur, um mal (in diesem Fall) templates schlecht zu machen:
Mit einem Template schreibt man zwar einmal die Schablone hin, das spart 
Quelltext gegenüber zwei sehr ähnliche Klassen komplett zu formulieren.
Es spart aber keinen Programmcode.

Denn: Wrapper<UART> und Wrapper<LCD> sind zwei voneinander unabhängige 
Klassen, die der Compiler bei Bedarf aus der Schablone generiert - und 
zwar vollständig.

D.h. daß auch gemeinsamer Code der beiden zweimal vollständig im 
Programm vorhanden ist, wenn beide Klassen in einem Programm verwendet 
werden.

Zudem sind die beiden nicht wirklich zur Laufzeit umschaltbar, weil sie 
keine gemeinsame Basisklasse haben. Mal das eine und mal das andere z.B. 
als Parameter zu verwenden für dieselbe Funktion, geht nicht.

Das als zusätzliche Erklärung, warum es besser ist, die Gemeinsamkeit in 
eine Basisklasse zu packen und die Unterschiede in eine Ableitung.

Hast du allerdings vor, in je einem Programm immer nur die eine oder die 
andere Version zu verwenden, kann man sich ein template vorstellen.
Dann macht aber ein virtual keinerlei Sinn.

[Marco M. (marco_m)]

Karl Heinz Buchegger schrieb:

> Ich versteh in erster Linie nicht, wozu dieses Template überhaupt gut
> sein soll. Ob man die virtuelle FUnktion im Template hat, oder ob man
> UART0 und LCD von einer gemeinsamen OutputDevice Klasse herleitet, kommt
> sich aufs gleiche raus.

Oh, das ist im Grunde genommen keine unübliche, wenn auch eher 
fortgeschrittene Technik. Man macht so etwas um Typen die in der 
Klassenhierachie nicht verwandt sind mit einem gemeinsamen Interface 
auszustatten, in etwa analog zu Haskell's Typklassen. Aber das ist nicht 
direkt Anfängerstoff.

[Karl H. (kbuchegg)]

Marco M. schrieb:

> Oh, das ist im Grunde genommen keine unübliche, wenn auch eher
> fortgeschrittene Technik. Man macht so etwas um Typen die in der
> Klassenhierachie nicht verwandt sind mit einem gemeinsamen Interface
> auszustatten, in etwa analog zu Haskell's Typklassen.

Das sagt mir jetzt nicht viel.
(Und Templates sind einer meiner schwachen Punkte)

Hast du da mal ein Schlagwort dafür?

[Marwin (Gast)]

Marco M. schrieb:
> Oh, das ist im Grunde genommen keine unübliche, wenn auch eher
> fortgeschrittene Technik.

Karl-Heinz weiss, was Templates sind. Die Frage war, wozu sie in diesem 
konkreten Fall gut sein sollen.

[Karl H. (kbuchegg)]

Karl Heinz Buchegger schrieb:
> Marco M. schrieb:
>
>> Oh, das ist im Grunde genommen keine unübliche, wenn auch eher
>> fortgeschrittene Technik. Man macht so etwas um Typen die in der
>> Klassenhierachie nicht verwandt sind mit einem gemeinsamen Interface
>> auszustatten, in etwa analog zu Haskell's Typklassen.
>
> Das sagt mir jetzt nicht viel.
> (Und Templates sind einer meiner schwachen Punkte)
>
> Hast du da mal ein Schlagwort dafür?


Ist schon ok.
Nach ein paar Minuten nachdenken, denke ich weiß, wo da die Reise 
hingeht. Man will den Klassen keine gemeinsame Basisklasse unterjubeln, 
noch nicht mal in Form eines gemeinsamen Interfaces und macht sich ein 
spezialisierte Interfaceklasse(n) (mit gemeinsamer Basisklasse), welches 
die Umsetzung erledigt. Im Grunde 'so ähnlich wie ein PIMPL Idiom mit 
gemeinsamer Basisklasse'. Und die kann man natürlich dann auch in 
Templates verpacken, so dass man das nicht jedesmal selber neu schreiben 
muss.

Ja ok.
Bringt ihm aber in diesem Falle nichts.
Ich hätte gesagt: Machs erst mal so, wie man das in C++ macht. 
Gemeinsame Basisklasse und Polymorphie.

[Marco M. (marco_m)]

Marwin schrieb:
> Marco M. schrieb:
>> Oh, das ist im Grunde genommen keine unübliche, wenn auch eher
>> fortgeschrittene Technik.
>
> Karl-Heinz weiss, was Templates sind. Die Frage war, wozu sie in diesem
> konkreten Fall gut sein sollen.

Das ist die Frage die ich beantwortet habe.

[Karl H. (kbuchegg)]

Streitet euch doch nicht. :-)


Ich denke, wenn man diese Frage hier liest

> Der Compiler beschwert sich beim Bauen mit dieser Fehlermeldung
> Error: cannot call member function `void UART::write(uint8_t)’
> without object
>
> Ich denke das Problem liegt daran, dass ich in der Wrapper methode die
> Klasse UART angebe anstelle der Instanz von UART. Wie komme ich jetzt an
> die Instanz von UART heran?

dann brauchen wir uns nicht lange darüber unterhalten, was eventuell bei 
einem fortgeschrittenem Programmierer ein Template-Problem sein könnte. 
Da haperts schon an ganz anderer Stelle.

Er hat sich einfach nur verrannt und darauf gesetzt, dass Templates 
irgendwie magisch das tun, was er auf seinem Wunschzettel hat.
Das übliche leidige Problem: Im Stroustroup die ersten 400 Seiten 
übersprungen, weil "das brauch ich eh alles nicht".

[Klaus W. (mfgkw)]

Nix für ungut, aber lies mal den Umschlag: der Mann heisst Stroustrup 
:-)

(nicht böse nehmen, aber die Steilvorlage war zu gut)

[Karl H. (kbuchegg)]

Klaus Wachtler schrieb:
> Nix für ungut, aber lies mal den Umschlag: der Mann heisst Stroustrup
> :-)
>
> (nicht böse nehmen, aber die Steilvorlage war zu gut)

LOL
Danke.

(wenn ich böse wäre, könnte ich jetzt sagen: Ich hab mich mehr um den 
Inhalt gekümmert als um den Umschlag :-)

[Edson (Gast)]

Karl Heinz Buchegger schrieb:
> (wenn ich böse wäre, könnte ich jetzt sagen: Ich hab mich mehr um den
> Inhalt gekümmert als um den Umschlag :-)

Um ehrlich zu sein, den Eindruck machst du auch. ;)

[Klaus W. (mfgkw)]

Karl Heinz Buchegger schrieb:
> (wenn ich böse wäre, könnte ich jetzt sagen: Ich hab mich mehr um den
> Inhalt gekümmert als um den Umschlag :-)

Wenn du böse wärst, hättest du gesagt, ICH hätte nur den Umschlag 
gelesen...

[Oliver S. (oliverso)]

Klaus Wachtler schrieb:
> Hast du allerdings vor, in je einem Programm immer nur die eine oder die
> andere Version zu verwenden, kann man sich ein template vorstellen.

markus schrieb:
> C++ auf dem AVR

Das ist auf einem AVR mit knappen RAM in diesem Fall durchaus sinnvoll.

Oliver