c++ static class mit und ohne Konstructor

[pointer->wald (Gast)]

Hi Leute,
hab eine Frage zu C++.

Ist der default Konstrucktor an, dann ist das Programm nur 1004 B groß.
Memory region         Used Size  Region Size  %age Used
        MFlash32:        1004 B        32 KB      3.06%
         RamLoc8:          40 B         8 KB      0.49%

Aktiviere ich meinen Konstrucktor wächst die Größe gleich auf 10952 B
Memory region         Used Size  Region Size  %age Used
        MFlash32:       10952 B        32 KB     33.42%
         RamLoc8:          80 B         8 KB      0.98%

Ich verstehe den Grund nicht...

Wo finde ich eine Erklärung dazu?

class test {
public:
    int get(){
       return x;
    }
    static test *inst(){
        static test x;
        return &x;
    }
    void set(int v){
        x = v;
    }
// mit Konstrucktor 10952 B code size
// mit default konstrucktor 1516 B
    test(){};
private:
        int x;
};

int main( void )
{
    test::inst()->set(7); 
return 0;
}

benutze den gnu c++ 14

[Oliver S. (oliverso)]

Die Version mit Konstruktor erzeugt thread-safe-Code beim Zugriff auf x, 
die Version mit default Konstruktor nicht.

https://godbolt.org/z/TkNs5J

Warum? Gute Frage...

Oliver
P.S. Gilt für den PC, wenn du für eine ander Plattform kompiliert, wäre 
es natürlich nicht ganz unwichtig, für welche...

[Einer K. (Gast)]

AVR-gcc 9.2 C++17 -Os

class Test
{
public:
  int get()
  {
    return x;
  }
  static Test &instance()
  {
    static Test x;
    return x;
  }
  void set(int x)
  {
    this->x = x;
  }
  // mit Konstruktor 180 Bytes code size
  // mit default konstrucktor 138 Bytes
  //Test() {};
private:
  int x;
};

int main( void )
{
  Test::instance().set(7);
  return 0;
}

Ohne Konstuktor wird das ganze Klassengedöns weg optimiert
Komplett

Mit Konstruktor macht der Kompiler alles inline.
Es wird kein zusätzliches call/ret generiert.

Kann man sic hauch schöne mit dem Disassembler anschauen.

[Oliver S. (oliverso)]

Arduino Fanboy D. schrieb:
> Mit Konstruktor macht der Kompiler alles inline.

Weil
> ; 0x800102 <guard variable for Test::instance()::x>

auch für AVR thread-safe-code erzeugt wird.

Oliver

[Niklas G. (erlkoenig)]

pointer->wald schrieb:
> static test x;

Die Initialisierung von statischen lokalen Variablen erfordert 
Thread-Synchronisation, welche sich anscheinend beim default-Konstruktor 
wegoptimieren lässt. Wenn 2 Threads gleichzeitig "inst" aufrufen muss 
sichergestellt werden, dass die "x" Variable nur exakt 1x initialisiert 
wird; da der eigene Konstruktor beliebigen Code enthalten kann, geht das 
nur über Mutexe. Dass dein Controller ggf. gar kein RTOS mit Threads 
nutzt weiß der Compiler nicht.

Die Lösung ist ganz schlicht eine Klassen-statische Variable zu 
verwenden:

class test {
  private:
    static test instance;
  public:
    static test& inst() {
        return instance;
    }
};

Der Nachteil daran ist, dass der Konstruktor immer aufgerufen wird, auch 
wennn "inst" niemals aufgerufen wird; dafür kann man den Konstruktor 
auch ggf. "constexpr" machen, was die Initialisierung noch effizienter 
macht.

Es ist auch besser eine Referenz statt eines Pointers zurückzugeben.

[hmmmm (Gast)]

Arduino Fanboy D. schrieb:
> Ohne Konstuktor wird das ganze Klassengedöns weg optimiert
> Komplett

Frage:

Würde bedeuten dass ich ohne existierenden Konstruktor keine
zweite (oder weitere) Instanz(en) anlegen kann? Denn bei
mehreren Instanzen brauche ich ja "Klassengedöns" (?), sonst
würde ja für jede Instanz neuer Code angelegt (werden müssen)(?).

[Niklas G. (erlkoenig)]

hmmmm schrieb:
> Würde bedeuten dass ich ohne existierenden Konstruktor keine
> zweite (oder weitere) Instanz(en) anlegen kann?

Doch klar. Es ist ja doch einer vorhanden, der wird automatisch erzeugt. 
Ohne Konstruktur könntest du überhaupt keine Instanz anlegen!

hmmmm schrieb:
> Denn bei
> mehreren Instanzen brauche ich ja "Klassengedöns" (?), sonst
> würde ja für jede Instanz neuer Code angelegt (werden müssen)(?).

Code wird nur pro Klasse erzeugt, nicht pro Instanz. Keine Ahnung was 
"Klassengedöns" ist und wie da was von wegoptimiert werden kann...

