Discussion :

[cob59]

Bonjour,
je suis sur un projet C++ dans lequel je suis - pour résumer - contraint d'utiliser des données à partir d'un tableau C classique (1024 éléments de type double).
J'aimerais "encapsuler" ce tableau avec un std::vector pour rendre son utilisation plus commode, c'est à dire créer un vector<double> de taille 1024 qui manipulerait cette plage de données sans avoir à la recopier ailleurs en mémoire.

Comment dois-je procéder ?
Merci.

[3DArchi]

Bonjour,
A mon sens, il n'existe rien de standard avec std::vector pour faire ça. Normalement, le std::vector a la responsabilité de gérer la façon dont il maintient les données.
Ensuite, avec une implémentation particulière, il y aurait certainement moyen de bidouiller avec un allocateur maison qui retournerait ta zone mémoire. Mais je pense que ce sera une origine de bugs inutile.
Donc, le meilleur conseil est encore la recopie ou l'encapsulation de ton tableau dans ta structure idoine. Que te manque-t-il pour ne pas utiliser directement ton tableau ? Tu peux appliquer les algos sur un tableau. Ca ne pose pas de problème...

[koala01]

Salut,

Déjà, je me demande pourquoi manipuler un tableau C style au lieu d'un std::vector...

Après tout, si tu sais pertinemment le nombre d'éléments que ton tableau va devoir contenir, tu pourrais tout à fait travailler, au choix:

• Avec un std::vector et sa fonction reserve
• Avec un boost::array qui est un tableau de taille fixe "stl Like"

Comme il s'agit de tableaux contigus en mémoire, si tu as, à un moment donné, réellement besoin d'un pointeur sur le premier élément (par exemple pour le passer en paramètre à une fonction écrite en C), tu peux toujours prendre... l'adresse de l'élément se trouvant en indice 0

Par exemple:

Code :

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

1
2
3
std::vector<double> tab;
tab.reserve(1024);
double* = &tab[0]; // je t'assure, ca marche :D

Tant que tu ne tentera pas d'accéder à d'autres éléments qu'aux 1024 réservés, tu n'aura strictement aucun problème

[3DArchi]

Tant que tu ne tentera pas d'accéder à d'autres éléments qu'aux 1024 réservés, tu n'aura strictement aucun problème

En revanche, reserve ne fait pas augmenter le nombre d'élément du vecteur. Il faut pour cela utiliser resize.

[koala01]

oupppss... au temps pour moi

[cob59]

Pour être plus précis, j'utilise une bibliothèque semblable à boost::uBlas (nt2) pour des calculs matriciels. Celle-ci utilise ses propres conteneurs génériques pour effectuer ses calculs. Ces conteneurs garantissent entre autre que les données d'une matrice appartiendront toujours à une zone mémoire contigüe. Comme il m'est possible d'obtenir l'adresse du premier élément de ce conteneur, je peux donc (si je le souhaite) créer un tableau C pour accéder à n'importe quel élément de la matrice.

Il se trouve que j'ai besoin de convertir ce conteneur nt2 en un std::vector pour les raisons citées dans mon premier post. Donc mon problème me semble bien être " Comment créer un std::vector à partir d'un tableau C déjà alloué ? "...

[3DArchi]

Pour être plus précis, j'utilise une bibliothèque semblable à boost::uBlas (nt2) pour des calculs matriciels. Celle-ci utilise ses propres conteneurs génériques pour effectuer ses calculs. Ces conteneurs garantissent entre autre que les données d'une matrice appartiendront toujours à une zone mémoire contigüe. Comme il m'est possible d'obtenir l'adresse du premier élément de ce conteneur, je peux donc (si je le souhaite) créer un tableau C pour accéder à n'importe quel élément de la matrice.

Il se trouve que j'ai besoin de convertir ce conteneur nt2 en un std::vector pour les raisons citées dans mon premier post. Donc mon problème me semble bien être " Comment créer un std::vector à partir d'un tableau C déjà alloué ? "...

Que ferais-tu de plus avec un std::vector que tu ne fais pas avec ton pointeur ?

[Nogane]

Si c'est pour être sur que la mémoire soit désallouée, il est possible de placer ce double* dans un boost::scoped_array, ou boost::shared_array.

[camboui]

Je plussois tout ce qui a été dit.

Mais s'il faut ab-so-lu-ment encapsuler le contenu d'un pointeur dans un std::vector sans faire aucune recopie, alors il faut passer par l'écriture d'un allocator.

[cob59]

Que ferais-tu de plus avec un std::vector que tu ne fais pas avec ton pointeur ?

Tu me demandes l'intérêt d'un std::vector par rapport à un tableau C ?



Bon, je UP ce topic parce qu'en cherchant des infos sur le constructeur de std::vector je suis tombé là-dessus : http://www.cplusplus.com/reference/stl/vector/vector/

En gros il semble qu'on puisse faire la chose suivante :

Code :

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

1
2
3
4
5
6
7
8
9
 
// Exemple de création d'un pointeur vers des données, mais dans mon
// cas il vient d'une fonction tierce
double* pMatrice = { 20.0, 1.3, 4.9, 2.2 };
size_t tailleMatrice = 4;
 
// Le std::vector est construit avec les deux pointeurs début/fin de la matrice
// L'objet n'efface pas (a priori) les données lors de sa destruction
std::vector<double> vMatrice(pMatrice, pMatrice + tailleMatrice);

Ce serait aussi simple que ça ?

[Arzar]

Ce serait aussi simple que ça ?

Non. Ce constructeur fait une copie du tableau contenu entre les deux pointeurs.

Ce n'est pas la peine de chercher des feintes, il n'existe aucun moyen de forcer un vecteur à utiliser ton propre buffer sans passer par une copie. Car fondamentalement un std::vector est autorisé à faire ce qu'il veut avec la mémoire qu'il possède (par exemple réallouer un nouveau bloc et dégager l'ancien), donc il n'y aurait aucune garantie que ton buffer s'en sorte vivant.

Il existe peut être une exception, comme l'a indiqué camboui, c'est d'implémenter son propre allocateur.
Et justement, une proposition est recemment passée sur la mailing list de boost, boost::monotonic, pour avoir des conteneurs auquel on pourrait passer son propre buffer (avec plein de restriction). Au vu du débat provoqué, ça a l'air extremement casse-gueule à faire, voire impossible