Discussion :

[momy2014]

Bonjour,
j'ai une classe intitulée "produit_fini" qui hérite à la fois de la classe "stock" (afficher, modifier, supprimer) et de la classe "production" (saisir) .
Mon problème est que je n'arrive pas à programmer cet héritage.
j'ai essayé de faire ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
class produit_fini : public stock , public production
{ public:
int code;
produit_fini();
~produit_fini();
void saisir();
void afficher();
void modifier();
void supprimer();
 
};

Aidez-moi SVP

[bretus]

Bonjour,

Je pense que tu abuses de l'héritage et que tu devrais revoir ta conception.

Si tu ne peux pas dire "un produit_fini est un stock, tu ne dois pas faire un héritage".

Si tu as "un stock recense une liste de produit_fini", tu auras plutôt une liste de produit_fini en variable membre du stock.

[Bousk]

Je suis d'accord avec Bretus et trouve suspect cet héritage.
Quant au problème

je n'arrive pas à programmer cet héritage

je ne comprends pas ce que tu veux dire... enfin, ça veut rien dire.

[ternel]

Ce qui se conçoit bien s'énonce clairement, et les mots pour le dire viennent facilement.

Il en va de même avec la programmation.
De mon point de vue, si tu n'arrives pas à coder ton héritage, le problème est dans la question: soit c'est "l'héritage", soit c'est "coder".
Dans le premier cas, repense ta solution, dans l'autre, révise tes connaissances du C++

En l’occurrence, Bretus (et nous) te disons que c'est l'héritage le problème.
J'en remets une couche.

Si tu parles d'avoir, c'est un membre qu'il te faut, si tu parles d'être, c'est de l'héritage.
C'est important, l'héritage signifie qu'on peut manipuler une référence vers le type de base (base&) désignant une variable du type héritant, sans perte d'information.

Ton produit fini n'a rien a voir avec un stock, en effet.

[Sunsawe]

Salut,

Je rejoins totalement l'avis des autres au sujet de la manière dont tu as conçu ton programme. Vu d'ici, il semblerait bien qu'il y ait quelque chose majeure à revoir.
Toutefois si pour une raison quelconque, tes choix étaient justifiés (un produit finit étant la combinaison d'un produit stocké et d'un mode de production ), pour qu'on puisse t'aider plus il faudrait nous en donner plus.

1) On suppose tous que tu n'y arrives pas, c'est bien pour ça que tu es là
2) Le problème est aussi complexe pour nous que pour toi. Si tu ne détaille pas ce que tu as déjà fait, on peut aller jusqu'à te demander "est-ce que tu sais ce qu'est l'héritage? un objet..? une variable....?" (oui, j'exagère les deux derniers). A moins de te refaire un cours sur le sujet, comment être sur de bien cibler la cause du problème?
3) En pratique, tu parles d'héritage depuis deux classes de base mais ne fournit que la signature de la classe enfant... ça compile? ou pas? et les classes de bases? tu les as faites aussi? elles compilent? ou pas? erreur fournit par le compilateur? erreur de runtime? pas d'erreur, juste que ça ne fait pas ce que tu veux??
4) Au pifomètre, les méthodes de ta classe enfant, sont elles des redéfinitions des méthodes des classes de base? ces dernières sont elles virtuelles?

[ternel]

Ca pourrait être une erreur de nommage.

un Stock s'affiche, se modifie et se supprime. Ca ressemble plus à un stockable.
un production peut être saisi, ca ressemble à un constructeur.

La structure que j'aurai choisi serait plutot:

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
class produit {
    string nom;
    int prix;//en centimes.
public:
    produit(string const& nom, int prix);
 
    string nom() const;
    int prix() const;//en centimes.
}
 
produit demander_produit();
//voire même
std::istream& operator>>(std::istream&, produit &);
 
//pour l'affichage
std::ostream& operator<<(std::ostream&, produit const&);
 
 
//une classe extérieure: 
class entrepot {
    collection<produit> produits; // une map? un vector?
 
public:
    entrepot& operator<<(produit const& p) {produits.add(p); return *this;}
 
    //les itérateurs classiques
    const_iterator& begin() const;
    //...
 
    entrepot& remove(produit const& p);
};
 
//pour l'affichage
std::ostream& operator<<(std::ostream&, entrepot const&);