Bonjour, voici mon code source. 

#include <iostream>
#include <string>
#include "Nain.h"
#include "Elf.h"
#include "Sorcier.h"

using namespace std;

int main()
{
    string nomPlayer;
    int choixPlayer;
    int commencer;



    cout << "Boujour! Qu'elle est votre nom?" << endl;
    cin >> nomPlayer;

    cout << "Tres bien, " << nomPlayer << ". " << endl;

    cout << "Maintenant choisissez votre type de hero. Vous avez le choix entre:" << endl;

    cout << "Un nain(1)" << endl;

    cout << "Un elf(2)" << endl;

    cout << "Un sorcier(3)" << endl;

    cin >> choixPlayer;

    if(choixPlayer == 1)
    {
        cout << "Vous avez choisi un nain. " << endl;

        Nain player;

    }
    else if (choixPlayer == 2)
    {
        cout << "Vous avez choisi un elf. " << endl;

        Elf player;

    }
    else if(choixPlayer == 3)
    {
        cout << "Vous avez choisi un sorcier. " << endl;

        Sorcier player;
    }



    return 0;
}

Je voudrais savoir comment je pourais utiliser le player pour continuer l'histoire sans devoir réécrire le même scénario trois fois pour chaque personnage choisis. Merci d'avance!

-
Edité par OlivierLebel2004 3 février 2019 à 17:00:32

Bonjour,

Pour insérer du code, il faut utiliser le bouton [</>]. Peux-tu corriger ton post s'il te plait.
Sinon pour répondre à ta question. Ce que tu souhaites utiliser c'est un objet qui est peut-être un Elfe, peut-être un Nain ou peut-être un Sorcier. Quel type de variable pourrait être cela? Un pointeur (de préférence intelligent) ou une référence vers une classe qui serait une Base de ces trois types fonctionnerait, un méta-type fonctionnerait aussi mais tu n'a certainement pas encore appris cela. C'est structurellement pas ce qu'il faire mais voilà ce que cela donnerait :

std::unique_ptr<Personnage> choisirPersonnage( int choixPlayer ) { // retourne un pointeur intelligent sur un Personnage
    std::unique_ptr<Personnage>  personnage_choisi;
    if ( choixPlayer == 1 ) {
        std::cout << "Vous avez choisi un nain." << std::endl;
        personnage_choisi = std::make_unique<Nain>();
    }
    else if ( choixPlayer == 2 ) {
        std::cout << "Vous avez choisi un elfe." << std::endl;
        personnage_choisi = std::make_unique<Elf>();
    }
    else if ( choixPlayer == 3 ) {
        std::cout << "Vous avez choisi un sorcier." << std::endl;
        personnage_choisi = std::make_unique<Sorcier>();
    }
    else
        return {};
    Personnage  &player = *personnage_choisi; // ici on a un objet
    ... ... // 'player' qu'il soit Nain, Elfe ou Sorcier
    return  personnage_choisi; // mais ne jamais ou oublier qu'un pointeur intelligent en est le propriétaire
}

Merci d'avoir corrigé ton post.

Pour en apprendre sur les pointeurs intelligents (smart pointers) : certainement pas dans le cours d'OpenClassrooms. Sur internet tu peux te former en français sur le cours de Zeste de Savoir, ou celui de Guillaume Belz programmez_avec_le_langage_c++. Sinon tu as toute la littérature où il faut bien vérifier les indications "C++ moderne" ou "C++11 ou ultérieurs" pour apprendre le C++ récent qui a eu une évolution importante en 2011 (documentation essentiellement en Anglais.)

Merci beaucoup Dalfab!!

salut, quand j'essaye ton code, sa me met une erreur sur le int de la première ligne

pourrais tu m'aider svp

est-ce que c'est comme sa que je dois mettre mon code??

#include <iostream>
#include <memory>
#include <string>
#include "Nain.h"
#include "Elf.h"
#include "Sorcier.h"


using namespace std;

int main()
{
    std::unique_ptr<Personnage> choisirPersonnage( int choixPlayer ) {
    std::unique_ptr<Personnage>  personnage_choisi;
    if ( choixPlayer == 1 ) {
        std::cout << "Vous avez choisi un nain." << std::endl;
        personnage_choisi = std::make_unique<Nain>();
    }
    else if ( choixPlayer == 2 ) {
        std::cout << "Vous avez choisi un elfe." << std::endl;
        personnage_choisi = std::make_unique<Elf>();
    }
    else if ( choixPlayer == 3 ) {
        std::cout << "Vous avez choisi un sorcier." << std::endl;
        personnage_choisi = std::make_unique<Sorcier>();
    }
    else
        return {};
    Personnage  &player = *personnage_choisi;

    return  personnage_choisi;
}



    return 0;
}

merci

ou alors, une lambda.

---

Bon, c'est l'heure de la récré, quelques amusements avec une fabrique, des pointeurs intelligents, des templates, blabla

#include <iostream>
#include <functional>
#include <map>
#include <memory>


class Personnage {
	protected:
		std::string m_nom;
	public: 
		Personnage(const std::string & nom) 
			: m_nom {nom}
		{}
		virtual std::string toString() = 0;
		virtual ~Personnage()  {}
	
		using Constructeur =  
			std::function<std::unique_ptr<Personnage>(const std::string &)>;
};

// --------------------------------------------------------

class Nain : public Personnage {
	public: 
		Nain(const std::string & nom) 
			: Personnage{nom}
		{}
		std::string toString() {
			return m_nom + " le nain";
		}
};

class Robot : public Personnage {
	public: 
		Robot(const std::string & nom) 
			: Personnage{nom}
		{}
		std::string toString() {
			return m_nom + " le robot";
		}
};

// -------------------------------------------------------------

class Fabrique {

	private:
		std::map<std::string, Personnage::Constructeur> m_constructeurs;
		
	public:
		void enregistrer(const std::string &type, 
						Personnage::Constructeur constructeur)
	{
		m_constructeurs[type] = constructeur;
	}
	
	std::unique_ptr<Personnage> fabriquer(const std::string &type, 
						const std::string &nom) {
		// exception si absent
		return m_constructeurs.at(type)(nom);
	} 
					
};


template <class P> 
std::unique_ptr<P> Producteur(const std::string &nom) {
		return std::make_unique<P>(nom); 
}
	
int main()
{
	Fabrique f;
	f.enregistrer("nain", Producteur<Nain>); 
	f.enregistrer("robot", Producteur<Robot>);
	
	std::unique_ptr<Personnage> 
		n = f.fabriquer("nain", "gérard"),
		r = f.fabriquer("robot", "toto");

	std::cout << n -> toString() << std::endl;
	std::cout << r -> toString() << std::endl;
	return 0;
}

Explication : dans la fabrique, on enregistre des producteurs qui construisent des objets de différents types.

Pour allouer un nouveau personnage, on le demande à la fabrique en lui indiquant le type et le nom, et ça fait faire le boulot par le bon fabricant.

PS: il y avait des lambdas à la place des Producteur, mais bon, vu que les lambdas se ressemblaient, c'est mieux avec une fonction template.

-
Edité par michelbillaud 7 février 2019 à 14:40:31