Segmentation fault : méthode sur objet dynamique

Bonjour,
Je suis confronté a un segmentation fault dont je n'arrive pas à me défaire.
Je sais que je ne dépasse pas la ligne 139 de mon main.cpp, qui utilise ma méthode enVie sur un Monstre et un Personnage, cependant le Monstre fonctionne mais dès que le programme passe à l'instruction suivante qui est

Code:

---

joueur->enVie()

---

. le seg fault arrive :(
J'ai cette erreur depuis que je passe par un fichier pour initialiser mon Personnage (pour pouvoir sauvegarder mon personnage).
Si vous changez cette partie

Code:

---

1 2 3 4 5 6 7 8 9

/*Attaque* attaque[]={new Attaque(), //Ligne 123 du main.cpp   new Attaque("Gros coup",150,20,2,0),   new Attaque("Assez gros coup",300,50,5,0),   new Attaque("Enorme coup",500,100,10,5)};*/ Personnage* joueur; //joueur = new Personnage("Personnage",1000,1000,200,200,50,attaque,4);   //Chargement du jeu chargerJeu(joueur, &tour);

---

en

Code:

---

1 2 3 4 5 6 7 8 9 10

Attaque* attaque[]={new Attaque(), new Attaque("Gros coup",150,20,2,0), new Attaque("Assez gros coup",300,50,5,0), new Attaque("Enorme coup",500,100,10,5)}; Personnage* joueur; joueur = new Personnage("Personnage",1000,1000,200,200,50,attaque,4);   //Chargement du jeu //chargerJeu(joueur, &tour);

---

vous pourrez voir que le jeu fonctionne (noramalement).

Mon code étant composé de plusieurs fichier je l'ai mit en pièce jointe en tar.gz :)
Après l'avoir téléchargé il vous suffit de le décomprésser, de faire make et de le lancer avec ./fighter

J'ai déjà chercher sur internet mais il y a pas l'aire d'avoir de personne avec le même problème ou j'utilise les mauvais mots clef peut-être.
Merci d'avance à la personnage qui aura le courage de comprendre ce que j'ai fait et de trouver mon(mes) erreur(s) °-°

Avec les bons warnings de compilation, l'erreur est évidente. Sur ce dépôt se trouve des options pour gcc et clang par version de compilateur. L'idéal étant de prendre un *-debug_full_broken_abi pour le débug et toujours utiliser un fichier *-warnings. La compilation se fait avec g++ @le-fichier-choisie ...reste des options... (@ pour que le compilateur lise chaque ligne du fichier comme option de compilation).

Ensuite, le gros problème de ton code (je ne l'ai pas regardé, juste ce que tu as posté dans ton message) est l'utilisation à tort et à travers des pointeurs et de l'allocation dynamique. Il n'y a pas de raison que Attaque soit alloué dynamiquement par exemple. Je pense que Personnage est dans la même situation. Dans tous les cas, utilisation des pointeurs nus est source de problème. Il faut toujours privilégier les pointeurs intelligents tel que std::unique_ptr.

Pour le Makefile, en C++ on utilise les variables préfixés de CXX, et non C qui font référence au langage C.

Code:

---

1 2 3 4 5 6 7 8 9 10

CXX = g++ CXXFLAGS = # ici mettre l'option @fichier CPPFLAGS = # CPP pour C-PreProcessor pour -I et -D SRC = $(wildcard *.cpp) O_FILES = $(SRC:.cpp=.o)   fighter: $(O_FILES) $(CXX) -o $@ $(CXXFLAGS) $(LDFLAGS) $^ # je pense optionnel s'il y a un CC=$(CXX)   # ...

---

Merci pour ta réponse :)
Je programme en faisant un mélange de java et de C donc je ne sais pas si c'est très bien ^^
Tu me dis que l'utilisation de Personnage alloué dynamiquement n'est pas top. Mais le problème c'est que je le crée dans une fonction, ce qui fait que je dois retourner une adresse alloué dans le tas pour que je puisse garder les données. Enfin pour attaque je ne sais pas combien d'attaque aura mon personnage, je le lis seulement dans le fichier :)

Je n'arrive pas à utiliser les options pour le compilateur que tu m'as conseillé °-°

Bonjour,

En ayant

Code:

---

1 2	Personnage* joueur; chargerJeu( joueur, &tour );

---

