Wie initialisiert man private statische Mitglieder in C++?

Question

Wie lässt sich ein privates, statisches Datenelement in C++ am besten initialisieren? Ich habe dies in meiner Header-Datei versucht, aber es gibt mir seltsame Linker-Fehler:

class foo
{
    private:
        static int i;
};

int foo::i = 0;

Ich vermute, dies ist, weil ich ein privates Mitglied von außerhalb der Klasse nicht initialisieren kann. Was ist also der beste Weg, dies zu tun?

Answer 1

Sie können die Zuweisung auch in die Header-Datei aufnehmen, wenn Sie Header-Guards verwenden. Ich habe diese Technik für eine C++-Bibliothek verwendet, die ich erstellt habe. Eine andere Möglichkeit, das gleiche Ergebnis zu erzielen, ist die Verwendung statischer Methoden. Zum Beispiel...

class Foo
   {
   public:
     int GetMyStatic() const
     {
       return *MyStatic();
     }

   private:
     static int* MyStatic()
     {
       static int mStatic = 0;
       return &mStatic;
     }
   }

Der obige Code hat den "Bonus", dass er keine CPP/Source-Datei erfordert. Auch dies ist eine Methode, die ich für meine C++-Bibliotheken verwende.

Answer 2

Ich folge der Idee von Karl. Sie gefällt mir und ich benutze sie jetzt auch. Ich habe die Notation ein wenig geändert und einige Funktionen hinzugefügt

#include <stdio.h>

class Foo
{
   public:

     int   GetMyStaticValue () const {  return MyStatic();  }
     int & GetMyStaticVar ()         {  return MyStatic();  }
     static bool isMyStatic (int & num) {  return & num == & MyStatic(); }

   private:

      static int & MyStatic ()
      {
         static int mStatic = 7;
         return mStatic;
      }
};

int main (int, char **)
{
   Foo obj;

   printf ("mystatic value %d\n", obj.GetMyStaticValue());
   obj.GetMyStaticVar () = 3;
   printf ("mystatic value %d\n", obj.GetMyStaticValue());

   int valMyS = obj.GetMyStaticVar ();
   int & iPtr1 = obj.GetMyStaticVar ();
   int & iPtr2 = valMyS;

   printf ("is my static %d %d\n", Foo::isMyStatic(iPtr1), Foo::isMyStatic(iPtr2));
}

diese Ausgänge

mystatic value 7
mystatic value 3
is my static 1 0

Answer 3

Wie wäre es mit einem set_default() Methode?

class foo
{
    public:
        static void set_default(int);
    private:
        static int i;
};

void foo::set_default(int x) {
    i = x;
}

Wir müssten nur die set_default(int x) Methode und unsere static Variable initialisiert werden würde.

Dies steht nicht im Widerspruch zum Rest der Kommentare, denn es folgt dem gleichen Prinzip der Initialisierung der Variablen in einem globalen Bereich, aber durch diese Methode machen wir es explizit (und leicht zu sehen-verstehen), anstatt die Definition der Variablen dort hängen zu lassen.

Answer 4

Funktioniert auch in der Datei privateStatic.cpp:

#include <iostream>

using namespace std;

class A
{
private:
  static int v;
};

int A::v = 10; // possible initializing

int main()
{
A a;
//cout << A::v << endl; // no access because of private scope
return 0;
}

// g++ privateStatic.cpp -o privateStatic && ./privateStatic

Answer 5

Eine "altmodische" Art, Konstanten zu definieren, besteht darin, sie durch eine enum :

class foo
{
    private:
        enum {i = 0}; // default type = int
        enum: int64_t {HUGE = 1000000000000}; // may specify another type
};

Auf diese Weise muss keine Definition angegeben werden, und es wird vermieden, die Konstante l-Wert Dies kann Ihnen einige Kopfschmerzen ersparen, z. B. wenn Sie versehentlich ODR-Nutzung es.