3. vector initialisieren

vector initialisieren

  • B

    Bsp:

    std::vector<double> mvSource;

.
.
.
.
.
struct data{
   //Var
   double A;
   //Konstruktor
   data(double a) : A(a){}
};

std::vector<data> mvDest(mvSource.size(), /* HIER der double wert von jeweiligen mvSource element */);

    Es so nun der übergabe wert des Konstruktors von data entsprechend des inhalts des mvSource element am in Index x übergeben werden!

    sowas geht wohl nich????

    0
  • C

    Du willst mvDest als "Kopie von mvSource erstellen, richtig? Dafür gibt es den Bereichs-Konstruktor:

    vector<data> mvDest(mvSoruce.begin(),mvSource.end());
    0
  • B

    ne nich ganz

    nehmen wir an mcSoure hat 4 Elemente mit den double werten 5.0, 3.4, 1.3, 6

    wenn ich nun mvDest initialisieren will, soll

    für das erste elemente (data) der wert 5.0 im konstruktor übergeben werden,
    für das zweite elemente (data) der wert 3.4 , usw.

    0
  • C

    Sag ich doch - als "Kopie" (jedes Element von Dest wird aus dem entsprechenden Source-Element erzeugt). Bevor du "klappt nicht" schreist, solltest du den obigen Code wenigstens ausprobieren.

    0
  • B

    hmm ist wohl ein schlechtes beispiel

    sagen wir mal, der mvSource hätte statt double die struktur

    struct elem{

 double d;
 int i;

};

std::vector<elem> mvSource;

    dann will ich von jedmem elemente des mv Source den double wert als übergabe parameter der mvDest

    0
  • _

    Vielleicht so?

    struct elem{

 double d;
 int i;

 operator double ()
 {
  return d;
 }

};
    0
  • C

    Wenn du data ändern kannst, könntest du ihm einen Ctor geben, der elem-Objekte entgegennehmen kann. Im Ernstfall bleibt dir immer noch die Möglichkeit, den vector über transform() zu füllen.

    0
  • B

    transform? kannst mal genauer erläutern?

    0
  • C

    transform() kann Bereiche "umrechnen". D.h. wenn du weder elem noch data ändern kannst, könntest du damit deinen vector umkopieren:

    struct elem
{
  double d;
  int i;
};
class data
{
  //Var
  double A;
public:
  //Konstruktor
  data(double a) : A(a){}
};

data from_elem(elem val)
{ return data(val.d); }

vector<elem> src;
...//fill src
vector<data> tgt;
transform(src.begin(),src.end(),back_inserter(tgt),from_elem);

    (benötigt <algorithm> (transform) und <iterator> (back_inserter))

    0
  • B

    Die Kristallkugel spricht...

    1. Du hast einen std::vector<double> mit irgendwelchen Werten initialisiert.
    2. Du hast eine Klasse, nennen wir sie Foo, deren Konstruktor ein Element vom Typ double verlangt.

    class Foo
{
    // ...
public:
    // ...
    Foo(double x);
    // ...
};

    Nun willst du einen neuen std::vector<Foo> anlegen und Foo::Foo(double) mit den Werten aus std::vector<double> aufrufen:

    std::vector<double> src;
// ...
std::vector<Foo> dst;
std::vector<double>::const_iterator iter = src.begin();
for(; iter != src.end(); iter++) {
    dst.push_back(Foo(*iter, 1234));
}

    Zumindest entspricht das dessen was ich mir gerade unter der Problemstellung vorstellen kann - und vermutlich gibt es ein Funktion/Methode von std::vector, welche genau das zu leisten vermag 😉

    Grüße...

    Heiko

    0
  • B

    @CStoll: Elengant;) thx

    @Rest: danke:)

    0
Anmelden zum Antworten