Sommet et arêtes

Version imprimable

Sommet et arêtes

Bonjour,

Je suis en train de créer une arête et un sommet, mais comme vous pouvez le voir j'ai un problème
que je ne comprends pas, lorsque j'utilise "ajoutArete"

Code:

1
2
 
C:\Users\Administrator\Documents\CodeBlocks-C++\GrapheVersionFinal\main.cpp|24|error: variable 'Arete nouvArete' has initializer but incomplete type|

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
#include <iostream>
#include <string>
#include <vector>
 
//#include "Arete.h"
//#include "Sommet.h"
 
using namespace std;
 
class Arete;
 
class Sommet
{
    private:
        string nom;
        vector<Arete> aretes;
    public:
        Sommet(string s_nom)
        {
            this->nom=s_nom;
        }
        void ajoutArete(Sommet *s,int valu)
        {
             Arete nouvArete(this,s,valu);
           // aretes.push_back(nouvArete);
        }
 
         ~Sommet(){};
};
 
class Arete
{
    private:
    Sommet *sOrigine;
    Sommet *sDestination;
    long valuation;
 
    public:
        Arete(const Sommet& s_Origine,const Sommet& s_Destination,int s_valuation)
        {
            sOrigine=new Sommet(s_Origine);
            sDestination=new Sommet(s_Destination);
            this->valuation=s_valuation;
        }
        ~Arete(){};
 
};
 
int main()
{
    Sommet s1("paris");
    Sommet s2("berlin");
 
    Arete a1(s1,s2,878.04);
 
    return 0;
}

02/11/2014, 08h45
LittleWhite

Bonjour,

Une bonne pratique, et, qui je pense, vous évitera ce genre de soucis est de faire un couple de fichier .hpp/.cpp par classe. Donc, des fichiers Arete.cpp/Arete.hpp et des fichiers Sommet.cpp/Sommet.hpp
Ensuite, vous placez les implémentation (le code) des fonctions dans les CPP et les définition/déclaration des classes dans les .hpp.

Pour l'erreur, elle indiquait simplement que le compilateur ne peut pas utilisé le type "Arete" car il ne connait pas l'intégralité du type. En effet class Arete; permet bien de dire au compilateur que le type existe, mais ne lui permet pas vraiment de l'utiliser (car il sait juste qu'il existe et non ce qu'il contient ou ce qu'il est).

Justement je travaille avec les fichiers séparés normalement,
mais j'ai des erreurs que je ne comprends pas.
C'est à dire que c'est la première fois que j'utilise deux classes qui sont interdépendante,
ce que je veux dire par la c'est que "sommet" contient des "arêtes" et les "arêtes" contiennent des "sommet"

Code:

1
2
 
include\Sommet.h|26|error: 'Arete' was not declared in this scope|

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
 
#ifndef SOMMET_H
#define SOMMET_H
 
#include <string>
#include <vector>
 
#include "Arete.h"
 
using namespace std;
 
class Sommet
{
    public:
        Sommet(string s_nom)
        {
            this->nom=s_nom;
        }
        void ajoutArete(Sommet *s,int valu)
        {
             Arete nouvArete(this,s,valu);
           // aretes.push_back(nouvArete);
        }
         ~Sommet(){};
    private:
        string nom;
        vector<Arete> aretes;
};
 
#endif // SOMMET_H

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
 
#ifndef ARETE_H
#define ARETE_H
 
#include <string>
#include <vector>
 
#include "Sommet.h"
 
using namespace std;
 
class Arete
{
    public:
        Arete(const Sommet& s_Origine,const Sommet& s_Destination,int s_valuation)
        {
            sOrigine=new Sommet(s_Origine);
            sDestination=new Sommet(s_Destination);
            this->valuation=s_valuation;
        }
        ~Arete(){};
    private:
    Sommet *sOrigine;
    Sommet *sDestination;
    int valuation;
 
};
 
#endif // ARETE_H

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
#include <iostream>
#include <string>
#include <vector>
 
#include "Arete.h"
#include "Sommet.h"
 
 
using namespace std;
 
int main()
{
    Sommet s1("paris");
    Sommet s2("berlin");
 
    Arete a1(s1,s2,878.04);
 
    return 0;
}

02/11/2014, 13h35
LittleWhite

Je répète mon conseil : mettez l'implémentation des constructeurs/destructeurs, dans des .cpp et non dans le .hpp. Je crois que c'est la raison.

C'est bon j'ai changé, mais les erreurs restent les mêmes à par si j'ai mal fait
le rajout des fichiers

Code:

1
2
3
4
5
6
 
