Was ist ein statischer Konstruktor?

Diese Frage wurde mir in einem Interview gestellt:

Was ist ein statischer Konstruktor?

Existiert es in C++? Wenn ja, erläutern Sie dies bitte anhand eines Beispiels.

C++ hat keine statischen Konstruktoren, aber Sie können sie emulieren, indem Sie eine statische Instanz einer verschachtelten Klasse verwenden.

class has_static_constructor {
    friend class constructor;

    struct constructor {
        constructor() { /* do some constructing here … */ }
    };

    static constructor cons;
};

// C++ needs to define static members externally.
has_static_constructor::constructor has_static_constructor::cons;

In C++ gibt es keinen statischen Konstruktor. In C# (und wahrscheinlich auch in Java) können Sie einen statischen Konstruktor definieren, der automatisch von der Laufzeit aufgerufen wird, um statische Member zu initialisieren.

Bei weiteren Fragen und Interesse können Sie dieses Thema lesen:

Was ist der Grund dafür, keinen statischen Konstruktor in C++ zu haben?

Da wir in C++ technisch gesehen keine statischen Konstruktoren haben, müssen Sie entscheiden, ob es sich lohnt, etwas Kniffliges zu tun, um das Problem zu erzwingen (z. B. eine statische Instanz einer verschachtelten Klasse zu verwenden), oder Ihren Code nur leicht umzustrukturieren, um a aufzurufen statischen Initialisierer früh im Leben Ihres Programms.

#include <iostream>           // cout, endl

class Foo {
   public:
      static int s_count;

      // Constructor definition
      Foo (int l, int w, int h)
      {
         cout <<"Foo ctor called." << endl;
         length = l;
         width  = w;
         height = h;

         // Increase every time object is created
         s_count++;
      }

      int vol ()
      {
         return length * width * height;
      }

      static void initCount()
      {
         s_count = 0;
      }

      static int getCount()
      {
         return s_count;
      }

   private:
      double length;     // Length of a box
      double width;      // Width  of a box
      double height;     // Height of a box
};

// Initialize static member of class Foo
int Foo::s_count;  // Initializing here is non-deterministic

int main(void) {

   Foo::initCount();  // Initializing here is deterministic

   // Print total number of objects before creating object.
   cout << "Inital Count: " << Foo::getCount() << endl;

   Foo Foo1(3, 1, 1);    // Declare box1
   Foo Foo2(8, 6, 2);    // Declare box2

   // Print total number of objects after creating object.
   cout << "Final Count: " << Foo::getCount() << endl;

   return 0;
}

Output:

$ static_init_test
Inital Count: 0
Foo ctor called.
Foo ctor called.
Final Count: 2

Dieser Ansatz gefällt mir besser; Als Silberstreif am Horizont nimmt es das Nicht-aus der nicht-deterministischen Initialisierung heraus.

Es gibt jedoch einen Haken: Diese Technik ist unzureichend, wenn Sie versuchen, statische konstante Variablen zu initialisieren. Bei statischen konstanten Variablen müssen Sie sie für die Klasse privat machen und Getter bereitstellen, damit Außenstehende sie lesen können.

Hinweis: Ich habe diesen Code aktualisiert – er wird kompiliert und läuft erfolgreich ohne Warnungen über:

g++ static_init_test.cpp -std=c++11 -o static_init_test

Statische Konstruktoren gibt es in C# und Java.
Sie werden verwendet, um statische Mitglieder einer Klasse zu initialisieren.
Die Laufzeit führt sie aus, bevor die Klasse zum ersten Mal verwendet wird.

In C++ gibt es so etwas nicht. Konstruktoren und Destruktoren, die normalerweise zum Erstellen oder Zerstören von Objektinstanzen verwendet werden. Es ist sinnlos, sie ohne entsprechende Objektinstanz aufzurufen. Sie können sie mit a emulieren Einzelling Muster.

Ein statischer Konstruktor wird verwendet, um statische Daten einer Klasse zu initialisieren. C++ hat keinen statischen Konstruktor. Ein statischer Konstruktor kann jedoch emuliert werden, indem eine Friend-Klasse oder eine verschachtelte Klasse wie unten verwendet wird.

class ClassStatic{
private:
    static char *str;
public:
    char* get_str() { return str; }
    void set_str(char *s) { str = s; }
    // A nested class, which used as static constructor
    static class ClassInit{
    public:
        ClassInit(int size){ 
            // Static constructor definition
            str = new char[size];
            str = "How are you?";
        }
    } initializer;
};

// Static variable creation
char* ClassStatic::str; 
// Static constructor call
ClassStatic::ClassInit ClassStatic::initializer(20);

int main() {
    ClassStatic a;
    ClassStatic b;
    std::cout << "String in a: " << a.get_str() << std::endl;
    std::cout << "String in b: " << b.get_str() << std::endl;
    a.set_str("I am fine");
    std::cout << "String in a: " << a.get_str() << std::endl;
    std::cout << "String in b: " << b.get_str() << std::endl;
    std::cin.ignore();
}

Ausgabe:

String in a: How are you?
String in b: How are you?
String in a: I am fine
String in b: I am fine

Vielleicht meinen sie das:

class Cat
{
private:
Cat();
public:
static Cat getCat() {return Cat(); }
}