Matrice Graphe C++

salut

j'ai besoin d’implémenter une matrice qui représente un graphe. j'utilise la notion du vector : vector<vector<type> > matriceGraphe. Mais, je me trouve devant le problème suivant :

Mon graphe est composé d'un ensemble des nœuds de différents type ainsi qu'un ensemble des arcs de différents types (en fait chaque type nœud ou arc est une classe ) donc le problème comment déclarer ça ?

Si tes classes (nœud et arc) fournissent respectivement les mêmes services (c'est-à-dire qu'elles ont respectivement la même interface), tu peux utiliser le polymorphisme (d'inclusion).
(Attention avec la classe std::vector et l'héritage, le plus "simple" et de stocker des std::vector<std::shared_ptr<T>> ou des std::vector<std::unique_ptr<T>> selon l'usage)
FAQ C++ - Héritage

Si ce n'est pas le cas, tu peux créer un type qui contient tous les types possibles et faire les tests qui vont bien pour savoir lequel utiliser (?) (On peut peut être utiliser une union (?)). Mais cette solution est à éviter.

Merci pour la réponse mais je ne parle d'héritage ici. La difficulté pour moi est le type des nœuds et des arcs : les nœuds du graphe ont un type complexe(classe) différent du type des arcs (aussi classe). En fait, le graphe est composé des instances de la classe Nœud (Nœud.h) et les arc sont des instances de la classe Arc (Arc.h). Aidez moi comment je peux implémenter ça?

Si j'utilise l'imbrication des vecteurs pour implémenter la matrice (i.e vector<vector> ), est ce je peux donner pour chaque vecteur un type différent?

Citation:

---

Envoyé par kochfet

Si j'utilise l'imbrication des vecteurs pour implémenter la matrice (i.e vector<vector> ), est ce je peux donner pour chaque vecteur un type différent?

---

Non, c'est std::vector<std::vector<T>>.
Il existe les tuple qui permettrait de faire std::tuple<std::vector<T>, std::vector<U>, std::vector<V>, ...> mais je ne pense pas que ce soit que tu veux faire.

J'ai du mal à comprendre ton problème, qu'est-ce qui ne va pas avec un truc du genre :

Code:

---

1 2 3 4 5 6 7

class noeud { T value; std::pair<noeud, int> arcs; // Les arcs mènent à un noeud et ont un poids };   std::vector<noeud> graphe;

---

la classe Nœud et la classe Arc sont indépendantes. Le graphe à construire a pour sommets des instances de la classe Nœud et pour arcs des instances de la classe Arc. La matrice correspondante est donnée dans la figure ci-joint.
(N1,N2, N3 sont de type Noeud et Arc1, Arc2 et Arc3 sont de type Arc)

Citation:

---

Envoyé par kochfet

(N1,N2, N3 sont de type Noeud et Arc1, Arc2 et Arc3 sont de type Arc)

---

C'est plus le même problème que dans le premier message (?!)

Citation:

---

Envoyé par kochfet

Mon graphe est composé d'un ensemble des nœuds de différents type ainsi qu'un ensemble des arcs de différents types (en fait chaque type nœud ou arc est une classe)

---

Tu peux donc utiliser std::map<Noeud, std::map<Noeud, Arc>> :)

Merci pour votre réponse, je vais essayer ça :)

Même si tu ne l'utilise pas, va jeter un œil du côté de boost.graph, les explications peuvent te donner des idées sur les possibilités d'implémentation.

svp
j'ai rencontré une erreur dans la compilation de mon code :
En fait, j'ai une classe classe A avec les deux constructeurs suivant:
un constructeur par défaut : A(cout<<"par défaut")
un constructeur paramétré : A(int a);
aussi j'ai une classe B dérivée de A ( class B : public A). Cette classe possede aussi deux constructeurs :
un constructeur par défaut : B()
un constructeur paramétré : B(int b); Dans le fichier B.cpp
j’écris B(int b) {A(a)} càd j'ai fait appel au constructeur paramétré de A puisqu'elle est sa classe mère.

Dans le main j'instancie un objet de type B comme suit :
B obj(4);
j'essaye d'afficher le 4 mais il s'affiche par défaut c-a-d
un appel du constructeur par défaut de A est appelé et pas le constructeur paramétré. Je veux savoir qu'elle est ma faute?

Salut

Il faut écrire

Code:

---

1 2 3

B::B(int b) : A(b) { }

---

Et pas

Code:

---

1 2 3 4

B::B(int b) { A(b); }

---

Ta faute est que la ligne A(b); crée un objet temporaire de classe A qui est détruit immédiatement. Ca ne sert donc à rien. Tu viendrais pas du Java par hasard :mrgreen: ?

Merci pour la réponse

J'essaye de déclarer ma classe Graphe comme suit :

Code:

---

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

#ifndef Graphe_H #define Graphe_H #include<iostream> #include<string> #include <vector> #include "Noeud.h" #include "Lien.h"   using namespace std; class Graphe { private : vector<Noeud*> vecNoeuds; int numNoeud ;     public : Lien** matLiens; string nom;   Graphe(string); Graphe(const Graphe&);   void ajouterNoeud(Noeud* n); void ajouterLien(Noeud NoeudDépart,Noeud NoeudArrivé,string attr);   void afficher(); ~Graphe(); }; #endif

---

Est ce que je dois utiliser vector <vector<Lien*> > matLiens; au lien Lien**matLiens? Car pour moi la taille de ma matrice est calculée en utilisant le vecNoeuds qui contient le nombre des noeuds qui seront ajouter à l'exécution autrement taille = taille de vecNoeuds*taille vecNoeuds