Discussion :

[Pragmateek]

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]

-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]

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]

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]

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]

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]

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]

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

[roulious]

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]

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]

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]

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]

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.