C++ Héritage et Constructeurs Help Please !

Podia-Yourt

Nouveau membre
Wouééééééé Cool ça marche !

Merci !

Ne vous inquiétez pas, je vous préviendrai quand Warcraft 4 sortira ! :D

Sinon c'est quoi les std ? Quel est l'avantage par rapport aux listes chainées ?

Et pourquoi c'est bizarre que une unité contienne elle meme une unité ?
Si c'est pour l'héritage c'est normal, les Peon, Grunts, Sorcières sont des "surcouches" d'Unite, elles ont des sorts et des attribus qu'elles ne partages pô. Donc je pense que c'est normal de faire de l'héritage là.
 

KangOl

Grand Maître
pour l'heritage, ok

l'avantage de la stl ? c'est testé et nettement mieux optimisé

renseigne toi et tu sera suppris...
 

Podia-Yourt

Nouveau membre
Hi tout le monde !

Bon j'ai un problème là, j'était tranquillement en train de programmer Warcraft 4, quand tout à coup je me suis rendu compte que je n'arrivais pô à faire des classes dérivées ! Aie ! Donc j'en ai parlé à notre cher ami Google qui m'a sortit plein de cours très intéressants, et quand je fais comme dans les cours chez moi ça marche pô !

Il doit y avoir une petite erreur dans mon code, je pense que cela vient du fait que la classe Unite a un constructeur avec arguments, y doit falloir faire un truc quand je déclare la classe Peon (Peon dérive de Unite biensur).

Voici le code des classes des unitées que j'ai simplifié pour qu'il soit plus lisible :

PS : Tout ce qui concerne Unite fonctionne (Constructeur, Destructeur, Ajoute), le problème est en bas vers Peon.

[cpp]
#include <stdio.h>
#include <windows.h>

int Map[100][100];

class Unite
{
public :
int Cm2;
int Cm2Max;
int X;
int Y;
//Blablabla...
Unite *Suivant;
Unite(int X,int Y);
~Unite(void);
void Ajoute(Unite *Nouvelle);
};

Unite *PremierUnite=NULL;//Premier pointeur de la liste.

Unite::~Unite(void)//Destructeur d'unite, enlève le maillon de la chaine.
{
Unite *Courant;
Courant=PremierUnite;
Map[this->X][this->Y]=99;//On libere la map.
if (PremierUnite==this)
{
PremierUnite=this->Suivant;
return;
}
while(Courant->Suivant!=this)
{
Courant=Courant->Suivant;
}
Courant->Suivant=this->Suivant;
}

Unite::Unite(int X,int Y)//Contructeur d'Unite.
{
this->Cm2=350;
this->Cm2Max=400;
this->X=X;
this->Y=Y;
//Blabla....
this->Suivant=NULL;
Map[X][Y]=-1;//Reserve sa case sur la carte.
Ajoute(this);//Ajoute la nouvelle unite à la fin de la liste.
}

void Unite::Ajoute(Unite *Nouvelle)//Ajoute l'unite Nouvelle à la fin de la liste chainée.
{
Unite *Courant;
Courant=PremierUnite;
if (Courant==NULL)//Si c'est la première :
{
PremierUnite=Nouvelle;
return;
}
while(Courant->Suivant!=NULL)//Sinon on va jusque au dernier :
{
Courant=Courant->Suivant;
}
Courant->Suivant=Nouvelle;//On la colle à la fin.
}

class Peon : public Unite
{
public :
int W;
Peon(int X,int Y,int W); //Ca va là ?
};

Peon::peon(int X,int Y,int W):Unite(int X,int Y) //C'est comme ca ?
{
this->W=W;
}

/* COURS :
B::B(int a, int b, int c) // Supposons que B derive de A
:A(int a, int b) // Ici on passe les paramètres au constructeur de A
{
...
}
*/

/* COURS 2 :
Etudiant(double m, const char * name, const char * adress = 0) :
Personne(name, adress), moyenne(m) {}

// Constructeur de recopie
// (on fait appel au constructeur de recopie de la classe Personne)
Etudiant(const Etudiant & e) : Personne(e), moyenne(e.moyenne) {}
*/

int main(void)
{
printf("SALOUTE !\n");
new Unite(2,2);
//printf("x : %d\n",PremierUnite->X);
system("pause");
return 0;
}
[/cpp]
 

KangOl

Grand Maître
Code:
Peon::Peon(int X,int Y,int W) : 
   Unite(X,Y) {
          this->W=W;
}

sinon a part ca, pouquoi ne pas utiliser std::vector au lieu de cette liste chainée ??
d'ailleur c'est bizarre que une unité contienne elle meme une unité...
 
Vous devez vous inscrire ou vous connecter pour répondre ici.
Derniers messages publiés
Statistiques globales
Discussions
730 126
Messages
6 717 807
Membres
1 586 365
Dernier membre
matiOs1
Partager cette page
Haut