Discussion :

[Ioro1]

Bonjour à tous,

Dans un programme, j'essaie de mettre en place le polymorphisme mais je suis pas sûr d'avoir tout bien compris.

En gros, ce programme doit gérer différents type de Vehicule d'un garage, la classe mère. Après j'ai des classes filles, voiture, moto, vélo, etc...

J'aimerais au démarrage, charger un fichier de config, qui indique quels véhicules sont dans le garage et leur prix. Donc par exemple un fichier txt qui contient :
Voiture:2000
Velo:100
Moto:1500

Je récupère ces infos dans un map et ensuite, j'aimerai à partir de ce map, créer les objets contenu dans mon garage. Donc appeler une méthode CreerVehicule(std::string, int)

Je ne sais pas si c'est possible et ni comment le faire si c'est le cas ^^

Une idée?

Pour info, j'ai quelques notions en c++, je ne suis pas un expert.

D'avance, merci.

Ioro

[Bousk]

Salut,

oui c'est une idée, c'est le principe de ce qu'on appelle une factory (ou fabrique en français).

[koala01]

Salut, et bienvenue sur le forum.

La première règle à comprendre et à appliquer, lorsque l'on pose une question sur un forum technique comme celui-ci est de nous aider à t'aider.

Il faut en effet bien comprendre que l'on ne regarde pas ton écran au dessus de ton épaule, et que l'on sait encore moins facilement imaginer ce qui peut te passer par la tête, simplement parce que les rares détenteurs d'une boule de crystal éprouvent régulièrement des problèmes avec son utilisation

De plus, il faut comprendre que, si l'on est généralement plein de bonne volonté, nous éviterons de te donner des solutions "toutes faites", parce que ce serait un bien mauvais service à te rendre. On préféreras mettre en oeuvre le fameux principe du

Donnes un poisson à quelqu'un, il mangera pendant un jour. Apprends lui à pêcher, et il mangera toute sa vie

en te donnant les explications qui te manquent pour résoudre (par toi-même) le problème auquel tu es confronté.

Mais, encore une fois, il est important de se rendre compte que l'on n'a aucun moyen de regarder par dessus ton épaule pour voir le code que tu as écrit.

L'idéal, quand tu viens poser une question technique, est donc de systématiquement nous donner un peu de code à partir duquel nous pourrons travailler. Tu auras surement compris que ce code devrait -- dans la mesure du possible -- correspondre autant que faire se peut à la situation dans laquelle tu te trouve au moment de poser ta question.

Mais, de manière générale, nous nous contenterons de ce que l'on appelle entre nous un "code minimum compilable" (si tant est qu'il te soit possible d'atteindre ce stade) susceptible de reproduire la situation dans laquelle tu te trouve.

Cela signifie que l'on n'a pas forcément besoin de connaitre l'intégralité de ton code, mais que l'on doit au moins disposer de l'ensemble des éléments qui nous permettront de nous faire une idée précise du problème (et, partant, de la solution plausible à te proposer )

Par facilité, nous te demanderons également de faire de préférence un copier / coller de ton code en le plaçant en les balises [ CODE ] et [ / CODE ] (sans les espaces), qui peuvent être ajoutées automatiquement en appuyant sur le bouton en forme de # qui se trouve au dessus de la zone d'édition de ton message.

De cette manière, le code sera correctement représenté, en respectant l'indentation de ton code d'origine, et en proposant même une coloration syntaxique plus qu'utile, et nous serons nous-même en mesure de le copier et de le coller de notre coté pour essayer de le compiler

Dans le cas qui nous intéresse aujourd'hui, j'aimerais que tu nous présente, ad minima :

