Bonjour à tous,

Au cours de mes "exercices", je me suis posé la problématique suivante : "Comment découper un vecteur (ou mieux, une plage mémoire donnée) de données contigües en plusieurs vecteurs différents, SANS perdre pour autant la contiguïté de la plage de données initiale ?"
Je ne le cacherais pas, l'objectif derrière tout ça est de pouvoir manipuler des portions de la mémoire allouée initialement de manière indépendante, et permettre une itération sur l'ensemble des données initiales, le tout sur une plage de données contiguës.

Dans un premier temps, je considère que, lors de l'ajout d'un élément d'un "sous_vecteur", l'ensemble des données suivantes sont simplement poussées les unes après les autres.

Pour ce premier aspect, je visualise plutôt bien les choses. Là où ça se gâte, c'est comment m'assurer que l'ensemble des vecteurs liés à la "Base" (le block de mémoire contenant l'ensemble des éléments) sont bien systématiquement décalés ?

Pour réaliser ça, j'ai tenté de procéder de deux manières différentes :
- en manipulant des pointeurs bruts... Méthode classique (ou presque)
- en manipulant des vecteurs (std::vector).

J'ai donc réussi à peu près à atteindre l'objectif, mais les implémentations générées ne me plaisent pas du tout, le système pondu semble à la fois fragile et hyper rigide à l'utilisation, bref, je dois refondre le code de A à Z.
Je suis très surpris de me retrouver à buter sur un tel sujet qui me semble, dans l'idée en tout cas, très simple....

Mes questions sont donc les suivantes :
- Que pensez-vous des méthodes proposées ?
- connaissez-vous des méthodes alternatives plus simples à mettre en œuvre ?
- Sauriez-vous m’orienter vers des sources d'inspiration pour implémenter un tel système ?

Bref, toute aide est la bien-venue... Pour aider un peu la compréhension, voici, in fine, comment je vois l'utilisation de cet outil :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
global_memory<int> base;
sub_vector<int> v1 = base.generate_vector(); // renvoie un vecteur(ou un simple tableau, peu importe) pointant uniquement sur une portion de "base"
sub_vector<int> v2 = base.generate_vector(); // typiquement, v2.begin() == v1.end() == &base[v1.size()]
 
v1.push_back(3);	// ici, v1.size() augmente, donc, v1.end() aussi, donc, v2.begin() aussi !
v2.push_back(5);	// ici, seul v2 est affecté, car v1 a été initialisé avant... 
 
sub_vector<int> v3 = base.generate_vector();	// là aussi, v3.begin() == v2.end() == &base[v1.size() + v2.size()]

Espérant trouver une solution aisée à mettre en œuvre...