has incomplete type,forward declaration of ,

**Pragmateek** · 21/07/2006, 22h24

Salut!

En tentant de compiler ce code:

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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
#ifndef ELECTRONIC
#define ELECTRONIC
 
#include <vector>
#include <string>
 
#ifndef BIT
typedef char BIT;
#else
#error BIT is already defined
#endif
 
 
class Component;
class ComponentPort;
class BooleanPolynom;
class BinaryOperator;
class Bit;
 
 
 
class Component{
private:
    unsigned fanIn;
    unsigned fanOut;
 
    std::string name;
 
    std::vector<ComponentPort*> inBuffer;
    std::vector<ComponentPort*> outBuffer;
 
    BooleanPolynom function;
public:
    /*Default constructor*/
    Component():fanIn(0),fanOut(0){};
    /*Binary constructor*/
    Component(unsigned _fanIn,unsigned _fanOut):fanIn(_fanIn),fanOut(_fanOut){}
 
    std::string getName(void);
    unsigned getFanIn(void);
    unsigned getFanOut(void);
};
 
 
class ComponentPort{
private:
   Component* currentComponent;
   Component* connectedComponent;
 
    Bit value;
    unsigned index;
 
public:
    Bit getValue(void);
    unsigned getIndex(void);
    Component* getCurrentComponent(void);
    Component* getConnectedComponent(void);
};
 
 
class BooleanPolynom{
private:
    bool isBit;
 
    BinaryOperator binaryOperator;
 
    BooleanPolynom* leftBooleanPolynom;
    BooleanPolynom* rightBooleanPolynom;
 
public:
    Bit evaluate(void);
};
 
Bit BooleanPolynom::evaluate(void){
 
    if(isBit){
        return (static_cast<Bit> (this))->value;
    }
 
    Bit firstOperand=leftBooleanPolynom->evaluate();
    Bit secondOperand=rightBooleanPolynom->evaluate();
 
    return binaryOperator(firstOperand,secondOperand);
 
}
 
class Bit : public BooleanPolynom{
private:
    BIT value;
public:
    Bit(BIT _value):value(_value){}
 
    BIT getValue(void);
};
 
BIT Bit::getValue(void){
    return value;
}
 
 
class BinaryOperator{
 
public:
    virtual Bit operator()(Bit b0,Bit b1)=0;
};
 
 
class AND : public BinaryOperator{
    Bit operator()(Bit b0,Bit b1){
        Bit result((b0.getValue())&(b1.getValue()));
        return result;
    }
};
#endif

les erreurs pleuvent:

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
 
32  field `function' has incomplete type 
50 field `value' has incomplete type 
65 field `binaryOperator' has incomplete type 
In member function `Bit BooleanPolynom::evaluate()': 
74 return type `struct Bit' is incomplete 
77 invalid use of undefined type `struct Bit' 
18 forward declaration of `struct Bit' 
80 variable `Bit firstOperand' has initializer but incomplete type 
80  invalid use of undefined type `struct Bit' 
18  forward declaration of `struct Bit' 
81 variable `Bit secondOperand' has initializer but incomplete type 
81  invalid use of undefined type `struct Bit' 
18 forward declaration of `struct Bit' 
83 `binaryOperator' undeclared (first use this function)

Beaucoup semble étranges:
-les "incomplete type" alors que les classes sont définies.
-les "forward declaration" alors que ce ne sont que des déclarations.

Merci de votre aide.

**roulious** · 21/07/2006, 22h30

Envoyé par seriousme

-les "incomplete type" alors que les classes sont définies.

Les classes concernées par les "incomplete type" ne sont pas définies, elles ne sont que déclarées. Pour déclarer une donnée membre d'un type, il faut que ce type soit complètement défini, donc dans ton cas il faut la déclaration des classes.

On ne peut faire une déclaration anticipée que quand on manipule des références ou des pointeurs sur le type concerné. Vu que tes membres sont des objets, ça ne marche pas.

**Pragmateek** · 21/07/2006, 22h33

Les classes concernées par les "incomplete type" ne sont pas définies, elles ne sont que déclarées. Pour déclarer une donnée membre d'un type, il faut que ce type soit complètement défini, donc dans ton cas il faut la déclaration des classes.

