Programmation orientée objet → Vos premières classes

Vos premières classes

Cette série d’exercices contribuent à d’évaluer vos capacités à concevoir des objets, à les manipuler et à les comparer entre eux. Vous serez amené à créer des classes, modifier les attributs, et surcharger les opérateurs de comparaison pour comparer les instances de vos classes. Prenez le temps de bien comprendre les exigences de chaque exercice et de planifier la structure de vos classes et méthodes avant de commencer d’écrire du code.

Les animaux

Créez une classe Animal avec les attributs nom (str), age (int), poids (float) et taille (float).
Surchargez les opérateurs de comparaison suivants pour comparer les instances d’Animal entre elles :
- Inférieur : Un animal est considéré comme inférieur à un autre si son poids est inférieur.
Dans un tableau, placez plusieurs instances d’Animal. Appelez la fonction min() sur ce tableau, puis afficher le nom de l’animal résultat. Testez également la fonction max().
Appelez la fonction print() sur une instance d’Animal.

Les adresses

Créez une classe Adresse avec les attributs rue (str), numero (int), code_postal (int) et ville (str).
Surchargez les opérateurs de comparaison suivants :
1. Conversion en string : pour afficher les informations d’une adresse sous la forme “Numéro Rue, Code Postal Ville”.
2. Égalité : Une adresse est considérée comme identique à une autre si la rue, le numéro, le code postal et la ville sont identiques.
Créez quelques instances de Adresse et testez les opérateurs de comparaison surchargés.
Appelez la fonction print() sur une instance d’Adresse.

Les personnes

Créez une classe Personne avec les attributs prenom (str), nom (str), age (int) et adresse (instance de la classe Adresse).
Surchargez les opérateurs de comparaison suivants :
1. Conversion en string : pour afficher les informations d’une adresse sous la forme “prénom, nom habitant à adresse”
2. Égalité : Deux personnes sont égales si leur prénom, nom, âge et adresse sont identiques.
Créez quelques instances de Personne et testez les opérateurs de comparaison surchargés.
Appelez la fonction print() sur une instance de Personne.

Correction: Animal

Python

class Animal:
    def __init__(self, nom, age, poids, taille):
        self.nom = nom
        self.age = age
        self.poids = poids
        self.taille = taille

    def __lt__(self, other):
        return self.poids < other.poids

# Création d'instances d'Animal
animal1 = Animal("Lion", 5, 190.5, 1.2)
animal2 = Animal("Tigre", 4, 170.3, 1.1)
animal3 = Animal("Ours", 7, 300.0, 1.8)

# Placement des instances dans un tableau
animaux = [animal1, animal2, animal3]

# Utilisation des fonctions min() et max()
animal_min = min(animaux)
animal_max = max(animaux)

# Affichage des résultats
print("Animal le plus léger :", animal_min.nom)
print("Animal le plus lourd :", animal_max.nom)

# Utilisation de la fonction print() sur une instance d'Animal
print(animal1)

C++

#include <iostream>
#include <vector>
#include <algorithm>

class Animal {
public:
    Animal(std::string nom, int age, float poids, float taille)
        : nom(nom), age(age), poids(poids), taille(taille) {}

    bool operator<(const Animal& other) const {
        return poids < other.poids;
    }

private:
    std::string nom;
    int age;
    float poids;
    float taille;
};

int main() {
    Animal animal1("Lion", 5, 190.5, 1.2);
    Animal animal2("Tigre", 4, 170.3, 1.1);
    Animal animal3("Ours", 7, 300.0, 1.8);

    std::vector<Animal> animaux = {animal1, animal2, animal3};

    Animal animal_min = *std::min_element(animaux.begin(), animaux.end());
    Animal animal_max = *std::max_element(animaux.begin(), animaux.end());

    std::cout << "Animal le plus léger : " << animal_min.nom << std::endl;
    std::cout << "Animal le plus lourd : " << animal_max.nom << std::endl;

    std::cout << animal1 << std::endl;

    return 0;
}

using System;
using System.Collections.Generic;

