handle_wrapper handles[3]; // Ruft 5 mal handle_wrapper::handle_wrapper() auf
for(handle_wrapper handle : handles) cout << handle << endl;

/*
Output:
56
60
64
*/

Allerdings ist vector da ja etwas anders: es kopiert immer das erste Element für die übrigen:

vector<handle_wrapper> handles(3/*, handle_wrapper()*/);
for(handle_wrapper handle : handles) cout << handle << endl;

/*
Output:
56
56
56
*/

Kann man da vector irgendwie anpassen? Die Handles dann noch mal extra auf dem Heap zu alloziieren und Zeiger im vector zu speichern fände ich doof.
Gibt's da eine Möglichkeit?

T a = T();
T a;

Ich denke, hier liegt das Problem. Normalerweise gilt auch

T a;
T b;
assert(a == b);

Also solltest du nicht den Defaultkonstruktor für spezielle Werte verwenden, sondern eher eine Factory-Funktion, mit der du die Objekte initialisierst.

typedef shared_ptr<handle_wrapper> hptr_t;

class handle_wrapper {
public:
	/* some */
	friend hptr_t create_socket();

private:
	handle_wrapper() {
		/* some */
	}
	// ...
};

hptr_t create_socket() {
	return hptr_t(new socket_handle);
}

// ...

vector<sockptr_t> handles(5);
for(sockptr_t& handle : handles) {
	sh = create_socket();
	cout << sh->get() << endl;
}

Ich hätte eher an sowas gedacht:

handle_wrapper create_socket();

int main()
{
   std::vector<handle_wrapper> vector;
   std::generate_n(std::back_inserter(vector), 5, &create_socket);
}

Das macht leider eine Copy-Operation?! Jedenfalls sind im vector dann die selben Handle-Werte.

Sofern du create_socket() so implementierst, dass es nicht jedes Mal dasselbe Objekt zurückgibt, sind die neuen Elemente im std::vector auch unterschiedlich.

Die STL-Algorithmen std::generate() und std::generate_n() rufen die Generatorfunktion für jedes Element auf – etwa im Gegensatz zu std::fill() und std::fill_n() .

> Sofern du create_socket() so implementierst, dass es nicht jedes Mal dasselbe Objekt zurückgibt, sind die neuen Elemente im std::vector auch unterschiedlich.

Das will ich auch meinen. Die Implementierung der Funktion ist trivial:

inline socket_handle create_socket() {
	return socket_handle();
}

Dabei kann es ja unmöglich immer das selbe Objekt sein?!

Dabei kann es ja unmöglich immer das selbe Objekt sein?!

Wenn du meinen Rat befolgt hast und der Defaultkonstruktor immer die gleiche Initialisierung durchführt, doch. Ansonsten passe deine Wertsemantik an, dass

socket_handle a;
socket_handle b;
assert(a == b);

gilt (falls operator== nicht existiert, denk dir eine sinnvolle Implementierung für dieses Gedankenexperiment aus).

Objekt-spezifische Initialisierungen sollten wie schon gesagt nicht im Defaultkonstruktor geschehen. Entsprechend müsste create_socket() auch mehr tun als nur Default- und Kopierkonstruktor aufzurufen.

inline socket_handle create_socket() {
	socket_handle sh;
	sh.init_();
	return sh;
}

schreibe, bleiben die Handles gleich?!

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

int create_int()
{
	static int i;
	return ++i;
}

void output(int i)
{
	std::cout << i << " ";
}

int main()
{
   std::vector<int> vector;
   std::generate_n(std::back_inserter(vector), 5, &create_int);
   std::for_each(vector.begin(), vector.end(), &output);
}

Kannst du etwas mehr Code posten? Wie sehen Kopier- und Standardkonstruktor von socket_handle aus? Kannst du die Funktion create_socket() und die Stelle ihrer Verwendung (beim Füllen des Containers) zeigen?

Nicht mehr und nicht weniger.

// EDIT:

Au weia, jetzt fällt mir was ein. Da der Destruktor ja beim Beenden von create_socket aufgerufen wird, wird die Ressource freigegeben, sodass es beim nächsten Aufruf wieder die selbe Ressource ist, die ich dann bekomme. Scheinbar muss ich doch den Heap benutzen.

Au weia, jetzt fällt mir was ein. Da der Destruktor ja beim Beenden von create_socket aufgerufen wird, wird die Ressource freigegeben, sodass es beim nächsten Aufruf wieder die selbe Ressource ist, die ich dann bekomme. Scheinbar muss ich doch den Heap benutzen.

Ja, dann scheint das sinnvoll zu sein. Wäre ja auch blöd, wenn bei einer Vector-Reallokation plötzlich alle Ressourcen freigegeben würden. Daher immer schön schauen, dass man so oft wie möglich eine sinnvolle Wertsemantik hat, besonders bei Containern.

Ad aCTa schrieb:

So, ich glaube, in diesem Fall ist das gute alte Array immernoch die einfachste Lösung.

Wenigstens std::tr1::array läge also schon drin.