Vector befüllen bei Deklaration?

Huhu

Wie kann ich einem Vector bereits bei der Deklaration Elemente übergeben?
In folgendem Zusammenhang:

struct Namensliste
{
    string Titel;
    vector<string> Liste;
}

Vorstand = { "Vorstand", { "Antje", "Reiner", "Jochen" } /*???*/ };
Mitglieder = { "Mitglieder", { "Theo", "Michael", "Susan", "Lisa", "Balz" } /*???*/ };

Dem Vector wird anschliessend nichts mehr hinzugefügt, aber enthält jenachdem eine unterschiedliche Anzahl.

schau dich mal bei google nach boost::assign um, ist genau das, was du suchst.

Sehr interessant ist auch die Möglichkeit einem Container, wie der Vector aus der STL einer ist, Werte via Generator zuzuweisen. Die Werte werden durch ein Funktionsobjekt, welches der Funktion generate übergeben wurde, erzeugt.

#include <cstdlib>
#include <iostream>
#include <iterator>
#include <vector>
#include <algorithm>

using namespace std;

/*
 * Generator liefert die Werte der Funktion 2^n (2, 4, 8, 16, ...). Es
 * handelt sich um eine Struktur, dessen Instanzen (Funktionsobjecte)
 * der Funktion generate uebergeben werden
 */

struct gen_
{
  int n;

  gen_()
    : n(1) {}
  ~gen_() {}

  int operator()() {
    return n*=2;
  }
};

int main()
{
  /*
   * Leerer Container mit einer maximalen Kapazitaet von 5 Elementen
   * anlegen und ihn auf 5 Elemente vergroessern. Anschliessend werden
   * die Werte mit dem oben definierten Generator generiert. Hierzu
   * wird auf die Funktion generate der STL zugegriffen
   */
  vector<int> v;
  v.reserve(5);
  v.resize(5);
  generate(v.begin(), v.end(), gen_());

  /*
   * Werte via Streamiterator auf die Standardausgabe cout ausgeben
   */
  ostream_iterator<int> oi(cout, " ");
  copy(v.begin(), v.end(), oi);

  return EXIT_SUCCESS;
}

/edit: Habe gerade noch einmal auf die Frage geschaut; die Rede ist wie ausdrücklich gesagt worden ist von der initalisierung zum Zeitpunkt der Deklaration. Muss wohl an der Uhrzeit liegen ...

Dennoch finde ich das oben genannte Vorgehen sehr sinnvoll.

Ein guter Ansatz wäre auch die Metaprogrammierung, damit lässt sich soetwas mit sicherheit auch realisieren.

Helmut S.

rEinerlei schrieb:

Huhu

Wie kann ich einem Vector bereits bei der Deklaration Elemente übergeben?
In folgendem Zusammenhang:
struct Namensliste
{
    string Titel;
    vector<string> Liste;
}

Vorstand = { "Vorstand", { "Antje", "Reiner", "Jochen" } /*???*/ };
Mitglieder = { "Mitglieder", { "Theo", "Michael", "Susan", "Lisa", "Balz" } /*???*/ };
Dem Vector wird anschliessend nichts mehr hinzugefügt, aber enthält jenachdem eine unterschiedliche Anzahl.

Deinem Vector wird anschliessend nichts mehr hinzugefügt und du willst
bereits bei der Deklaration (die dann auch eine Definition ist) die
Elemente übergeben. Wenn Du auf Vector verzichtest und dafür ein String-Array
einsetzt kannst du komfortabel nach Deinen obigen Vorstellungen arbeiten.
Die String-Klasse der STL reicht Dir als Werkzeug.

#include <iostream>
#include <string>
using namespace std;
int main()
{
   string VorstandListe[] = {"Vorstand", "Antje", "Reiner", "Jochen"}; 
   string MitgliederListe[] = {"Mitglieder", "Theo", "Michael", "Susan", "Lisa", "Balz"};  

   for (int i = 0; i < 4; i++)
      cout << VorstandListe[i] << "  ";
   cout << endl;
   for (int i = 0; i < 6; i++)
      cout << MitgliederListe[i] << "  ";
   cout << endl << endl;
}

Danke mal erst.

Habs nun mit boost::assign gemacht. Funzt wundeba.
@Helmut
Das dachte ich auch erst, ich will aber die Struktur so übergeben, wie oben beschrieben.
@lucky_tux
Hab das irgendwie nicht verstanden, was Du da generierst
Aber was hat es mit Metaprogrammieren auf sich? Was ist das?

Metaprogrammierung ist rein funktionaler Natur. Ein Metaprogramm ist ein Programm auf einer höheren Ebene als der C++-Quelltext. Anders gesagt ein Metaprogramm ist ein Programm das ein Programm beim Übersetzen modifiziert. Es gibt zum Beispiel die C++-Template-Metaprogrammierung und die Metaprogrammierung durch den Präprozessor.

.filmor

lucky_tux schrieb:

Metaprogrammierung ist rein funktionaler Natur.

Nicht zwingend, oder?! C++(-Template!)-Metaprogrammierung ist deshalb rein funktional, weil man nur typedefs und statische Konstanten benutzen kann, welche beide "final" sind und alle "Funktionen" (vor allem deshalb) bei gleicher Eingabe immer das gleiche zurückliefern müssen. Es gibt auch Präprozessor-Metaprogrammierung, für die muss das nicht gelten, genausowenig für Metaprogrammierungsansätze in anderen Sprachen.

Du hast Recht. Habe nicht genau auf die Formulierung geachtet. Die Metaprogrammierung via Templates in C++ ist rein funktional.