[Oliver S. (oliverso)]

Das klappt schon. Die Variante ohne Konstruktor ist halt nicht 
thread-safe.

Falls nicht schon vorhanden, reduziert -fno-threadsafe-statics die 
Codegröße mit Konstruktor etwas.

Oliver

[hmmmm (Gast)]

Niklas G. schrieb:
> Code wird nur pro Klasse erzeugt, nicht pro Instanz.

Das ist mir schon klar. War auch bereits Inhalt meiner Frage.

Niklas G. schrieb:
> Keine Ahnung was
> "Klassengedöns" ist und wie da was von wegoptimiert werden kann...

Unser allwissender Fanboy behauptet jedenfalls sowas.

Unter seinem "Klassengedöns" habe ich verstanden dass das Handling
vorhanden ist für mehrere Instanzen ein und denselben Code zu
verwenden wie es normalerweise implementiert ist.

[pointer->wald (Gast)]

Danke für die Antworten!

Der Code ist für den LPC11xx Chip.

[Oliver S. (oliverso)]

hmmmm schrieb:
> Unter seinem "Klassengedöns" habe ich verstanden

Schau dir doch einfach den Assemblercode an, da siehst du, was passiert.

Oliver

[Einer K. (Gast)]

Niklas G. schrieb:
> Keine Ahnung was
> "Klassengedöns" ist und wie da was von wegoptimiert werden kann...

Das asm Listing "ohne Konstuktor" zeigt, dass alles was die 
Klasse/Instanz betrifft, nicht im generierten Code erscheint.
Es wird komplett weg optimiert.
Mit Stumpf und Stiel.

Ein Programm nur mit:

int main( void )
{
  return 0;
}

Erzeugt exakt den gleichen Maschinencode.

[hmmmm (Gast)]

Arduino Fanboy D. schrieb:
> Es wird komplett weg optimiert.
> Mit Stumpf und Stiel.

Dann erklär mal bitte wie mehrere Instanzen einer Klasse
ohne "Klassengedöns" auskommen sollen.

Gut, du kannst dich rausreden indem du dein "Klassengedöns"
nach deinem Belieben definierst.

Ich habe es nun mal so aufgefasst wie von mir beschrieben.

[Markus (Gast)]

hmmmm schrieb:
> Dann erklär mal bitte wie mehrere Instanzen einer Klasse
> ohne "Klassengedöns" auskommen sollen.

Im konkreten Code kommen mehrere Instanzen nicht vor.


Niklas G. schrieb:
> Es ist auch besser eine Referenz statt eines Pointers zurückzugeben.
Kurze Zwischenfrage: Warum bietet sich hier eher eine Referenz an?

[Niklas G. (erlkoenig)]

Arduino Fanboy D. schrieb:
> Es wird komplett weg optimiert.
> Mit Stumpf und Stiel.

Weil die Klasse halt nicht wirklich verwendet wird. Auch eine Klasse 
ohne expliziten Konstruktor kann "normalen" Klassen-Spezifischen-Code 
erzeugen, also z.B. eigenständige Member-Funktionen.

Markus schrieb:
> Kurze Zwischenfrage: Warum bietet sich hier eher eine Referenz an?

Ein Zeiger sagt dem Aufrufer, dass er auch Null sein kann, und er eben 
auf Null prüfen muss. Eine Referenz kann nicht Null sein, weshalb man 
dort keine Prüfung machen muss. Im konkreten Fall wird nie Null 
zurückgegeben, also kann man auch eine Referenz nehmen.

[Einer K. (Gast)]

hmmmm schrieb:
> Dann erklär mal bitte wie mehrere Instanzen einer Klasse
> ohne "Klassengedöns" auskommen sollen.
Das war kein Thema im Eingangsposting.

Da dreht es sich nur um die unterschiedlichen Codegrößen, in 
Abhängigkeit von der Anwesenheit eines eigenen Konstruktors.

[hmmmm (Gast)]

Arduino Fanboy D. schrieb:
> Das war kein Thema im Eingangsposting.

ja neee .... iss klaa

[Einer K. (Gast)]

hmmmm schrieb:
> Arduino Fanboy D. schrieb:
>> Das war kein Thema im Eingangsposting.
>
> ja neee .... iss klaa

Ich beziehe mich auf das Eingangsposting und mein "Experiment" dazu.
Wenn du über irgendwas anderes schwadronieren möchtest, nur zu, aber 
halt mich bitte da raus.

[Rigó M. (rig_m)]

Einfach mit -fno-threadsafe-statics kompilieren, dann kann man statische 
Klassen auf dem AVR effektiv nutzen.

Die Erklärung für diesen Switch:
Do not emit the extra code to use the routines specified in the C++ ABI 
for thread-safe initialization of local statics. You can use this option 
to reduce code size slightly in code that doesn’t need to be 
thread-safe.

https://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Dialect-Options.html