1. la définition de ta classe vehicule, ainsi que l'implémentation des différentes fonctions dont tu l'a fournie
2. la définition d'une des classes spécifique (voiture, vélo, camion ou autre), ainsi que l'implémentation des fonctions qu'elle contient
3. la définition des autres classes (qui n'héritent pas de véhicule, telle que garage ou autre), ainsi que l'implémentation des fonctions qu'elles contiennent.

Cela devrait nous permettre de nous faire une idée relativement précise de ta situation actuelle, et de nous diriger vers les explications les plus adaptée

Merci de ta compréhension

[Ioro1]

Alors j'ai lu le lien du site mais j'ai pas tout compris comment l'implémenter.

Vous pouvez me donner un exemple de factory?

Merci.

Ioro

EDIT : ne pas tenir compte de ce message On reprend du début!

[Ioro1]

Alors voici le main :

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
#include "Vehicule.h"
#include "Garage.h"
 
int main(int argc, char *argv[])
{
	Garage g;
	std::map<std::string, int> garageConf;
	garageConf = g.LoadGarage("Config.ini");
 
	for (std::map<std::string, int>::iterator it = garageConf.begin(); it != garageConf.end(); it++)
	{
		// Créer les véhicules en fonction du type soit de it->first
	}
 
 
}

Garage.h

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
#pragma once
 
#include <string>
#include <map>
#include <fstream>
 
class Garage
{
public:
	Garage();
	~Garage();
	std::map<std::string, int> LoadGarage(std::string);
};

garage.cpp

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
36
37
38
39
40
#include "Garage.h"
 
Garage::Garage()
{
}
 
 
Garage::~Garage()
{
}
 
std::map<std::string, int> Garage::LoadGarage(std::string iniFile)
{
	std::ifstream setupGarage;
	setupGarage.open(iniFile, std::ios::in);
	std::map<std::string, int> garageConf;
 
	if (setupGarage)
	{
		std::string sContent = ("");
 
		while (getline(setupGarage, sContent))
		{
			std::string vehiculeType = ("");
			std::string price = ("");
			std::size_t pos = sContent.find(":");
			vehiculeType = sContent.substr(0, pos);
			price = sContent.substr(pos + 1);
			garageConf.insert(std::pair<std::string, int>(vehiculeType, stoi(price)));
		}
 
		setupGarage.close();
	}
	else
	{
		//erreur
	}
 
	return garageConf;
}

Vehicule.h

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
#pragma once
 
#include <string>
#include <map>
#include <fstream>
 
class Vehicule
{
public:
	Vehicule();
	~Vehicule();
 
	virtual void CreateVehicule(std::string, int) const;
 
 
private:
	int m_prix;
	std::string m_modele;
};

Vehicule.cpp

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#include "Vehicule.h"
 
 
 
Vehicule::Vehicule()
{
}
 
 
Vehicule::~Vehicule()
{
}

Et une classe fille de Vehicule, Moto par exemple :
Moto.h

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#pragma once
#include "Vehicule.h"
class Moto :
	public Vehicule
{
public:
	Moto();
	~Moto();
 
	virtual void CreateVehicule(std::string, int) const;
 
private:
 
};

Moto.cpp :

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
#include "Moto.h"
 
Moto::Moto()
{
}
 
 
Moto::~Moto()
{
}
 
void Moto::CreateVehicule(std::string type, int prix) const
{
 
}

Voilà, les méthodes sont vides en fait parce que je ne sais pas quoi mettre dedans pour créer mes objets.

Si j'ai bien compris le polymorphisme, je crée d'abord mes objets :

Code :

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

1
2
3
Garage g;
Vehicule v;
Moto m;

et ensuite j'applique des méthodes "polymorphiques".

Code :

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

1
2
3
4
 
v.CreateVehicule
m.CreateVehicule
...

Avec par exemple :

Code :

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

1
2
3
4
void Moto::CreateVehicule(std::string, int)
{
std::cout << "Je suis une Moto" std::endl;
}

Mais j'aimerai créer les objets en fonction de ce qu'il y a dans mon fichier et là je vois pas trop comment faire.

J'ai essayé le factory, avec le lien du site, mais comme je disais, j'ai pas bien compris son implémentation.

[Bktero]

Déjà, tu pourrais te simplifier la vie en ne définissant pas des fonctions membres qui sont vides. A la limite, tu peux utiliser = default. Voir https://en.cppreference.com/w/cpp/la...lt_constructor

Ensuite, tu peux parcourir bien plus simplement que cela ta map, avec auto ou un range-based for loop (voir https://en.cppreference.com/w/cpp/language/range-for).

Ensuite, il faut réfléchir à ce que tu souhaites faire. Tu peux ne souhaites que chaque classe possède une méthode pour se créer, tu cherches à faire une fonction qui sache créer plusieurs types. Car comment créer les bons objets alors que tu ne les connais pas encore ? Comme cela a été dit, il te faut une factory. Par exemple https://www.geeksforgeeks.org/design...actory-method/

Un code basique (et un peu cracra) ressemblerait à ça :

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
#include <iostream>
 
struct Vehicule {
    virtual void start() = 0;
};
 
struct Car : Vehicule {
    void start() override { std::cout << "car started\n"; }
};
 
struct Bike : Vehicule {
    void start() override { std::cout << "bike started\n"; }
};
 
Vehicule* create(std::string what) {
    if (what == "car") return new Car;
    if (what == "bike") return new Bike;
    return nullptr;
}
 
int main() { 	
    auto car = create("car");
    car->start();
    auto bike = create("bike");
    bike->start();
}