public class Animal : IComparable<Animal>
{
    public string Nom { get; set; }
    public int Age { get; set; }
    public float Poids { get; set; }
    public float Taille { get; set; }

    public Animal(string nom, int age, float poids, float taille)
    {
        Nom = nom;
        Age = age;
        Poids = poids;
        Taille = taille;
    }

    public int CompareTo(Animal other)
    {
        return Poids.CompareTo(other.Poids);
    }
}

public class Program
{
    public static void Main()
    {
        // Création d'instances d'Animal
        Animal animal1 = new Animal("Lion", 5, 190.5f, 1.2f);
        Animal animal2 = new Animal("Tigre", 4, 170.3f, 1.1f);
        Animal animal3 = new Animal("Ours", 7, 300.0f, 1.8f);

        // Placement des instances dans une liste
        List<Animal> animaux = new List<Animal> { animal1, animal2, animal3 };

        // Utilisation des fonctions Min() et Max()
        Animal animal_min = animaux.Min();
        Animal animal_max = animaux.Max();

        // Affichage des résultats
        Console.WriteLine("Animal le plus léger : " + animal_min);
        Console.WriteLine("Animal le plus lourd : " + animal_max);

        // Utilisation de la fonction ToString() sur une instance d'Animal
        Console.WriteLine(animal1);
    }
}

Correction: Adresse et personne

Python

    def __init__(self, rue, numero, code_postal, ville):
        self.rue = rue
        self.numero = numero
        self.code_postal = code_postal
        self.ville = ville

    def __str__(self):
        return f"{self.numero} {self.rue}, {self.code_postal} {self.ville}"

    def __eq__(self, other):
        return (self.rue == other.rue and self.numero == other.numero and
                self.code_postal == other.code_postal and self.ville == other.ville)

class Personne:
    def __init__(self, prenom, nom, age, adresse):
        self.prenom = prenom
        self.nom = nom
        self.age = age
        self.adresse = adresse

    def __str__(self):
        return f"{self.prenom} {self.nom} habitant à {self.adresse}"

    def __eq__(self, other):
        return (self.prenom == other.prenom and self.nom == other.nom and
                self.age == other.age and self.adresse == other.adresse)

# Test des instances de Adresse
adresse1 = Adresse("Rue des Fleurs", 12, 75000, "Paris")
adresse2 = Adresse("Rue des Fleurs", 12, 75000, "Paris")
adresse3 = Adresse("Rue des Lilas", 5, 69000, "Lyon")

print(adresse1)  # "12 Rue des Fleurs, 75000 Paris"
print(adresse1 == adresse2)  # True
print(adresse1 == adresse3)  # False

# Test des instances de Personne
personne1 = Personne("Alice", "Dupont", 30, adresse1)
personne2 = Personne("Alice", "Dupont", 30, adresse2)
personne3 = Personne("Bob", "Martin", 25, adresse3)

print(personne1)  # "Alice Dupont habitant à 12 Rue des Fleurs, 75000 Paris"
print(personne1 == personne2)  # True
print(personne1 == personne3)  # False

C++

#include <iostream>
#include <string>

class Adresse {
public:
    Adresse(std::string rue, int numero, int code_postal, std::string ville)
        : rue(rue), numero(numero), code_postal(code_postal), ville(ville) {}

    friend bool operator==(const Adresse& a1, const Adresse& a2) {
        return a1.rue == a2.rue && a1.numero == a2.numero &&
               a1.code_postal == a2.code_postal && a1.ville == a2.ville;
    }

    friend std::ostream& operator<<(std::ostream& os, const Adresse& adresse) {
        os << adresse.numero << " " << adresse.rue << ", " << adresse.code_postal << " " << adresse.ville;
        return os;
    }

private:
    std::string rue;
    int numero;
    int code_postal;
    std::string ville;
};

class Personne {
public:
    Personne(std::string prenom, std::string nom, int age, Adresse adresse)
        : prenom(prenom), nom(nom), age(age), adresse(adresse) {}

    friend bool operator==(const Personne& p1, const Personne& p2) {
        return p1.prenom == p2.prenom && p1.nom == p2.nom && p1.age == p2.age && p1.adresse == p2.adresse;
    }

