Abstrakte Klasse durch Initlasisierungsliste referenzieren

[Evil-E (Gast)]

Ich muss für ein STM32 Microcontroller Projekt in C++ ein Objekt einer 
Klasse durch Referenz aufrufen, dass ein Interface initialisiert.
Das Problem ist dass das Objekt während der Runtime gebraucht wird aber 
es da noch nicht existiert.

Ich habe es mit constexpr versucht aber das scheint nicht zu 
funktionieren.

Die Klasse nennt sich Ltdc und das Objekt muss den Konstruktor aufrufen, 
zB LtdcObjekt(Ldtc()),


class Ltdc : public ILtdc
{
      public:
        constexpr Ltdc() noexcept {};
}


///////////////////////////////////////

class ILtdc
{
    protected:

    constexpr ILtdc() { }

    public:

    virtual ~ILtdc() {};
}
///////////////////////////////////////

class Ili9341 final
{
  public:

  Ili9341() noexcept;

  ILtdc & ltdc; //Interface Ltdc Referenz
}


///////////////////////////////////////

Ili9341:: Ili9341() noexcept :

    ltdc(Ltdc()), //Hier wird es in der cpp Datei aufgerugen
{ }


////////////////////////////////////////

Dieser Fehler wird mir geworden

error: #461 initial value of non-const must be an lvalue

[Wilhelm M. (wimalopaan)]

Evil-E schrieb:
> Ich muss für ein STM32 Microcontroller Projekt in C++ ein Objekt einer
> Klasse durch Referenz aufrufen, dass ein Interface initialisiert.
> Das Problem ist dass das Objekt während der Runtime gebraucht wird aber
> es da noch nicht existiert.
>
> Ich habe es mit constexpr versucht aber das scheint nicht zu
> funktionieren.

Hat damit auch nichts zu tun.


> Ili9341:: Ili9341() noexcept :
>
>     ltdc(Ltdc()), //Hier wird es in der cpp Datei aufgerugen
> { }
>
>
> ////////////////////////////////////////
>
> Dieser Fehler wird mir geworden
>
> error: #461 initial value of non-const must be an lvalue

Du versuchst eine lvalue-reference durch ein rvalue zu initialisieren. 
Das geht nicht.

[wolpino (Gast)]

Das Problem ist die Zeile:

    ltdc(Ltdc()), //Hier wird es in der cpp Datei aufgerugen

Da wird versucht, ein anonymes Object (rvalue) an eine Lvalue-Referenz 
zu binden. Das ist verboten, da das anonyme Objekt mit Verlassen des 
Konstruktors (genauer: der Initialisierungsliste) automatisch zerstört 
wird und man dann eine "hängene" (ungültige, tote) Referenz 
zurückbehält.

Achtung! Mit einem Zeiger anstelle einer Referenz würde das nicht besser 
werden!

Mögliche Lösung (ohne Änderung/Verbesserung des Klassendesigns):
Speichern einer dynamisch erzeugten Instanz, z.B. mittels 
std::unique_ptr.
Der std::unique_ptr sorgt dann automatisch auch für die Zerstörung des 
verwaltenen Objekts im Destruktor.

#include <memory>

class ILtdc
{
protected:
    constexpr ILtdc() { }

public:
    virtual ~ILtdc() {};
};

///////////////////////////////////////

class Ltdc : public ILtdc
{
public:
    constexpr Ltdc() noexcept {};
};

///////////////////////////////////////

class Ili9341 final
{
public:
  Ili9341() noexcept;
  std::unique_ptr<ILtdc> ltdc; //Interface Ltdc Referenz
};

///////////////////////////////////////

Ili9341::Ili9341() noexcept
: ltdc(std::make_unique<Ltdc>()) //Hier wird es in der cpp Datei aufgerugen
{
}

Das Member 'ltdc' kann dann wie ein Zeiger dereferenziert werden.

[Evil-E (Gast)]

Wir sind im Embedded Bereich und haben leider keinen Zugriff auf externe 
Bibliotheken, darunter auch die std Bibliothek.

[Wilhelm M. (wimalopaan)]

Dein Code von oben macht ja auch so, wie er da steht, keinen Sinn. Denn 
die offensichtliche Laufzeitpolymorphie benötigst Du ja gar nicht. Ein 
einfaches Datenelement wäre ja ausreichend.

[wolpino (Gast)]

Evil-E schrieb:
> Wir sind im Embedded Bereich und haben leider keinen Zugriff auf externe
> Bibliotheken, darunter auch die std Bibliothek.

Hmm, dann gibt es (wahrscheinlich) für das Target auch kein new/delete, 
somit sehe ich als Option nur das direkte Speichern einer Instanz der 
Implementierungsklasse (class Ltdc) als Datenmember in der Klasse 
Ili9341 (oder irgendwo anders).

class ILtdc
{
protected:
    constexpr ILtdc() { }

public:
    virtual ~ILtdc() {};
};

///////////////////////////////////////

class Ltdc : public ILtdc
{
public:
    constexpr Ltdc() noexcept {};
};

///////////////////////////////////////

class Ili9341 final
{
public:
  Ili9341() noexcept;
  Ltdc ltdc; //Interface Ltdc Referenz
};

///////////////////////////////////////

Ili9341::Ili9341() noexcept
: ltdc() //Hier wird es in der cpp Datei aufgerugen
{
}

[Dr. Sommer (Gast)]

Wahrscheinlich soll die Ili9341 Klasse doch gar nicht wissen, welche 
ILtdc Implementation da jetzt benutzt wird. Sonst wäre die abstrakte 
Klasse ziemlich nutzlos. Daher sollte man die Instanz außerhalb anlegen 
und übergeben:

class Ili9341 final
{
  public:

  Ili9341(ILtdc & l) noexcept;

  ILtdc & ltdc; //Interface Ltdc Referenz
}


///////////////////////////////////////

Ili9341:: Ili9341(ILtdc & l) noexcept :

    ltdc(l), // Referenz übernehmen
{ }

und dann, typischerweise als globale Variablen:

Ltdc ltdc;
Ili9341 ili9341 (ltdc);