Bonsoir

Je dispose de 3 fichiers :

fichier main :

#include <iostream>
#include "Vehicule.h"

using namespace std;

int main()
{   //On utilise les voitures et les motos
    vector<Vehicule*> listeVehicules;
    listeVehicules.push_back(new Voiture(15000, 5));//J'ajoute à ma collection de véhicules une voiture
                                                    //Valant 15000 euros et ayant 5 portes
    listeVehicules.push_back(new Voiture(12000, 3));
    listeVehicules.push_back(new Moto(2000, 212.5));//Une moto à 2000 euros allant à 212.5 km/h

    listeVehicules[0]->affiche();//On affiche les informations de la première voiture

    listeVehicules[2]->affiche();//Et celles de la moto

    for(int i(0); i<listeVehicules.size(); ++i)
    {
        delete listeVehicules[i];  //On libère la i-ème case mémoire allouée
        listeVehicules[i] = 0;  //On met le pointeur à 0 pour éviter les soucis
    }

    return 0;
}

fichier Vehicule.cpp :

#include "Vehicule.h"
#include <iostream>

using namespace std;

Vehicule::Vehicule(int prix)
    :m_prix(prix)
{}

void Vehicule::affiche() const
{
    cout << "Ceci est un vehicule coutant " << m_prix << " euros." << endl;
}

Vehicule::~Vehicule() //Même si le destructeur ne fait rien, on doit le mettre !
{}

Voiture::Voiture(int prix, int portes)
    :Vehicule(prix), m_portes(portes)
{}

void Voiture::affiche() const
{
    cout << "Ceci est une voiture avec " << m_portes << " portes et coutant " << m_prix << " euros." << endl;
}

Voiture::~Voiture()
{}

Moto::Moto(int prix, double vitesseMax)
    :Vehicule(prix), m_vitesse(vitesseMax)
{}

void Moto::affiche() const
{
    cout << "Ceci est une moto allant a " << m_vitesse << " km/h et coutant " << m_prix << " euros." << endl;
}

Moto::~Moto()
{}

Camion::Camion(int prix, double poidsTransportable)
    :Vehicule(prix), m_poidsTransportableMax(poidsTransportable)
{}

void Camion::affiche() const
{
    cout << "Ceci est un camion dont le poids transportable maximal est de " << m_poidsTransportableMax << "." << endl;
}

Camion::~Camion()
{}

void Vehicule::afficheAnneeDeFabrication() const
{
    cout << "Le vehicule a ete fabrique durant l'annee : " << m_anneeDeFabrication << "." << endl;
}
//////////////////////////////////////////////////////////////////////////////////////
//
//Garage::ajouterVehicule(Vehicule, int prix, (int or double)caracteristique) const
//{
//    typeDeVehicule.push_back(new Vehicule(prix, caracteristique));
//}

Vehicule.h :

#ifndef VEHICULE_H_INCLUDED
#define VEHICULE_H_INCLUDED

#include <vector>

class Vehicule
{
    public:
//    void affiche() const;  //Affiche une description du Vehicule
    Vehicule(int prix);
    virtual void affiche() const;  //Affiche une description du Vehicule
    virtual ~Vehicule();//le destructeur est aussi virtuel afin de détruire le bon
                        //constructeur avec le delete
    void afficheAnneeDeFabrication() const;

    protected:
    int m_prix;  //Chaque véhicule a un prix
    int m_anneeDeFabrication;
};

class Voiture : public Vehicule //Une Voiture EST UN Vehicule
{
    public:
//    void affiche() const;
    Voiture(int prix, int portes);
    virtual void affiche() const;//virtual pas obligatoire grâce à l'héritage
    virtual ~Voiture();

    private:
    int m_portes;  //Le nombre de portes de la voiture
};

class Moto : public Vehicule  //Une Moto EST UN Vehicule
{
    public:
//    void affiche() const;
    Moto(int prix, double vitesseMax);
    virtual void affiche() const;//virtual pas obligatoire grâce à l'héritage
    virtual ~Moto();

    private:
    double m_vitesse;  //La vitesse maximale de la moto
};

class Camion : public Vehicule  //Un camion EST UN Vehicule
{
    public:
    Camion(int prix, double poidsTransportable);
    virtual void affiche() const;//virtual pas obligatoire grâce à l'héritage
    virtual ~Camion();

    private:
    double m_poidsTransportableMax;  //Le poids que le camion peut transporter
};

class Garage
{
    public:
    Garage();
    //ajouterVehicule(int prix, (int or double)caracteristique) const;//la caracteristique peut être double ou int
   
    ~Garage();

    private:
    std::vector<Vehicule*> m_listeDeVehicules;
};

#endif // VEHICULE_H_INCLUDED

Ce code contient des classes représentants différents genre de véhicule avec pour point commun d'avoir leur prix de type int en premier argument dans leur constructeur mais ayant pour certains un deuxième argument aussi de type int et pour d'autre de type double. Par exemple les voitures ont un type int en deuxième argument représentant leur nombre de porte tandis que les motos ont un type double en deuxième argument représentant leur vitesse maximale. Dans le cadre d'un entrainement au polymorphisme, je cherche à créer une classe garage avec à l'intérieur une fonction qui permet d'ajouter un nouveau véhicule à l'aide d'un tableau dynamique. Le problème est que je bloque dans la manière de créer une fonction pouvant à la fois prendre en argument une variable de type int ou de type double. Est-ce possible de créer une fonction qui puisse prendre une variable de type int ou double en argument ?

Cordialement

-
Edité par 1Stark 8 juillet 2023 à 19:24:24

> Je cherche à créer une classe garage avec à l'intérieur une fonction qui permet d'ajouter un nouveau véhicule à l'aide d'un tableau dynamique. Le problème est que je bloque dans la manière de créer une fonction pouvant à la fois prendre en argument une variable de type int ou de type double

Que vas-tu faire lorsque la fonction va prendre un double ? Instancier une Moto ou un Camion ?

Ajouter un nouveau véhicule ne requière aucunement d'avoir une fonction qui prend un prix et une caractéristique, mais une fonction qui prend un Véhicule.

Le garage n'a aucunement besoin de savoir les caractéristiques d'un véhicule. Et si on essaye d'accéder à des caractéristiques qui sont pas prévus par la classe de base, le polymorphisme dynamique est une mauvaise approche.

Au passage, la classe Vehicule étant copiable, tu vas avoir des surprises. Le polymorphisme se marie très mal avec la copie.

Concernant l'allocation dynamique et gestion des destructions à la main, on ne fait plus ça depuis plus de 10 ans, on passe par std::unique_ptr qui le gère pour nous (+ std::make_unique). Les boucles sur indices sont aussi beaucoup moins bien que celle sur intervalle.

On voit clairement les ravages du cours d'OC avec des exemples qui virent facilement sur une mauvaise utilisation de l'OO. Ici, on recommande plutôt le cours sur Zeste de Savoir (la version bêta est plus complète, le livre aussi) ou C++ Primer 5th edition. De Lippmann.

Pour le pourquoi: https://openclassrooms.com/forum/sujet/mooc-c?page=7#message-86545267

-
Edité par jo_link_noir 8 juillet 2023 à 20:35:50