En quoi ne sont elles pas définies?

Les méthodes sont définies, les champs ont des types qui sont aussi définis, non?

**Pragmateek** · 21/07/2006, 22h38

On ne peut faire une déclaration anticipée que quand on manipule des références ou des pointeurs sur le type concerné. Vu que tes membres sont des objets, ça ne marche pas.

En mettant la définition de la classe "Bit" avant celle de "BooleanPolynom" les "forward declaration" disparaissent.
Pourquoi?

Qu'importe au compilo que la classe soit définie au début ou à la fin du moment qu'il connait son existence via sa déclaration?

**Eusebe** · 21/07/2006, 22h39

Il faut définir tes classes dans le bon ordre.

Par exemple, dans "Component", tu as "BooleanPolynom function;". Donc il faut que tu définisses ta classe BooleanPolynom avant ta classe Component.

**Pragmateek** · 21/07/2006, 22h41

Envoyé par Eusebe

Il faut définir tes classes dans le bon ordre.

Par exemple, dans "Component", tu as "BooleanPolynom function;". Donc il faut que tu définisses ta classe BooleanPolynom avant ta classe Component.

C'est plutôt étrange que le compilo ne soit pas capable de chercher la définition de la classe plus loin alors qu'elle a été déclarée.

**roulious** · 21/07/2006, 22h43

Envoyé par seriousme

Qu'importe au compilo que la classe soit définie au début ou à la fin du moment qu'il connait son existence via sa déclaration?

Justement, non. Au moment où tu déclares les membres, leur type doit être complètement défini.

**Pragmateek** · 21/07/2006, 22h48

Mais là ca risque de tourner en rond car "Bit" a besoin de "BooleanPolynom" par héritage et "BooleanPolynom" se sert de "Bit".

**roulious** · 21/07/2006, 22h54

Envoyé par seriousme

Mais là ca risque de tourner en rond car "Bit" a besoin de "BooleanPolynom" par héritage et "BooleanPolynom" se sert de "Bit".

Exact

Faire hériter Bit de BooleanPolynom est une erreur de conception : si je comprends bien ton code, Bit n'a pas de polynome gauche et droit. Je suppose que quelque part dans BooleanPolynom, tu mettras des fonctions permettant d'affecter ces deux polynome. Bit ne respectera alors pas cette interface, et ne devrait donc pas hériter de BooleanPolynom.

Voir http://www.parashift.com/c++-faq-lit....html#faq-21.6 et les questions suivantes pour l'utilisation de l'héritage.

**Pragmateek** · 21/07/2006, 23h06

En fait c'est une application directe de la théorie des polynomes boolens:
-une variable booleenne, ici représentée par "Bit", est un polynome booleen.
-si p1 et p2 sont des polynomes booleens alors operateur(p1,p2) est un polynome booleen.

Donc faire hériter "Bit" de "BooleanPolynom" semble logique; il suffit juste de mettre à NULL tous les pointeurs.

**rigobert** · 22/07/2006, 01h24

Envoyé par roulious

Faire hériter Bit de BooleanPolynom est une erreur de conception

Mouais, pas évident.

En revanche utiliser le type Bit dans sa propre classe de base, ça c'est une grosse bêtise

qui mérite à elle seule de se repencher sur la conception !

.

**Luc Hermitte** · 22/07/2006, 01h53

Envoyé par seriousme

C'est plutôt étrange que le compilo ne soit pas capable de chercher la définition de la classe plus loin alors qu'elle a été déclarée.

La compilation est déjà suffisament lente quand le code est mal organisé. Si en plus il fallait payer une passe supplémentaire juste pour savoir :
- le nombre d'octet à réserver pour les attributs
- des bouts de code pour les E/S de fonctions
- ...
alors le café, on aurait le temps de le moudre nous même.

**Pragmateek** · 22/07/2006, 15h03

Envoyé par Luc Hermitte

La compilation est déjà suffisament lente quand le code est mal organisé. Si en plus il fallait payer une passe supplémentaire

La seconde passe serait plus légère car centrée sur les problèmes de définition trouvés lors de la première passe.

has incomplete type,forward declaration of ,

C++

Discussions similaires

Partager

Partager