Wie nennt man einen Konstruktor für Globale Objekte für arrays von Objekten, und Objekte innere Klassen/structs?

Globale Objekte

Deiner ist der einzige Weg. Auf der anderen Seite, versuchen, dies zu vermeiden. Es ist besser, um Funktionen (oder auch andere Objekte) als Fabriken statt. Auf diese Weise können Sie Steuern die Zeit der Schöpfung.

Arrays von Objekten

Gibt es keine Möglichkeit das direkt tun. Nicht-POD-Objekte werden immer default-konstruiert. std::fill ist oft eine große Hilfe. Sie möchten vielleicht auch einen Blick in allocators und std::uninitialized_fill.

Objekte in Klassen/structs

Verwenden, die Initialisierung der Listen in den Konstruktor:

class Bar {
    Foo foo;

    Bar() : foo(3) { }
};

Statischen Elemente müssen tatsächlich außerhalb der Klasse definiert:

class Bar {
    static Foo foo;
};

Foo Bar::foo(3);

Konrad-Antwort ist OK, nur ein puntualization über die arrays....
Es ist ein Weg, um ein array von Elementen(keine Zeiger) und hier folgt es:

//allocate raw memory for our array
void *rawMemory = operator new[](30 * sizeof(Foo))

//point array_of_foos to this memory so we can use it as an array of Foo
Foo *array_of_foos = static_cast<Foo *>(rawMemory);

//and now we can create the array of objects(NOT pointers to the objects)
// using the buffered new operator
for (int i = 0; i < 30; i++)
    new(array_of_foos[i])Foo(3);

Dieser Ansatz wird hier beschrieben: http://www.amazon.com/gp/product/0321334876?ie=UTF8&tag=aristeia.com-20&linkCode=as2&camp=1789&creative=9325&creativeASIN=0321334876

Scheint es die Allgemeine Kernaussage in diesem thread, dass Sie nicht initialisiert werden Mitglieder eines Arrays anderen als den default-Konstruktor. Eine Antwort, die auch erzeugt eine andere Art, nur zu nennen ein weiterer Konstruktor. Obwohl Sie können (, wenn das array nicht Teil, als ein Mitglied einer Klasse!):

struct foo {
    foo(int a): a(a) { }
    explicit foo(std::string s): s(s) { }
private:
    int a;
    std::string s;
};

/* global */
foo f[] = { foo("global"), foo("array") };

int main() {
    /* local */
    foo f[] = { 10, 20, 30, foo("a"), foo("b") };
}

Art, jedoch kopiert werden muss-in der Lage: Die Elemente gegeben sind, - Kopie-initialisiert, in die die Mitglieder des Arrays.

Für arrays als Mitglieder in den Klassen, es ist das beste, um Behälter verwenden, derzeit:

struct bar {
    /* create a vector of 100 foo's, initialized with "initial" */
    bar(): f(100, foo("initial")) { }
private:
    std::vector<foo> f;
};

Mithilfe der placement-new beschriebenen Verfahren von andy.gurin ist eine option, zu. Aber beachten Sie, es wird die Dinge zu komplizieren. Sie haben zu nennen, Destruktoren selbst. Und wenn jeder Konstruktor wirft, während Sie immer noch den Aufbau des array, dann brauchen Sie, um herauszubekommen, wo Sie aufgehört haben... Insgesamt, wenn Sie wollen, um arrays in Ihrer Klasse, und initialisieren möchten, verwenden Sie eines std::vector ist eine einfache Wette.

C++0X-Initialisierer-Listen lösen dieses problem für die arrays von Objekten Fall. Sehen diese Herb Sutter blog-Eintrag, wo er beschreibt Sie im detail.

In der Zwischenzeit können Sie möglicherweise das problem umgehen, etwa so:

class Foo {
public:
    Foo(int a) : b(a) {}

private:
    int b;
};

class Foo_3 : public Foo {
public:
    Foo_3() : Foo(3) {}
};

Foo_3 array_of_foos[30];

Hier, die Foo_3 - Klasse ist ausschließlich für den Zweck der Berufung der Foo Konstruktor mit dem richtigen argument. Man konnte es eine Vorlage auch:

template <int i>    
class Foo_n : public Foo {
public:
    Foo_n() : Foo(i) {}
};

Foo_n<3> array_of_foos[30];

Wieder diese möglicherweise nicht genau das tun, was Sie wollen, aber einige Denkanstöße.

(Beachten Sie auch, dass in Ihrem Foo Klasse, die Sie sollten wirklich in die Gewohnheit, mit Element-Initialisierer-Listen anstelle von Zuweisungen im Konstruktor, als je mein Beispiel oben)