Variable Anzahl an Objekten

[Dadam]

Hoi zusammen,

class_name{
public:
class_name(int a);

//...

class_name obj[2] = {  obj(c), obj(d) };

so würde man eine bestimmte Anzahl an Objekten initialisieren.
Nun brauche ich aber eine variable Anzahl an Objekten X die zugehörigen Werte für den Konstruktur würden in einem Array liegen zb. int werte[x].
Wie kriege ich es nun hin diesee Objekte zu erzeugen?

Danke Gruß

[wektor]

std::vector<class_name> objs(x);

?

[Dadam]

wektor schrieb:

std::vector<class_name> objs(x);

?

Ich hab bisher std::vector noch nicht verwendet.
Ah würde das so funktionieren:

std::vector<class_name> obj(10, class_name(wert[x]));

[Dadam]

^ ne BS würde es natürlich nicht wir sind ja nicht in einer Schleife.

std::vector<class_name> obj(10, class_name(wert[x]));

Wie kriege ich es hin die zehn Objekte mit unterchiedlichen Werten zu initialisieren die sich im Array Wert[10] befinden?

[patrick246]

Mit dem Range-Konstruktor von std::vector: http://www.cplusplus.com/reference/vector/vector/vector/

std::vector<class_name> obj(std::begin(Wert), std::end(Wert));

[Dadam]

patrick246 schrieb:

Mit dem Range-Konstruktor von std::vector: http://www.cplusplus.com/reference/vector/vector/vector/

std::vector<class_name> obj(std::begin(Wert), std::end(Wert));

Danke funktioniert

[Dadam]

patrick246 schrieb:

Mit dem Range-Konstruktor von std::vector: http://www.cplusplus.com/reference/vector/vector/vector/

std::vector<class_name> obj(std::begin(Wert), std::end(Wert));

Und wie mache ich das mit mehr als einem Argument?

[Dadam]

Ich hab mich schon durch das halbe Internet gesucht! Ich finde es einfach nicht wie es mit zwei Argumenten funktioniert

Gruß

[TNA]

Dadam schrieb:

Ich hab mich schon durch das halbe Internet gesucht! Ich finde es einfach nicht wie es mit zwei Argumenten funktioniert

Kommt etwas drauf an was du machen möchtest. Wenn die Werte in mehreren Arrays liegen wirst du wohl um eine Schleife (alternativ einen Algorithmus) nicht drum herum kommen. Eventuell könnte ein Array mit Tupeln funktioniert, aber da bin ich mir nicht ganz sicher, das müssen die Experten hier beantworten.

[camper]

TNA schrieb:

Dadam schrieb:

Ich hab mich schon durch das halbe Internet gesucht! Ich finde es einfach nicht wie es mit zwei Argumenten funktioniert

Kommt etwas drauf an was du machen möchtest. Wenn die Werte in mehreren Arrays liegen wirst du wohl um eine Schleife (alternativ einen Algorithmus) nicht drum herum kommen. Eventuell könnte ein Array mit Tupeln funktioniert, aber da bin ich mir nicht ganz sicher, das müssen die Experten hier beantworten.

Das könnte funktionieren, wenn man noch einen Konvertierungsoperator anbietet. Im allgemeineren Fall müsste man wohl einen geeigneten Iteratoradapter schreiben.

[Dadam]

Alles klar! Dann machen wir es anders ich will EIN Argument vom Typ string[] übergeben der string array soll zwei slots haben aber selber in einem vector sitzen.

Also sowas wie std::vectorstd::string[] das funktioniert aber nicht?
Wie kriegt man das richtig hin?

Gruß

[TNA]

camper schrieb:

Das könnte funktionieren, wenn man noch einen Konvertierungsoperator anbietet. Im allgemeineren Fall müsste man wohl einen geeigneten Iteratoradapter schreiben.

Gibt es nicht in C++14 etwas, mit dem man eine Funktion mit den Parametern aus einem Tupel aufrufen kann? Ich meine mich da dunkel zu erinnern. Das kriegt man so natürlich trotzdem noch nicht ohne weiteres in den Range-Kontruktor rein.

Warum gibt es keine emplacement iteratoren oder Iterator-Adapter mit konvertierungen (Quasie Transform-Iteratoren in die man eine Konvertierungsfunktion einhängen kann, analog zu std::transform)? Da hätte ich oft verwendung für.

[TNA]

Dadam schrieb:

Alles klar! Dann machen wir es anders ich will EIN Argument vom Typ string[] übergeben der string array soll zwei slots haben aber selber in einem vector sitzen.

Also sowas wie std::vectorstd::string[] das funktioniert aber nicht?
Wie kriegt man das richtig hin?

Wenn es immer genau zwei sein sollen, würde ich ein std::pairstd::string als argument nehmen und dann einen vector<std::pairstd::string> für die werte anlegen.

Alternativ std::arraystd::string,2 das ist statisch erweiterbar und vielleicht angenehmer von Zugriff.

[Dadam]

[quote="TNA"]

Dadam schrieb:

Alternativ std::arraystd::string,2 das ist statisch erweiterbar und vielleicht angenehmer von Zugriff.

Das hört sich gut an!

Nur wie fühle ich eigentlich eine solche Syntax mit Werten?

std::vector<std::array<std::string,2>> socket;
socket.push_back({ { "127.0.0.1", "4563" },{"127.0.0.2","892"} });

Das funktioniert schonmal nicht..

Danke Gruß

[singularvaldecomposition]

Dadam schrieb:

std::vector<std::array<std::string,2>> socket;
socket.push_back({ { "127.0.0.1", "4563" },{"127.0.0.2","892"} });

Das funktioniert schonmal nicht..

push_back kann nur ein Element auf einmal pushen.

std::vector<std::array<std::string,2>> socket;
socket.push_back({ "127.0.0.1", "4563" });
socket.push_back({ "127.0.0.2", "892" });

[Daram]

^ Danke bin grad auch drauf gekommen. Zu meiner Verteidigung es ist schon spat

[singularvaldecomposition]

Alternativ kannst du das gleich im Konstruktor einfügen:

std::vector<std::array<std::string,2>> socket{
    { "127.0.0.1", "4563" },
    { "127.0.0.2",  "892" },
};

[camper]

TNA schrieb:

Gibt es nicht in C++14 etwas, mit dem man eine Funktion mit den Parametern aus einem Tupel aufrufen kann? Ich meine mich da dunkel zu erinnern. Das kriegt man so natürlich trotzdem noch nicht ohne weiteres in den Range-Kontruktor rein.

Geht auch mit C++11, C++14 erspart ein bisschen boilerplate

template <typename F, typename T, std::size_t... i>
auto invoke(F&& func, T&& tuple, std::integer_sequence<std::size_t, i...>)
{
    return std::forward<F>(func)(get<i>(std::forward<T>(tuple))...);
}
template <typename F, typename T>
auto invoke(F&& func, T&& tuple)
{
    return invoke(std::forward<F>(func), std::forward<T>(tuple), std::make_integer_sequence<std::size_t, std::tuple_size<typename std::remove_reference<T>::type>::value>);
}

[Columbo]

Vereinfacht:

template <typename F, typename T, std::size_t... i> 
auto invoke(F&& func, T&& tuple, std::index_sequence<i...>) 
{ 
    return std::forward<F>(func)(get<i>(std::forward<T>(tuple))...); 
} 
template <typename F, typename T> 
auto invoke(F&& func, T&& tuple) 
{ 
    return invoke(std::forward<F>(func), std::forward<T>(tuple), std::make_index_sequence<std::tuple_size<std::remove_reference_t<T>>{}>{}); 
}