Question sur les vectors

Salut!:D

J'ai besoin de faire une fonction qui crée et initialise aléatoirement un vector d'entiers.
Je me demandais:
1)Faut il créer le vector d'une manière particulière pour qu'il reste valide à la sortie de la fonction?
En C il faut l'allouer dynamiquement pour l'utiliser à la sortie de la fonction, est-ce que pour les vectors on peut se contenter de:

Code:

---

std::vector<int> vecteur;

---

2)Faut il renvoyer un pointeur sur le vector créé:

Code:

---

1 2	std::vector<int>* p_vecteur=&vecteur; return p_vecteur;

---

ou peut on se contenter de:

Code:

---

return vecteur;

---

3)Dans ce cas le retour fera il une copie de "vecteur" dans la variable qui recevra le retour de la fonction ou le passage se fera il par référence comme les paramètres de fonction?

Merci de votre aide.:D

std::vector est un type copiable, donc comme n'importe quel type copiable (un int, un std::string, ...) il peut être renvoyé par valeur par une fonction, et c'est bien une copie qui sera faite.

Si tu veux éviter la copie, pour des raisons de performances, tu peux toujours passer ton vecteur par référence et simplement le remplir dans la fonction.

Merci de la réponse mais je préfère que la fonction fasse tout.
Donc il me faut renvoyer un pointeur pour éviter la copie?

Attention, si tu crées ton vecteur dans la fonction comme une variable locale, prendre un vecteur sur lui ne sert à rien car la variable est détruite à la sortie de la fonction.
comme Laurent le dit si bien, soit tu retournes par valeur, soit tu passes en argument par référence le vecteur à remplir.

OK, donc j'en revient à la première question:
comment le créer afin qu'il reste exploitable à la sortie de la fonction?
Comme ça:

Code:

---

1 2	vector<int>* p=new vector<int> (10); return p;

---

?

2 solutions - on ne fait pas trop de pointeur sur un vecteur ;) -

Code:

---

1 2 3 4 5 6