Avec une fonction définie comme void chargerJeu( Personnage* joueur, int* tour );; donc passage d'une variable non initialisée (en plus c'est un pointeur!) le code ne va pas aller bien loin. Avec en plus des new dans le code, il doit y avoir d'autres erreurs. Et en effet le compilateur doit déjà émettre des warnings qui doivent tous être pris en compte.

Partir d'un mélange de Java et de C, est surement la pire des bases pour travailler en C++. Il va te falloir t'appuyer sur un cours C++ robuste.

Dalfab mon compilateur ne m'a dit aucune erreur et aucun warnings °-°

Pour préciser un peu la réponse de dalfab :

Tu passes à ta fonction un pointeur par copie. Donc, dans la fonction tu assigne une nouvelle valeur à ce paramètre, mais ce paramètre n'a rien à voir avec la variable en dehors qui a servi à l'initialiser...

https://cpp.developpez.com/faq/cpp/?...-a-ma-fonction

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

void f(Joueur *j) { j = new Joueur; // Ne modifie que le paramètre local }   void g(Joueur *&j) { j = new Joueur; // Modifie la variable passée à la fonction }   void h() { Joueur *j = nullptr; f(j); // j vaut toujours nullptr g(j); // j est modifié }

---

Attention, le code comme g n'est pas un bon exemple à suivre, c'est juste pour expliquer ton problème.

Citation:

---

Envoyé par adjokaido

je dois retourner une adresse alloué dans le tas pour que je puisse garder les données.

---

Si tu retournes vraiment une valeur, pourquoi la valeur de retour n'est pas utilisée/assignée ? C ou JAVA fonctionnent de la même manière là. :weird:

Effectivement, je suis passé par une fonction

Code:

---

1 2 3 4

Personnage* chargerPersonnage() { //Lecture dans le fichier return new Personnage(paramètre lu dans le fichier); }

---

Et mon problème est résolu °-°

Pourquoi new ? Pourquoi un pointeur ?

Code:

---

1 2 3 4

Personnage chargerPersonnage() { //Lecture dans le fichier return Personnage(paramètre lu dans le fichier); }

---

Il peut y avoir de bonnes réponses à mes questions qui justifient un pointeur (intelligent, mais je ne pense pas que tu aies déjà vu ça), mais par défaut, on devrait manipuler les objets directement, et réserver les pointeurs aux cas où ils sont justifiés.

Citation:

---

Pourquoi new ? Pourquoi un pointeur ?

---

Utiliser des pointeurs permet par la suite d'utiliser le

Code:

---

delete joueur

---

,et aussi de déplacer moins de données en retour de la fonction. Donc si on déplace moins de données le programme est plus rapide :)

Mais c'est vrai que j'ai pas vu les pointeurs intelligents, il faudrait que je me penche dessus avant d'aller plus loin.

Citation:

---

Envoyé par adjokaido

si on déplace moins de données le programme est plus rapide :)

---

Autant c'est pas faux dans l'absolu, autant dans ce cas c'est loin d'être vrai.
Un pointeur ça ajoute une indirection, et ici je ne vois absolument aucune raison à utiliser un pointeur, ni d'utiliser quelconque fonction, et non directement ton personnage sur la pile. Et la pile c'est mieux qu'un pointeur, la variable est directement accessible localement sans indirection. Et tu ne risques pas de créer une fuite mémoire.

Citation:

---

Envoyé par adjokaido

Utiliser des pointeurs permet par la suite d'utiliser le

Code:

---

delete joueur

---

,

---

C'est amusant, ce que tu décris comme une possibilité, je le décris comme une contrainte : Utiliser l'allocation dynamique impose à l'utilisateur de ta fonction d'utiliser un delete joueur; quelque-part, s'il ne veut pas avoir de fuites mémoire.

Citation:

---

Envoyé par adjokaido

et aussi de déplacer moins de données en retour de la fonction. Donc si on déplace moins de données le programme est plus rapide :)

---

Dans certains cas rares, ça peut effectivement avoir une importance. Mais c'est un compromis :
+ Peut-être plus rapide à déplacer
- Passe par une allocation dynamique, qui est une opération coûteuse
- Accès indirect aux données
- Fragmentation accrue de la mémoire

Au final :

• L'optimisation n'est pas évidente
• Si optimisation il y a, il s'agit d'une optimisation qui va à l'encontre de la simplicité du code. C'est à dire que c'est le genre d'optimisation à ne faire que si un benchmark montre :
  
  • Qu'il y a un problème de rapidité à résoudre
  • Que ce changement le résout bien

