was wäre wohl die beste Möglichkeit ein konstantes Array von Objekten ohne Default-Konstruktor zu erstellen? C++0x mit

const std::vector<Klasse> v = ({2, 3, 5, 7, 11}); // http://stackoverflow.com/questions/3701903/initialisation-of-static-vector

steht nicht zur Verfügung. Boost für list_of() auch nicht. Wie gesagt, der Container ist mir egal, es könnte auch ein rohes Array sein.

Einen Vektor direkt mit solchem Inhalt zu initialisieren ist in C++03 meines Wissens nicht möglich.

template<typename T>
struct vector_of_helper {
  std::vector<T> v;
  vector_of_helper &operator()(T const &t) {
    v.push_back(t);
    return *this;
  }
  operator std::vector<T>() { return v; }
  vector_of_helper(T const &t) {
    v.push_back(t);
  }
};

template<typename T>
vector_of_helper<T> vector_of(T const &t) {
  return vector_of_helper<T>(t);
}

// ...
std::vector<int> const v = vector_of(1)(2)(3);

struct test
{
  test()
    : k({Klasse(5), Klasse(4)})
  {}
  const Klasse k[];
};

Sieht jemand einen besseren Ausweg als:

struct test
{
  test()
  {
    k.push_back(5);
    ..
  }
  std::vector<Klasse> k;
};

Perfekt wäre natürlich so was wie:

struct test
{
  const Klasse k[] = {Klasse(5), Klasse(4)};
};

Warum haben die Standardler das eigentlich verboten? Es ist doch eindeutig, was der Konstruktor hier machen muss.

Ich sehe gerade: vector_of könnte eine Lösung sein..

Wenn der Arrayinhalt konstant ist, gibt es dann einen bestimmten Grund, dass er nicht statisch sein kann? Das sieht man eigentlich eher selten.

Hm.. vielleicht bin ich da auch gerade von etwas Falschem ausgegangen. Ist das Thread-safe? Ich weiß, der heilige Standard sagt da nichts zu, aber wie sieht es in der Praxis aus?

void thread()
{
  my_class c;
  c.do_smth_cool();
}

int main()
{
  start_thread(thread);
  my_class c;
  c.do_smth_cool();
}

seldon schrieb:

Wenn der Arrayinhalt konstant ist, gibt es dann einen bestimmten Grund, dass er nicht statisch sein kann? Das sieht man eigentlich eher selten.

Hm.. vielleicht bin ich da auch gerade von etwas Falschem ausgegangen. Ist das Thread-safe? Ich weiß, der heilige Standard sagt da nichts zu, aber wie sieht es in der Praxis aus?

void thread()
{
  my_class c;
  c.do_smth_cool();
}

int main()
{
  start_thread(thread);
  my_class c;
  c.do_smth_cool();
}

Wenn my_class keine statischen Member hat, ist das typischerweise threadsafe. Sind ja zwei unterschiedliche Instanzen.
Natürlich kannst du Probleme bekommen wenn do_smth_cool() (direkt oder indirekt) auf andere gemeinsam genutzte Daten zugreift, z.B. globale Variablen oder statische Member anderer Klassen.

#include "VectorStream.hpp"

class MyClass
{
    int value;
    public:
    MyClass(int);
};

class Foo
{
    std::vector<MyClass> bar;
    public:
    Foo() : bar(VectorStream<MyClass>() << 2 << 5 << 8 << 11 << 14 << 17 << 20) {}
};