std::vector<int> maFonction() { std::vector<int> monVecteur; /// Mon code return monVecteur; }

---

Auquel cas le vecteur sera créé puis copié dans le nouveau vecteur dans la fonction appelante.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

void maFonction(std::<int>& monVecteur) { /// Mon code }   void fonctionAppelante() { std::vector<int> vecteur; maFonction(vecteur); /// Le reste du code }

---

Oui mais:
-je veux éviter la recopie à la sortie de la fonction;
-la fonction doit tout faire:créer et initialiser le vector.

Donc est-ce que la création avec "new" le rend exploitable à la sortie au travers du pointeur?

Qu'est-ce qui te gêne avec le passage par référence ?

Il n'y a absolument aucune différence :

Code:

---

1 2 3 4 5 6 7

// Retour de fonction std::vector<int> Ret; Ret = Fonction();   // Passage par référence std::vector<int> Ret; Fonction(Ret);

---

Créer un vector dynamiquement juste pour éviter une copie en retour de fonction, c'est à oublier.

Oui en effet, je me suis mal exprimé.
En fait voici mon prototype:

Code:

---

generateVector(int size,int min,int max)

---

(je n'ai pas mit encore le type de retour)
La fonction crée un vector de "size" entiers compris entre "min" et "max".
Et j'aimerais m'y tenir, c'est pour cela que le passage d'une référence sur un vector en paramètre me gêne.
Bref, ce qui me tente c'est de faire:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

vector<int>* generateVector(...){ vector<int>* p=new vector<int> (10); ... return p; }         int main() { vector<int>* p_vecteur=generateVector(10,1,5);

---

Est-ce valide?

Si vraiment tu veux utiliser le retour par valeur et éviter la copie, tu peux toujours utiliser la feinte de sioux suivante :

Code:

---

1 2	std::vector<int> Ret; Fonction().swap(Ret);

---

C'est valide, mais il faudra penser à détruire le vector ensuite.

Citation:

---

La fonction crée un vector de "size" entiers compris entre "min" et "max".
Et j'aimerais m'y tenir, c'est pour cela que le passage d'une référence sur un vector en paramètre me gêne.

---

Je ne comprends toujours pas ce qui te gêne... Que ta fonction dimensionne et remplisse un vecteur qu'elle a reçu en paramètre, ou qu'elle le fasse sur un vecteur qu'elle a créé, où est la différence ?

Citation:

---

Envoyé par Laurent Gomila

Si vraiment tu veux utiliser le retour par valeur et éviter la copie, tu peux toujours utiliser la feinte de sioux suivante :

Code:

---

1 2	std::vector<int> Ret; Fonction().swap(Ret);

---

---

Et là il n'y a pas de création d'un vector supplémentaire?
Je me demande si cela n'est pas équivalent à:

Code:

---

1 2 3 4

std::vector<int> Ret; std::vector<int> intermediaire; intermediaire=Fonction(); intermediaire.swap(Ret);

---

?:roll:
Je me demande si il n'y a pas création d'un objet intermédiaire, le retour de la fonction, au niveau de "Fonction()".

De plus, comment être sur que l'adresse du vector retournée est valide?
Car "swap" ne fait qu'échanger les addresses.

Citation:

---

Je me demande si il n'y a pas création d'un objet intermédiaire, le retour de la fonction, au niveau de "Fonction()".

---

C'est ce que je me suis demandé aussi, mais a priori non.

Citation:

---

De plus, comment être sur que l'adresse du vector retournée est valide?
Car "swap" ne fait qu'échanger les addresses.

---

Il ne faut pas tout confondre. Le vecteur retourné sera forcément valide, je ne vois pas comment il pourrait ne pas l'être (à partir du moment où tu ne fais pas n'importe quoi dans ta fonction).
Swap ne fait qu'échanger des adresses, mais ça tu n'es pas obligé de le savoir. Tout ce qu'il faut savoir c'est qu'il échange le contenu de deux vecteurs, et qu'il n'y a donc pas de recopie.

Mais pourquoi diable ne pas vouloir ce passage par référence :calim2:

Donc je crois que l'astuce est pas mal mais j'ai peur qu'elle ne soit pas aussi efficace qu'un retour de pointeur.

Sinon si je m'entête pour ne pas mettre de vector en paramètre c'est pour la propreté du code.
J'aime avoir des fonctions avec le moins de paramètres possible à efficacité égale.

Mais pour qu'elle fonctionne faut il que le vector soit déclaré avec "new" obligatoirement?

Je pense que oui car un vector déclaré de manière "classique" sera détruit à la sortie de la fonction, et du coup même si je récupère son addresse elle sera invalide cette fois.

Quand je fait:

Code:

---

vector<int>* generateVector(int size,int min,int max)

---

il m'indique:

Code:

---

expected constructor, destructor, or type conversion before '<' token

---

:aie:

std:: ?
#include <vector> ?

Si tu veux la propreté du code, tu fais un retour par valeur et tu prends le constructeur par copie. Ton histoire de pointeur, c'est bien, mais c'est sale pour éviter qqch qui est inutile sauf si tu démontres le contraire.

Donc si je veux éviter pointeur et recopie il faut que j'utilise le "swap"?

Oui, mais c'est un hack :|
D'abord vérifie que c'est bien un goulot d'étranglement, et ensuite optimise.

Citation:

---

Oui, mais c'est un hack :|

---

C'est à dire, ç'est pas fiable à 100%?

Si c'est fiable, mais c'est de la bidouille, c'est tout sauf intuitif. Surtout que...

Citation:

---

Sinon si je m'entête pour ne pas mettre de vector en paramètre c'est pour la propreté du code

---

On ne doit pas avoir la même conception d'un code propre. Pour moi le passage par référence l'est tout à fait, le swap par contre est cradingue.

Et puis comme le dit Miles, est-ce qu'il est réellement nécessaire d'éviter cette copie ?

Je suis désolé, mais là honêtement tu fais de la résistance pour rien, ce serait tellement plus simple de faire comme il faut :|

Exact, un code propre, c'est un code qu'on comprend directement en lisant, avec des hacks, c'est plus le cas, et c'est déjà de l'optimisation, alors qu'on ne sait même pas si ce sera critique !

Bon OK je vais me contenter d'un passage par référence ce sera le plus simple.
Sinon est-ce qu'il n'y a pas de mécanisme d'optimisation lors de la copie d'un trés grand tableau:un style de swap géré automatiquement; ou est-ce que dans tous les cas la recopie est effectué "bêtement" si rien n'est indiqué par le programmeur.

Le mieux que tu puisses espérer comme optimisation sur un retour par valeur, c'est la RVO (Return Value Optimization), qui évite parfois une recopie lorsque tu construis directement ton objet sur la ligne du return. Mais ça dépend fortement du compilo.

Parfois, les grosses classes copiables implémentent aussi une sémantique de déplacement, ce qui permet lors d'une copie de déplacer les données plutôt que de les copier. C'est le cas par exemple dans certaines classes de matrices, si je me souviens bien.

Tu peux aussi simuler ce comportement avec std::auto_ptr (toujours si je me souviens bien).

Citation:

---

ce qui permet lors d'une copie de déplacer les données plutôt que de les copier

---

déplacer, copier c'est pas la même chose?
Tu veux dire au niveau des pointeurs sur les zones mémoire.

Déplacer signifie déplacer la "responsabilité", pas les données en elles-mêmes. En gros tu vas passer ton pointeur vers les données d'une instance à une autre.

OK je marque le sujet :resolu:.

Merci pour votre aide.:D

Citation:

---

Envoyé par Laurent Gomila

Parfois, les grosses classes copiables implémentent aussi une sémantique de déplacement, ce qui permet lors d'une copie de déplacer les données plutôt que de les copier. C'est le cas par exemple dans certaines classes de matrices, si je me souviens bien.

Tu peux aussi simuler ce comportement avec std::auto_ptr (toujours si je me souviens bien).

---

Ca ressemble un peu au Copy-On-Write. Ca permet de faire des copies à peu de frais, en comptant le nombre de références à l'espace mémoire qu'on partage. Par exemple, si on fait brutalement, sur des matrices :

Code:

---

1 2	a = b+c; c = a;

---

il faudrait recopier à chaque fois le résultat de l'addition dans a, puis a dans c, ce qui est long. Làs, on copie simplement l'espace mémoire et on dit indique qu'il y a 2 objets qui utilisent cet espace.
Maintenant, si on veut modifier a, il faut recopier a dans un nouvel espace, et indiquer qu'on ne partage plus qu'avec c.
Ca marche très bien avec des boost::shared_ptr<>

MAintenant, si on sait qu'on a juste une seule copie valide à chaque fois, effectivement les std::auto_ptr<> sont idéals car ils transmettent la responsabilité au lieu de la partager.

Les RVO suivant les compilos marchent plutôt bien. J'ai été supris par SunWSPro CC qui se débrouillait pas mal du tout.
Sinon, les types auto_xxx (il n'y a pas un auto_array chez boost ? -- ou alors, c'est chez adobe?) qui implémentent une sémantique de déplacement sont globalement plus efficaces (et simples à mettre en oeuvre) que le COW -- qui pose des petits problèmes de coût obligatoire en multi-threads.

Avec le COW, tout parait plus simple car il n'y a qu'un seul type à manipuler. Avec la sémantique de déplacement, aujourd'hui (les rvalue reférences pourraient changer la donner en C++0x -- si acceptées), il faut se balader avec deux types. Avec les passages d'arguments en [out] (référence non constante), l'écriture est un chouilla moins naturelle.

Chez Boost, ils n'ont pas d'auto_xx, c'est scoped_xxx - non copiable -, shared_xxx, instrusive_ptr ou weak_xxx :)
De toute manière, le COW n'est à utiliser que dans des cas très précis.