Là, comme on parle quand même d'une fonction qui va lire des choses sur le disque, je ne crois pas qu'on soit à ça près...

Citation:

---

Là, comme on parle quand même d'une fonction qui va lire des choses sur le disque

---

Elle lit quand même pas mal d'information é_é
Mais si je ne dois pas passer par un pointeur je ne peux plus utiliser le delete qui me libérais tout mes espaces alloué dans le tas.
Donc pour cela il faut que je remplace des parties de mon code, comme par exemple dans mon Personnage.h Attaque** m_attaque
Comment créer un tableau (liste) d'attaque qui ne soit pas alloué dynamiquement (dans le tas) ne sachant pas par avance combien d'attaque il aura.

Pour avoir un tableau de taille variable, il y aura forcément à un moment une allocation dynamique (sauf si tu sais borner le nombre d'éléments, et que tu es près à perdre de la place), mais ce n'est pas à toi de gérer manuellement cette allocation dynamique, elle peut être entièrement prise en charge par un std::vector, par exemple ton personnage pourra avoir un std::vector<Attaque> m_attaque.

Si les attaques sont une classe de base d'une hiérarchie polymorphe, il faudra alors passer par un pointeur supplémentaire, pour éviter le slicing. Par exemple un std::vector<std::unique_ptr<Attaque>> m_attaque

Citation:

---

Envoyé par JolyLoic

std::vector<std::unique_ptr<Attaque>> m_attaque

---

Si je comprend bien ce code me permet de créer un pointeur vers tableau dynamique ?
Mais si je veux ajouter un élément dans le tableau pas besoin d'un malloc/realloc du bon vieu C ?
Je peux directement faire ?

Code:

---

1 2	for (int i=0;i<nb_attaque;i++) m_attaque[i]=new Attaque();

---

J'ai vu en Java que l'on peut parcourir un tableau dynamique facilement dans ce style : for (Attaque a : m_attaque).
J'aimerais savoir si il y a un équivalent en c++ ?

Citation:

---

Envoyé par adjokaido

Si je comprend bien ce code me permet de créer un pointeur vers tableau dynamique ?

---

Non , c'est un tableau de pointeurs intelligents sur des Attaque

Citation:

---

Envoyé par adjokaido

Mais si je veux ajouter un élément dans le tableau pas besoin d'un malloc/realloc du bon vieu C ?
Je peux directement faire ?

Code:

---

1 2	for (int i=0;i<nb_attaque;i++) m_attaque[i]=new Attaque();

---

---

A la place tu utilises les capacités d'un vector donc ici à la place de ta boucle on ferait

Code:

---

1 2 3

m_attaque.resize(nb_attaque); for ( auto&& a : m_attaque ) a = std::make_unique<Attaque>();

---

Citation:

---

Envoyé par adjokaido

J'ai vu en Java que l'on peut parcourir un tableau dynamique facilement dans ce style : for (Attaque a : m_attaque).
J'aimerais savoir si il y a un équivalent en c++ ?

---

L'équivalent c'est for (auto&& a : m_attaque) a->attaquer(); et donc ici a sera du type std::unique_ptr<Attaque>&.

Citation:

---

Envoyé par dalfab

L'équivalent c'est for (auto&& a : m_attaque) a->attaquer(); et donc ici a sera du type std::unique_ptr<Attaque>&.

---

Hmm je pense que si tu fais un auto&& tu déplaces chaque élément de m_attaque vers un temporaire, vidant au passage ton m_attaque du coup.
Il vaudrait mieux faire un simple auto& ou const auto&.

En fait auto&& n'est pas une r-référence mais est une universal-référence. Elle permet de parcourir les collections dans les rares cas où l'itérateur retourne une r-référence (par exemple std::vector<bool>::iterator), et fournit une l-référence dans les autres cas. Il y a un article détaillé de scott meyer sur cela.

Citation:

---

Envoyé par dalfab

En fait auto&& n'est pas une r-référence mais est une universal-référence.

---

Il y a désormais un terme officiel pour ça, c'est forwarding reference. Et Scott Meyer est d'accord pour remplacer son appellation par celle-ci, plus précise.

Ha effectivement forward reference ça me parle, mais en dehors des templates un peu lourds j'aurais jamais fait le rapprochement.
Je trouve ça un peu confusant dans le cas d'une simple boucle comme là par exemple, mais ça doit être utile dans d'autres cas je suppose (autre que les paramètres template).
:merci: