Discussion :

[ternel]

les opérateurs, c'est assez simple, à la base.
Pour toute expression a # b, soit il existe une fonction operator#(A a, B b), soit ca ne compile pas.
Pour les types de bases, tout se passe comme si c'était vrai
Pour les classes, c'est à toi de les fournir.


Dans le cas de les opérateurs de manipulation de flux, il y a (plus ou moins) par défaut les operateurs pour les types primitifs (entiers, pointeurs) et std::string.

Pour toutes tes classes, c'est à toi de définir.
Souvent les classes ont une méthode publique "tostring() const", "operator std::string() const", "print() const", "serialize() const", et l'operateur se contente de l'appeler.

Est-ce que la déclaration de ton afficheinfo est bien:
std::string enemy::afficherinfo() const

[devdeb91]

non mon affiche info est un void enemy::afficherinfo()a la base je veut juste avoir une liste d'objet et que des que je suis sur un objet je puisse utiliser sa méthode

[ternel]

Si tu veux tu peux avoir un truc pas beau du type

void enemy::afficheinfo() {
std::cout<<m_nom;
}

mais dans ce cas, doit-tu mettre un std::endl?
Que faire si tu veux afficher dans le flux d'erreur?
Comment utiliser la meme fonction pour afficher dans un formulaire html?
et dans une base de donnée?

Ce n'est pas à enemy de gérer son affichage, mais à l'afficheur de se poser la question de comment afficher un enemy.

un flux de sortie peut être n'importe quoi: un fichier, une socket, un écran, un shader pour écrire sur la pancarte affichée dans mon jeu, une base de donnée, un autre objet, un composteur de ticket de bus…

[devdeb91]

je pense qu'il y a confusion donc voila ma class enemy

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
#ifndef ENEMY_H_INCLUDED
#define ENEMY_H_INCLUDED
#include <iostream>
#include <string>
#include "personnage.h"
 
class enemy : public personnage
{
private:
 
    std::string m_type;
    int m_restonnerre;
    int m_resglace;
    int m_resfeu;
    int m_reseau;
    int m_ressacre;
 
public:
 
    enemy(std::string nom, int hp, int mp, std::string type, int xp, int argent);
    ~enemy();
    void afficherinfo();
    void IA(personnage &cible);
};
 
 
#endif // ENEMY_H_INCLUDED

je veut faire une liste chainée de enemy donc std::list<enemy> ennemiepuis je le remplie avec une info pour générer un maillon

Code :

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

ennemi.push_back(enemy("guepe", 100, 0, "poison", 10, 5));

une fois cela je veut parcourir la chaine et par exemple pouvoir utiliser une methode de la class enemy avec l'enemy dans la chaine ici sa serai guepe qui utilise admettons afficherinfo()

c'est pour cela que j'ai essayer cela

Code :

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

1
2
3
4
5
 std::list<enemy>::iterator it1;
               for(it1 = ennemi.begin(); it1 != ennemi.end(); it1++)
               {
                   std::cout << *it1 << std::endl;
               }

suite a un exemple que j'avais essayer vue plus tot qui etait sa

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
 std::list<int> mylist;
  std::list<int>::iterator it1,it2;
 
  // set some values:
  for (int i=1; i<10; ++i) mylist.push_back(i*10);
 
                              // 10 20 30 40 50 60 70 80 90
  it1 = it2 = mylist.begin(); // ^^
  std::cout << *it2 << std::endl;
  advance (it2,6);
  std::cout << *it2 << std::endl;       // ^                 ^
  ++it1;                      //    ^              ^
 
std::cout << *it1 << std::endl;
  it1 = mylist.erase (it1);   // 10 30 40 50 60 70 80 90
  std::cout << *it1 << std::endl;                            //    ^           ^
 
  it2 = mylist.erase (it2);   // 10 30 40 50 60 80 90
                              //    ^           ^
 
  ++it1;                      //       ^        ^
  --it2;                      //       ^     ^
 
  mylist.erase (it1,it2);
 
it1 = mylist.begin();
  advance (it1, 4);
  std::cout << *it1 << std::endl;
  mylist.erase(it1);        // 10 30 60 80 90
                              //        ^
 
  std::cout << "mylist contains:";
  for (it1=mylist.begin(); it1!=mylist.end(); ++it1)
    std::cout << ' ' << *it1;
  std::cout << '\n';

[Médinoc]

Normalement, pour un opérateur << et un enemy::afficheinfo(), je dirais que tu as deux solutions:

• std::string enemy::afficherinfo() const qui retourne les infos à afficher dans une string.
• void enemy::afficherinfo(ostream &) const qui envoie directement les infos à afficher.

Code C++ :

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
class UneClasse {
public:
	int toto;
	std::string affiche() const {
		std::ostringstream oss;
		oss << "UneClasse(toto=" << toto << ")";
		return oss.str();
	}
};
 
std::ostream& operator<<(std::ostream& os, UneClasse const &obj) {
	return os << obj.affiche();
}
 
class UneAutreClasse {
public:
	int tata;
	void affiche(std::ostream& os) const {
		os << "UneAutreClasse(tata=" << tata << ")";
	}
};
 
