Discussion :

[vince3320]

Bonjour,

Ma question est toute simple mais je ne trouve pas la réponse...

J'ai un vector contenant disons 100 doubles.

J'aimerais pouvoir crée un vector contenant les valeurs des positions 20 a 40 de mon gros vector.

En gros un truc du genre

Code :

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

monPetitVect<double> = new vector (monGrosVect[20]; monGrosVect[40]);

Mon petit vector contiendrait donc 20 doubles qui sont les valeurs contenus dans mon gros vector aux positions de 20 a 40.

Merci

[darkman19320]

Salut,

Je procède de la façon suivante mais il y a sans doute mieux:

Code :

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

1
2
3
std::vector<double>::const_iterator first = myVector.begin() + 20;
std::vector<double>::const_iterator last = myVector.begin() + 40;
std::vector<double> subcopyMyVector(first, last);

[vince3320]

Salut!

Merci pour ta réponse mais il me semble qu'il y a plus rapide (vieux souvenirs de mes études...^^)

[jmv]

Salut!

Merci pour ta réponse mais il me semble qu'il y a plus rapide (vieux souvenirs de mes études...^^)

non, il y a plus court comme code donc plus rapide à écrire comme :

Code :

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

std::vector<double> subcopyMyVector(myVector.begin() + 20, myVector.begin() + 40);

ou alors :

Code :

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

std::vector<double> subcopyMyVector(&myVector[20],&myVector[40]);

Mais ça ne sera pas plus rapide à l'exécution.

[gbdivers]

Si le vecteur n'est pas destiné à être modifié, le mieux est encore de ne pas le copier. En effet, les algos de la STL (et ceux qui programment correctement) utilisent une itérateur sur le premier et le dernier+1 élément. Donc il est possible d'écrire :

Code :

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

unAlgo(myVector.begin() + 20, myVector.begin() + 40);

au lieu de

Code :

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

1
2
3
4
5
std::vector<double> subcopyMyVector(myVector.begin() + 20, myVector.begin() + 40);
unAlgo(subcopyMyVector.begin(), subcopyMyVector.end());
 
// ou encore plus moche
unAlgo(subcopyMyVector);

[Iradrille]

Si le vecteur n'est pas destiné à être modifié, le mieux est encore de ne pas le copier. En effet, les algos de la STL (et ceux qui programment correctement) utilisent une itérateur sur le premier et le dernier+1 élément. Donc il est possible d'écrire :

Code :

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

unAlgo(myVector.begin() + 20, myVector.begin() + 40);

Et même depuis C++11 :

Code :

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

unAlgo(myVector.cbegin() + 20, myVector.cbegin() + 40);

[gbdivers]

Bonne remarque...
Il est vrai que je préfère l'écriture :

Code :

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

unAlgo(begin(myVector) + 20, begin(myVector) + 40);

Mais il n'existe pas de fonction libre cbegin().

begin() renverra aussi un const_iterator, l'utilisation de cbegin() est une question de lisibilité et une garantie plus forte (l'appelant de la fonction sait qu'il ne veut pas que le vecteur soit modifié et si la fonction essaie de le faire, le compilateur râlera)

Du coup, je sais pas s'il est préférable d'utiliser begin(v) ou v.cbegin()

[banche]

Il me semble que la std n'implémente pas cette fonctionnalité. Tu veux pouvoir référencer une partie continue d'un vecteur et en faire une copie. Cette fonctionnalité est présente dans certaines bibliothèques et souvent dans celle de calcul car c'est un besoin récurrent.

Tu as plusieurs manière de l'implémenter
-- soit tu fais une copie de la zone mémoire
-- soit tu utilise un mécanisme d'implicit sharing avec des pointeurs partagés.
-- soit tu met en place en architecture d'objet te permettant de représenter des segment référençant ton objet donc non responsable de la zone mémoire.

Par exemple Qt à implémenter la première solution dans ses api avec les fonctions mid regarde le QVector par exemple c'est exactement ce que tu veux faire.

La deuxième solution n'est pas bien compliquée à implémenter par contre tu as les défaut de l'implicit sharing en terme de performance. Si jamais tu fais des accès avec [] non const par exemple tu auras à chaque accès une vérification afin de savoir si la zone mémoire n'est pas partagée. Mais si c'est pour faire des lectures const tu n'auras pas de surcout.
La 3ème solution est plus complexe tu peux soit faire une implémentation "fonctionnelle" en plusieurs classes pour représenter un vecteur ou pousser avec le code template. Eigen met en place un mécanisme de ce genre la je crois, le code étant relativement violent je n'ai pas approfondi!!

Une implémentation d'un conteneur maison avec les méthodes de constructions à partir de std::vector me semble plus simple à réaliser.
Tu pourras rajouter les méthode mid ou segment qui feront ce dont tu as besoin.

++

[Bousk]

std::vector a un constructeur qui réalise ça tout simplement sinon..
http://www.cplusplus.com/reference/v...vector/vector/

(3) range constructor
Constructs a container with as many elements as the range [first,last), with each element constructed from its corresponding element in that range, in the same order.

vector::insert permet aussi d'ajouter à partir d'iterator

Mais est-il vraiment cohérent de créer un autre vector à partir du premier ou pourrais-tu te contenter de passer les valeurs (iterator) qui correspondent au range à traiter à ton algo ?