    friend std::ostream& operator<<(std::ostream& os, const Personne& personne) {
        os << personne.prenom << " " << personne.nom << " habitant à " << personne.adresse;
        return os;
    }

private:
    std::string prenom;
    std::string nom;
    int age;
    Adresse adresse;
};

int main() {
    Adresse adresse1("Rue des Fleurs", 12, 75000, "Paris");
    Adresse adresse2("Rue des Fleurs", 12, 75000, "Paris");
    Adresse adresse3("Rue des Lilas", 5, 69000, "Lyon");

    std::cout << adresse1 << std::endl;  // "12 Rue des Fleurs, 75000 Paris"
    std::cout << (adresse1 == adresse2) << std::endl;  // 1 (True)
    std::cout << (adresse1 == adresse3) << std::endl;  // 0 (False)

    Personne personne1("Alice", "Dupont", 30, adresse1);
    Personne personne2("Alice", "Dupont", 30, adresse2);
    Personne personne3("Bob", "Martin", 25, adresse3);

    std::cout << personne1 << std::endl;  // "Alice Dupont habitant à 12 Rue des Fleurs, 75000 Paris"
    std::cout << (personne1 == personne2) << std::endl;  // 1 (True)
    std::cout << (personne1 == personne3) << std::endl;  // 0 (False)

    return 0;
}

using System;

public class Adresse
{
    public string Rue;
    public int Numero;
    public int CodePostal;
    public string Ville;

    public Adresse(string rue, int numero, int codePostal, string ville)
    {
        Rue = rue;
        Numero = numero;
        CodePostal = codePostal;
        Ville = ville;
    }

    public override string ToString()
    {
        return $"{Numero} {Rue}, {CodePostal} {Ville}";
    }

    public override bool Equals(object obj)
    {
        if (obj == null || GetType() != obj.GetType())
        {
            return false;
        }

        Adresse other = (Adresse)obj;
        return Rue == other.Rue && Numero == other.Numero && CodePostal == other.CodePostal && Ville == other.Ville;
    }
}

public class Personne
{
    public string Prenom;
    public string Nom;
    public int Age;
    public Adresse Adresse;

    public Personne(string prenom, string nom, int age, Adresse adresse)
    {
        Prenom = prenom;
        Nom = nom;
        Age = age;
        Adresse = adresse;
    }

    public override string ToString()
    {
        return $"{Prenom} {Nom} habitant à {Adresse}";
    }

    public override bool Equals(object obj)
    {
        if (obj == null || GetType() != obj.GetType())
        {
            return false;
        }

        Personne other = (Personne)obj;
        return Prenom == other.Prenom && Nom == other.Nom && Age == other.Age && Adresse.Equals(other.Adresse);
    }
}

public class Program
{
    public static void Main()
    {
        // Test des instances de Adresse
        Adresse adresse1 = new Adresse("Rue des Fleurs", 12, 75000, "Paris");
        Adresse adresse2 = new Adresse("Rue des Fleurs", 12, 75000, "Paris");
        Adresse adresse3 = new Adresse("Rue des Lilas", 5, 69000, "Lyon");

        Console.WriteLine(adresse1);  // "12 Rue des Fleurs, 75000 Paris"
        Console.WriteLine(adresse1.Equals(adresse2));  // True
        Console.WriteLine(adresse1.Equals(adresse3));  // False

        // Test des instances de Personne
        Personne personne1 = new Personne("Alice", "Dupont", 30, adresse1);
        Personne personne2 = new Personne("Alice", "Dupont", 30, adresse2);
        Personne personne3 = new Personne("Bob", "Martin", 25, adresse3);

        Console.WriteLine(personne1);  // "Alice Dupont habitant à 12 Rue des Fleurs, 75000 Paris"
        Console.WriteLine(personne1.Equals(personne2));  // True
        Console.WriteLine(personne1.Equals(personne3));  // False
    }
}

Vos premières classes

Les animaux

Les adresses

Les personnes

Login with your site account

Register a new account