||=== Build: Debug in GrapheVersionFinal (compiler: GNU GCC Compiler) ===|
include\Sommet.h|20|error: 'Arete' was not declared in this scope|
include\Sommet.h|20|error: template argument 1 is invalid|
include\Sommet.h|20|error: template argument 2 is invalid|
||=== Build failed: 3 error(s), 0 warning(s) (0 minute(s), 0 second(s)) ===|

Arete.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
#ifndef ARETE_H
#define ARETE_H
 
#include <string>
#include <vector>
 
#include "Sommet.h"
 
using namespace std;
 
class Arete
{
    public:
        Arete(const Sommet& s_Origine,const Sommet& s_Destination,int s_valuation);
        ~Arete();
    private:
    Sommet *sOrigine;
    Sommet *sDestination;
    int valuation;
};
 
#endif // ARETE_H

Arete.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
#include "Arete.h"
 
Arete::Arete(const Sommet& s_Origine,const Sommet& s_Destination,int s_valuation)
{
    sOrigine=new Sommet(s_Origine);
    sDestination=new Sommet(s_Destination);
    this->valuation=s_valuation;
}
 
Arete::~Arete()
{
    //dtor
}

Sommet.h

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
 
#ifndef SOMMET_H
#define SOMMET_H
 
#include <string>
#include <vector>
 
#include "Arete.h"
 
using namespace std;
 
class Sommet
{
    public:
        Sommet(string s_nom);
        void ajoutArete(Sommet *s,int valu);
 
         ~Sommet();
     private:
        string nom;
        vector<Arete> aretes;
};
 
#endif // SOMMET_H

Sommet.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
#include "Sommet.h"
 
Sommet::Sommet(string s_nom)
{
    this->nom=s_nom;
}
 
Sommet::~Sommet()
{
    //dtor
}
 
Sommet::ajoutArete(Sommet *s,int valu)
{
             Arete nouvArete(this,s,valu);
           // aretes.push_back(nouvArete);
}

main

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
#include <iostream>
#include <string>
#include <vector>
 
#include "Arete.h"
#include "Sommet.h"
 
 
using namespace std;
 
int main()
{
    Sommet s1("paris");
    Sommet s2("berlin");
 
    Arete a1(s1,s2,878.04);
 
    return 0;
}

02/11/2014, 14h29
LittleWhite

Un début de solution est présent ici, dans la FAQ : http://cpp.developpez.com/faq/cpp/?p...iers-d-en-tete
Il vous faudra une troisième classe/fichier afin de faire comme un intermédiaire. Car là, regardez vos include, sachant que le préprocesseur, lorsqu'il voit un "include", il faut bêtement un copier coller, je peux vous dire que vous avez quelques soucis avec le fichier final (qui est compilé).

Bonjour,

En fait ce qu'il faudrait faire c'est l'inverse, car comme l'a expliqué LittleWhite la classe vector ne peut pas être compilé :

Citation:

car il ne connait pas l'intégralité du type

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
32
33
34
35
36
37
38
class Sommet;
 
class Arete
{
    private:
    Sommet *sOrigine;
    Sommet *sDestination;
    long valuation;
 
    public:
        Arete(const Sommet& s_Origine,const Sommet& s_Destination,int s_valuation)
        {
            sOrigine=new Sommet(s_Origine);
            sDestination=new Sommet(s_Destination);
            this->valuation=s_valuation;
        }
        ~Arete(){};
 
};
 
class Sommet
{
    private:
        string nom;
        vector<Arete> aretes;
    public:
        Sommet(string s_nom)
        {
            this->nom=s_nom;
        }
        void ajoutArete(Sommet *s,int valu)
        {
             Arete nouvArete(this,s,valu);
           // aretes.push_back(nouvArete);
        }
 
         ~Sommet(){};
};

02/11/2014, 18h33
LittleWhite

Oui, car Arete n'utilise que des pointeurs vers la classe Sommet.

Comme personne ne dit rien et que LittleWhite galère je réponds :mrgreen:

Pour cette erreur
Citation:
Envoyé par bouritosse
Bonjour,

Je suis en train de créer une arête et un sommet, mais comme vous pouvez le voir j'ai un problème
que je ne comprends pas, lorsque j'utilise "ajoutArete"
Code:

