j´ai un probleme pour déclarer des méthodes qui seront héritées.

j´ai une classe A et une classe B qui hérite de A

je souhaite mettre une methode virtuelle dans A, la methode bouger, qui sera codée dans B. cette methode modifira un parametre privé de la classe B.

j´arrive a déclarer une methode virtuelle constance

(virtual void bouge() const = 0)
et a ecrire la methode dans B, mais je n´arrive pas a écrire une methode non virtual

comment fait on?

merci

Que veut tu dire par : "je n´arrive pas a écrire une methode non virtual"

Ecrire une méthode non virtuelle, c´est écrire une méthode normalle.

Donne tout le code de ta classe (ou au moins son prototype (c´est à dire, done ce qui est interessant) ici ou sur ce site si c´est long : http://rafb.net/paste/

Puis montre ce que tu aimerais avoir mais qui ne marche pas.

comme dis dnob, avec le code, ca marche mieux..

un squelette qui peut donner des idees :

class A
{
protected:
virtual void Method() const = 0 { }
};

class B : public A // ou protected/private/virtual si multi
{
protected:
virtual void Method() const { A::Method(); } // ici virtual est facultatif
};

merci, ca marche mieux.

mais j´ai un autre probleme maintenant.

j´ai une classe esim dont hérite les classes vivant et nonvivant.

j´ai cette methode

esim* esim::creer(int i)
{
if(i<3) return vivant::creer(i);

return nonvivant::creer();
}

j´ai cela comme include

1. include "esim.h"
2. include "vivant.h"
3. include "nonvivant.h"

j´ai l´erreur "nonvivant" is not a class or namespace name.

mais je change l´ordre des include, avec

1. include "esim.h"
2. include "nonvivant.h"
3. include "vivant.h"

j´obtiens la meme errreur avec "vivant"

pourquoi la 2eme class que j´inclus au travers d´un #include n´est pas reconnue??? que faire pour que ca marche?

et encore une petite question...

j´ai toujours la class esim dont hérite vivant et nonvivant.

je souhaite avoir une methode bouger() pour tous les vivants mais pas pour les nonvivants.

j´ai donc mis une methode void bouger() dans la declaration de la classe vivant que j´ai codé dans le ficher .cpp

j´ai ensuite une tableau d´element esim *

j´aimerai pouvoir bouger les elements vivants, mais je ne peux pas faire de TABESIM[i]->bouger(); car je n´ai pas déclarer de methode virtual void bouger() =0; dans la class esim.

si je la mets, je dois ensuite rajouter un void bouger() dans la class nonvivant, methode qui ne contiendra aucune instruction dans le cpp

ma question est donc : comment mettre la methode bouger pour que je puisse y acceder au travers de mon tableau de esim sans a avoir a la declarer dans esim (puisque tous les esims ne bougeront pas, ca me semble illogique selon le principe de l´héritage...)

merci d´avance

Pourquoi ne pas mettre cette méthode bouger() dans la classe vivant qui hérite de esim ?

Ton design n´est pas top.
Plusieurs solutions s´offrent a toi: mets virtual void bouger() {} dans esim, redefini lorsque necessaire. Sinon, tu peux faire un reinterpret_cast<vivant*>(objet_esim), enfin si le RTTI est supporte.

/kUfa

->kilyn

c´est ce que j´ai à la base mais ca me pose problème, relis ma question ^^

-> kufa

si tu parles de design pattern... pas encore vu XD (ouais je débute l´héritage). donc lorsque tu me parles de redefinir ou de reinterpret et RTTI... voila quoi ^^

je dois m´en sortir qu´avec des virtual et des =0 lol

et pour le virtual void bouger() dans le esim, c´est justement ce que je ne souhaiterai pas faire, vu que les nonvivants qui hériteront pourtant de esim, eux, n´ont pas de methode bouger. seuls les vivants le peuvent. si je mets bouger dans esim, je dois declarer et ecrire bouger aussi dans les nonvivants non? et ca me semble pas très bon...

ah oui autant pour moi c´est ce que tu as fait.

pour ta première question avec le vivant::creer();

je pense qu´il y a un sérieux problème d´architecture : vivant::creer n´est rien si ce n´est une fonction membre d´une classe. Mais si la classe à des données membres non const alors tu ne peut pas appeler de fonction membre sans initialiser une instance de la classe.
De plus comme vivant hérite de esim, on peut supposer que esim ne "connait pas" vivant c´est à dire que esim ne doit pas se servir de vivant car c´est vivant qui va se servir de esim (sinon on tombe dans un cerle vicieux).

Je pense donc comem les autres que tu devrais sérieusement penser à la manière dont tu as arrengé tes classes et voir s´il n´y aura pas quelque choses de plus logique.

oui, je sais que idéalement les classes ne connaissent pas ce qu´il y a en dessous. une question de pattern prototype un truc du genre... mais on ne l´a pas encore vu, donc je dois faire avec...

et sinon le probleme s´est resolu... en supprimant la page .cpp, créant la meme et recopiant le contenu... le compilateur a plus rien dit...