Bonjour tout le monde,

J'essaye de faire un vecteur d'objet connaissant leur voisins (qui ne sont pas forcément à l'indice précédent).

Pour cela, j'ai fait une structure de noeud contenant des données, le pointeur sur le noeud précédent et le noeud suivant:

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
21
22
23
24
25
26
27
28
29
30
 
#include <vector>
#include <iostream>
using namespace std;
 
struct Data
{
	double m_val;
	int m_id;
 
	Data(): m_val (0), m_id(-1)
	{
	}
 
	virtual ~Data()
	{
	}
 
};
 
struct Node
{
	Data* m_data; //des données contenant un id
	Node* m_next; // le noeud précédent
	Node* m_prev; // le noeud suivant
 
	Node(): m_data(NULL), m_next(NULL), m_prev(NULL)
	{
	}
};
Jusque là rien d'extraordinaire.

Ensuite, je fais une autre structure contenant une tête et une queue ainsi qu'un vecteur de Node.

Quand j'insère un objet Data, je crée un nouveau Node et je l'ajoute à celui ci et je mets à jours les différents Node.

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
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
struct Graph
{
	Node* m_head; 
	Node* m_tail;
 
	std::vector<Node> m_nodes;
 
	Graph(): m_head(new Node()), m_tail(new Node())
	{
               //Creation d'un graph fermé bouclant aux extrémités
 
		m_head->m_next = m_tail;  
		m_head->m_prev = m_head;
 
		m_tail->m_prev = m_head;
		m_tail->m_next = m_tail;
	}
 
        virtual ~Graph()
        {
              delete m_head;
              delete m_tail;
        }
 
	void insert(Data* data)
	{
		if (data != NULL)
		{
			data->m_id = m_nodes.size();
			m_nodes.push_back(Node());
 
			m_nodes[data->m_id].m_data = data;
 
			m_nodes[data->m_id].m_next = m_tail;
			m_nodes[data->m_id].m_prev = m_tail->m_prev;
 
                        // lors du premier ajout, m_tail->m_prev correspond à m_head
			m_tail->m_prev->m_next = &(m_nodes[data->m_id]);
			m_tail->m_prev = &(m_nodes[data->m_id]);
		}
	}
};
Voici un exemple d'utilisation:
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
 
int main(int argc, char **argv) {
 
	Graph g;
	Data d, d1, d2;
 
	g.insert(&d);
	g.insert(&d1);
	g.insert(&d2);
 
        if (g.m_nodes[0].m_next == &(g.m_nodes[1]))
        {
             cout << "C'est ok" << endl;
        } else 
        {
             cout << "Tu t'es planté" << endl;
        }
	return 0;
}
Mon problème est que je n'obtiens pas le bon résultat ("C'est ok").
Pire encore, lorsque je tente d'accéder aux données du Noeud 1 à partir du Noeud 0 (g.m_nodes[0].m_next->m_data) j'ai une belle erreur de segmentation alors que lorsque je n'ai pas de problèmes lorsque j'accède directement à ces données à partir du noeud 1 (g.m_nodes[1].m_data)...

J'ai remarqué que les adresses des Node stockés dans le vecteurs changeaient au cours de l'insertion de nouveau Node.

Est-ce normal?

Comment remédier à ce problème (sans remplacer des Nodes par des pointeurs de Node au niveau du vecteur)?

Merci pour tout!