1 2 C:\Users\Administrator\Documents\CodeBlocks-C++\GrapheVersionFinal\main.cpp|24|error: variable 'Arete nouvArete' has initializer but incomplete type|
Lorsqu'on manipule un objet d'un type autre que pointeur (et éventuellement référence, mais je n'en suis pas sûr :wow:), le C++ exige d'avoir la déclaration complète (il doit connaître au moins sa taille, ces constructeurs, son destructeur).
Tu as fait une déclaration anticipée (forward declaration) de ton type Arete, mais tu manipules un vrai objet Arete.

Sinon :mrgreen:

Mettre l'implémentation de tes méthodes dans les entêtes (fichier .h/ .hpp) permet de faire des méthodes inline implicites. Tu peux tout également utiliser dans la déclaration de ta méthode le mot clef inline et l'implémenter dans le fichier source (fichier .cpp)
Avec les template, le compilateur doit avoir la déclaration complète en permanence (en C++, on include des fichiers, on ne les exporte pas). Donc, tu dois coder toute l'implémentation de ta classe template dans les entêtes. Une technique consiste à faire un 3ième fichier (fichier .tpp), d'y coder l'implémentation et de faire un include en fin d'entête de ce fichier.

Ne mets pas de using namespace std dans un fichier header (.h/ .hpp) :mrgreen:

Je me demande si ce n'est pas ta façon de coder ou ta logique qui est mauvaise :koi:
J'ai le souvenir, dans le temps :mrgreen:, que je faisais 2 tableaux 1 d’arêtes et 1 de sommets, et que pour tout j’utilisais des index de tableau.
Une arête c'était déjà 2 index de tableau de sommets.

Par exemple:
Citation:
Envoyé par PilloBuenaGente
Code:

1 2 3 4 5 6 7 Arete(const Sommet& s_Origine,const Sommet& s_Destination,int s_valuation) { sOrigine=new Sommet(s_Origine); sDestination=new Sommet(s_Destination); this->valuation=s_valuation; }
Tu va créer X fois un même sommet :koi: :koi:

ah oui j'ai fait une petite erreur,
c'est ça que je voulais faire:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
#include "Arete.h"
#include "Sommet.h"
 
Arete::Arete(const Sommet& s_Origine,const Sommet& s_Destination,long s_valuation)
{
    sOrigine=s_Origine;
    sDestination=s_Destination;
    this->valuation=s_valuation;
}
 
Arete::~Arete()
{
    //dtor
}

02/11/2014, 21h02
bouritosse
J'ai finalement réussit à tout faire marcher, en faisant (code en dessous)

en utilisant un pointeur de this, et en changeant le constructeur de arête,
par contre je ne comprends pas vraiment à quoi correspond un *this ,
j'ai mis ça au hasard et ça a marché.
Si quelqu'un peut m'expliquer ?

Sommet.cpp
Code:

1 2 3 4 5 6 void Sommet::ajoutArete(Sommet s,long valu) { Arete nouvArete(*this,s,valu); aretes.push_back(nouvArete); }
Arete.cpp
Code:

1 2 3 4 Arete::Arete(const Sommet& s_Origine,const Sommet& s_Destination,long s_valuation): sOrigine(s_Origine),sDestination(s_Destination),valuation(s_valuation) {}
02/11/2014, 21h08
foetus

this comme son nom l'indique c'est le pointeur sur l'objet courant :mrgreen:

Tu crées une classe qui est un type, mais ce type permet de définir des objets (d'où le this)
03/11/2014, 02h34
koala01
Salut,

Je n'ai pas lu toute la discussion, je me suis arrêté juste après le code fourni par bouritosse. Mais, ce qui m'a frappé, c'est que la classe Sommet contient la lignevector<Arete> aretes;.

Cette seule ligne fait que le compilateur ne peut pas se contenter de savoir qu'il existe une classe nommée Arete lorsqu'il parcourt le fichier Sommet.h.

En effet, le tableau maintient des arrêtes par valeur, ce qui fait que le compilateur doit connaitre la taille exacte que chaque arrête prend en mémoire. Et, pour pouvoir déterminer cette place, la déclaration anticipée ne suffit pas : il a besoin de la définition complète de la classe...

Nota :
- Ce n'est qu'un détail, mais arrête prend deux R... Ce serait cool si tu renommais Arete en Arrete (et toutes les variations sur le même thème de manière similaire) ;). L'orthographe est toujours un point important pour la lisibilité du code ;)
- Jamais de directive using namespace std; dans un fichier d'en-tête... Je pourrais l'expliquer, mais bon l'explication est toujours longue ;) (je ne suis déjà pas fan de cette directive en général, mais dans un fichier d'en-tête, c'est la cata ;))
03/11/2014, 18h08
bouritosse

Arête prend un seul r http://fr.wikipedia.org/wiki/Th%C3%A9orie_des_graphes

et je vais enlever les using namespace, merci