Discussion :

[manticore]

Bonjour,

j'aimerai savoir quelle est la meilleur pratique pour l'utilisation d'un std::vector.

Sachant que celui-ci fait une copie lors d'un push_back, vaut-il mieux insérer des pointeurs (intelligent ou non) ou insérer l'objet lui-même.

Quel est la meilleurs version :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
#include <vector>
#include <stdio.h>
#include <iostream>
 
int main()
{
	std::vector<std::string*> vec_test;
 
	std::string* s1 = new std::string("Blabla");
 
	vec_test.push_back(s1);
 
	for (std::vector<std::string*>::iterator it = vec_test.begin(); it!=vec_test.end(); ++it)
	{
		delete *it;
	}
 
	return 1;
}

ou la version "simple" :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <vector>
#include <stdio.h>
#include <iostream>
 
int main()
{
	std::vector<std::string> vec_test;
 
	std::string s1 = "Blabla";
 
	vec_test.push_back(s1);
 
	return 1;
}

Je trouve la première plus efficace (pas de copie des données), mais il y a la gestion des pointeurs.

[cob59]

Si ton compilateur gère le C++11 (c'est très probable) il suffit d'utiliser la sémantique de mouvement, de cette manière :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
std::vector<std::string> vec_test;
 
// #1
std::string s1 = "Blabla";
vec_test.emplace_back(std::move(s1)); // [edit] correction suite à la remarque de gbdivers
//ou vec_test.emplace_back("Blabla")
assert ( s1.empty() );
 
// #2
vec_test.push_back("Blabla")
//ou vec_test.push_back(std::string("Blabla"))
 
// #3
std::string s2 = "Blabla";
vec_test.push_back(std::move(s2));
assert ( s2.empty() );

Ces trois méthodes déplacent la chaine à la fin du vecteur d'une manière optimale, sans avoir à s’embarrasser de new/delete.

[gbdivers]

Petite correction :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
// #1
std::string s1 = "Blabla";
vec_test.emplace_back(s1);
assert ( s1.empty() );

emplace_back permet de créer un élément directement dans le conteneur sans faire de copie. Il prend en paramètre les arguments que l'on aurait utilisé pour créer la chaine. Il ne s'agit pas de move sémantique (cela utilise les variadic template) et dans ton code #1, tu as bien une copie. Pour éviter la copie, il faut écrire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
// #1
vec_test.emplace_back("Blabla");

La confusion vient peut être du fait que le prototype de emplace_back est template< class... Args > void emplace_back( Args&&... args ); ce qui fait penser à la move semantic, mais il s'agit de perfect forwarding ici

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
// #2
vec_test.push_back("Blabla")
//ou vec_test.push_back(std::string("Blabla"))
 
// #3
std::string s2 = "Blabla";
vec_test.push_back(std::move(s2));
assert ( s2.empty() );

Là ok, c'est bien de la move semantic (appelle de la version push_back(T&&) au lieu de push_back(const&)). La move semantic est obtenu en utilisant un temporaire (dans #2) ou en forçant le déplacement avec std::move (dans #3)


@Manticore
Réponse qui marche toujours : cela dépend

Si tu t'intéresse qu'à la sémantique, la première version si tu as des objets à sémantique d'entité, la seconde si tu as une sémantique de valeur.

Si tu t'intéresse aux perfs... fais du profiling
Le risque de la seconde version du code, en termes de perfs, n'est pas la copie lors de la création d'un nouvel élément. C'est surtout que tu risques d'avoir, lors d'un pusk_back, un redimensionnement du vector, donc réallocation + copie de la totalité du vector. La première version du code permet d'éviter la copie des chaînes, au prix d'une modification de la sémantique.
Mais cela est à vérifier en pratique : si tu as un tableau qui contient 10 chaines de 10 caractères et que tu fais un push 1 fois par mois, même si en théorie la version avec pointeur est plus performante, le gain réel sera nul.

Donc dans l'ordre :
* C++11 si tu peux
* profiling pour vérifier l'utilisation réelle
* modifier la politique de dimensionnement de tes vectors
* utiliser des pointeurs "masqués" pour garder la même sémantique en bénéficiant des pointeurs (string avec COW, boost.ptr_vector, vector<unique_ptr>)
* faire du code moche

[manticore]

Merci beaucoup de ces informations très clair

J'ai tous les éléments pour faire un choix.