std::ostream& operator<<(std::ostream& os, UneAutreClasse const &obj) {
	obj.affiche(os);
	return os;
}

Généralement, j'utilise la seconde solution.

[ternel]

Code :

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

1
2
3
4
5
 std::list<enemy>::iterator it1;
               for(it1 = ennemi.begin(); it1 != ennemi.end(); it1++)
               {
                   std::cout << *it1 << std::endl;
               }

Ceci est une boucle "itérante" sur ennemi (qui devrait se nommer ennemis, ou ennemies, en anglais) qui donne chaque enemy de la liste à cout.

toi tu veux surement

Code :

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

1
2
3
for(std::list<enemy>::iterator it = ennemi.begin(); it != ennemi.end(); ++it) {
    it->afficheinfo();
}

Pour les détails, mieux vaut utiliser ++iterator.
déclarer l'iterateur dans le for permet de réduire sa portée de définition (et donc réutiliser son nom).
en C++11, tu écrirais for(const enemy& e : ennemis) e.afficheinfo(); voire for(auto const& e : ennemis) e.afficheinfo();

[devdeb91]

Normalement, pour un opérateur << et un enemy::afficheinfo(), je dirais que tu as deux solutions:

• std::string enemy::afficherinfo() const qui retourne les infos à afficher dans une string.
• void enemy::afficherinfo(ostream &) const qui envoie directement les infos à afficher.

Code C++ :

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
class UneClasse {
public:
	int toto;
	std::string affiche() const {
		std::ostringstream oss;
		oss << "UneClasse(toto=" << toto << ")";
		return oss.str();
	}
};
 
std::ostream& operator<<(std::ostream& os, UneClasse const &obj) {
	return os << obj.affiche();
}
 
class UneAutreClasse {
public:
	int tata;
	void affiche(ostream& os) const {
		os << "UneAutreClasse(tata=" << tata << ")";
	}
};
 
std::ostream& operator<<(std::ostream& os, UneAutreClasse const &obj) {
	obj.affiche(os);
	return os;
}

Généralement, j'utilise la seconde solution.

est ce vraiment obliger de modifier la methode car celle ci peut etre appeler n'importe ou et n'importe quand sans forcement avoir l'operateur <<

[Médinoc]

Ben tu peux toujours la surcharger ou mettre un paramètre par défaut:

Code C++ :

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

1
2
3
4
5
6
7
class UneAutreClasse {
public:
	int tata;
	void affiche(std::ostream& os = std::cout) const {
		os << "UneAutreClasse(tata=" << tata << ")";
	}
};

[devdeb91]

Code :

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

1
2
3
4
5
 std::list<enemy>::iterator it1;
               for(it1 = ennemi.begin(); it1 != ennemi.end(); it1++)
               {
                   std::cout << *it1 << std::endl;
               }

Ceci est une boucle "itérante" sur ennemi (qui devrait se nommer ennemis, ou ennemies, en anglais) qui donne chaque enemy de la liste à cout.

toi tu veux surement

Code :

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

1
2
3
for(std::list<enemy>::iterator it = ennemi.begin(); it != ennemi.end(); ++it) {
    it->afficheinfo();
}

Pour les détails, mieux vaut utiliser ++iterator.
déclarer l'iterateur dans le for permet de réduire sa portée de définition (et donc réutiliser son nom).
en C++11, tu écrirais for(const enemy& e : ennemis) e.afficheinfo(); voire for(auto const& e : ennemis) e.afficheinfo();

merci beaucoup c'etait exactement sa que je voulais j'avais essayer avec it.afficherinfo() mais celui ci refuser.

mais pourquoi utiliser la fleche car si je ne me trompe pas celle ci et du referencement non ?

[devdeb91]

voici un bout de code

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
for(it = ennemi.begin(); it != ennemi.end(); ++it)
    {
    //it->afficherinfo();
    bool vivant = it->est_vivant();
    if(vivant == false)
    {
        it = ennemi.erase(it);
        nbmonstre--;
    }
    else
        it->IA(tidus);
    }

quand on fait it = ennemi.erase(it); supprime t'il seulement le maillon ou il detruit l'objet en question avec ?

[ternel]

it est un iterateur, seul *it est la valeur référencée
par analogie, -> a été surchargée pour permettre d'accéder aux membres de la valeur.

Pour le erase, la valeur est retirée du conteneur, et ainsi détruite.
Si ta liste est une liste de pointeur, le pointeur est détruit, c'est à dire la valeur (adresse) est oubliée, mais pas l'objet éventuellement pointé.
Dans ton cas (std::list<enemy>), l'enemy est retiré et détruit.

[devdeb91]

ok merci pour ce apport d'information sa m'aide beaucoup car je ne voulais pas avoir de perte mémoire ou autre problème du fait que l'objet reste présent malgré la suppression du maillon

[ternel]

Autre précision, si un itérateur propose la même syntaxe qu'un pointeur, ce n'en est pas un pour autant. C'est un objet d'un type précis, défini par l'implémentation de la STL que tu utilises.
Son type est "template <typename T> std::list<T>::iterator", qui est un typedef vers un type arbitraire qui satisfait la norme.