TP3 : Initiation à la refactorisation - Qualité de Développement

Utilisation d’un IDE

Les codes deviennent de plus en plus complexes.
Une bonne coloration syntaxique, une autocomplétion et un Search and Replace peuvent vous faire gagner beaucoup de temps.
Utilisez donc un IDE (comme VSCodium) sans son intégration Git pour le moment.

Quelques points utiles à connaître sur VSCodium :

Ouvrez le répertoire Git (la racine de votre dépôt) via File > Open Folder et restez sur Explorer (première icône de la barre à gauche).
Vous pouvez créer des fichiers et des dossiers à l’aide des boutons situés à droite du nom de la racine de votre dépôt.
Un clic droit sur un fichier permet d’ouvrir un terminal dans le répertoire du fichier avec Open in Integrated Terminal.
Utilisez Ctrl + H sur une sélection de code pour effectuer un Search and Replace dans le fichier courant.

Objectifs¶

Le but de ce TP est de comprendre les points suivants :

Exercice 1 : Short functions¶

Organisation du code¶

Créez un répertoire short-functions/ dans TP3/.
Créez les fichiers suivants dans short-functions/.

product.h

product.cpp

display-prices.h

display-prices.cpp

main.cpp

#ifndef PRODUCT_H
#define PRODUCT_H

#include <string>

class Product {
private:
    std::string mName;
    double mPrice; // in euros
    int mQuantity; // in units

public:
    Product(const std::string& name, double price, int quantity);
    std::string getName() const;
    double getPrice() const;
    int getQuantity() const;
    bool operator<(const Product& other) const;
};

#endif

#include "product.h"
#include <string>

Product::Product(const std::string& name, double price, int quantity) 
    : mName(name), mPrice(price), mQuantity(quantity) {}
    
std::string Product::getName() const { 
    return mName; 
}
        
double Product::getPrice() const { 
    return mPrice; 
}

int Product::getQuantity() const { 
    return mQuantity; 
}

bool Product::operator<(const Product& other) const {
    return mPrice < other.mPrice;
}

#include "product.h"
#include "display-prices.h"
#include <iostream>
#include <vector>
#include <algorithm>

void displayAvailableProductsByNonDecreasingPriceAndDisplayTotalPrice(){
	
    // Fetching products data
    std::vector<Product> products;
    // Our current products
    products.push_back(Product("Laptop", 1000, 5));
    products.push_back(Product("Smartphone", 700, 0));
    products.push_back(Product("Tablet", 500, 2));
    products.push_back(Product("Headphones", 150, 10));
    products.push_back(Product("Smartwatch", 200, 0));

    // Fetching available products data
	std::vector<Product> availableProducts;
    for (const Product& product : products) {
        if (product.getQuantity() > 0) {
            availableProducts.push_back(product);
        }
    }

    // Sorting available products by non-decreasing price
	sort(availableProducts.begin(), availableProducts.end());

    // Calculating total price
    double totalPrice = 0;
    for (const Product& product : availableProducts) {
        totalPrice += product.getPrice() * product.getQuantity();
    }

    // Displaying available products by non-decreasing price
	std::cout << "Sorted Available Products (by non-decreasing price):" << std::endl;
    for (const Product& product : availableProducts) {
        std::cout << "Name: " << product.getName() << " - Price: " << product.getPrice() 
             << " - Quantity: " << product.getQuantity() << std::endl;
    }

    // Displaying total price
    std::cout << "Total Price of Available Products: " << totalPrice << std::endl;
}

Include guards

Ces directives ensemble forment un include guard :

#ifndef PRODUCT_H
#define PRODUCT_H

//...

#endif

#define crée une macro qui remplace le texte défini (PRODUCT_H) par le code qui suit. La convention de nommage des macros est la même que celle des constantes globales et inclut _H pour indiquer qu’il s’agit d’une macro liée à l’include guard d’un header (bien qu’il puisse exister d’autres types de macros).
#ifndef (abréviation de “if not defined”), #define et #endif signifient : “Si la macro PRODUCT_H n’est pas définie, définissez la macro PRODUCT_H comme suit : <code>, fin de la condition”.

L’include guard permet à un header d’être inclus une seule fois dans chaque code source et donc dans chaque translation unit.

L’inconvénient des include guards est la nécessité d’avoir un schéma de nommage cohérent pour un exécutable (dont la compilation peut provenir de milliers de fichiers différents répartis dans différents répertoires) : il ne peut pas y avoir deux headers avec la même macro (même si les fichiers se trouvent dans des répertoires très éloignés les uns des autres).

Une autre directive est parfois utilisée à la place des include guards, mais elle présente aussi ses propres inconvénients.
Les bonnes pratiques standard en C++ recommandent l’utilisation des include guards.

Compilez le code avec g++ -o short-functions main.cpp display-prices.cpp product.cpp (l’ordre des .cpp n’a pas d’importance).

Version C++

Si vous voyez des warnings lors de la compilation liés aux standards de syntaxe utilisés (par exemple, for (ElementType element : vectorOfElements), qui n’existe que depuis C++11), vous pouvez compiler avec une version plus récente de C++ compatible avec votre compilateur g++.

Pour vérifier la version (l’année) de C++ utilisée par défaut par g++ sur votre poste de travail, utilisez la commande suivante :

g++ -dM -E -x c++ /dev/null | grep __cplusplus | sed 's/[^0-9]*\([0-9]\{4\}\)[0-9]*L/\1/'

Par exemple, 2011 correspond à C++11.

Pour vérifier les versions compatibles avec g++ sur votre poste, utilisez la commande :

g++ -v --help 2> /dev/null | grep -oP '(?<=-std=)c\+\+\S+' | sed 's/\.$//' | sort | uniq

Les dernières versions de C++ après 11 sont C++14, 17, 20 et 23.

Vous pouvez compiler votre code en utilisant une version plus récente et compatible que celle par défaut. Par exemple :

g++ -std=c++14 -o short-functions main.cpp display-prices.cpp product.cpp

Exécutez ./short-functions.

Résumé des bonnes pratiques d’organisation du code en C++

Ne pas tout coder dans un seul fichier.
Utiliser un fichier .cpp et un fichier .h de même nom pour chaque classe et chaque groupe de fonctions externes liées, puis un fichier main.cpp.
Un fichier (.cpp et .h) d’une classe porte le nom de la classe, et un fichier (.cpp et .h) de fonctions externes porte le nom qui les relie.
Les fichiers .h doivent contenir uniquement les déclarations, et les fichiers .cpp doivent contenir les définitions.
Les fichiers .h doivent toujours avoir des include guards, c’est-à-dire :

#ifndef NOM_DE_HEADER_H
#define NOM_DE_HEADER_H

//...

#endif

Ne pas oublier d’utiliser MyClass:: devant les méthodes dans my-class.cpp qui définit la classe MyClass déclarée dans my-class.h.
Si vous avez besoin des éléments définis dans code.cpp, alors #include "code.h" (qui déclare ces éléments), et non le code.cpp lui-même.
Include what you see : ajouter les bibliothèques et headers que vous utilisez pour votre code au début, peu importe si un header que vous incluez les contient déjà.
Ne plus utiliser using namespace std.

Java et C#

En Java et C#, il n’y a pas de séparation entre les headers et les codes source, car leurs systèmes de compilation diffèrent. Les éléments du code sont à la fois déclarés et définis dans le même fichier.
Néanmoins, il reste essentiel d’organiser le code en plusieurs fichiers, de la même manière qu’en C++.
En Java et C#, il est nécessaire de nommer un fichier contenant une classe en fonction du nom de la classe (comme en C++), mais en utilisant la convention UpperCamelCase (également appelée PascalCase). De plus, en Java, la compilation échouera si le fichier contenant une classe n’est pas correctement nommé, contrairement à C++.
En Java et C#, on suit plutôt le principe de Include what you use, qui consiste à importer (import en Java, using en C#) uniquement ce qui est nécessaire au bon fonctionnement du code. Cela diffère du principe Include what you see en C++, qui repose sur les include guards pour éviter les duplications de code.

Refactorisation du code¶

Que fait ce code ?

Quiz : Quels sont les problèmes du code de displayAvailableProductsByNonDecreasingPriceAndDisplayTotalPrice ?
Refactorisez le code de display-prices.cpp (en modifiant les autres fichiers concernés comme le header, le main).

Exercice 2 : Classify it¶

Créez un répertoire classify-it/ (dans lequel le code sera organisé dans plusieurs fichiers différents).
Dans classify-it/, créez le fichier suivant :

main.cpp

#include <iostream>
#include <string>
#include <vector>

double calculateAverage(const std::vector<double>& scores) {
    double sum = 0;
    for (double score : scores) {
        sum += score;
    }
    return sum / scores.size();
}

void printScores(const std::string& studentName, int studentId, const std::vector<double>& scores) {
    std::cout << std::endl << "Scores for " << studentName << " (Id: " << studentId << "): ";
    for (size_t i = 0; i < scores.size(); i++) {
        std::cout << "[" << i+1 << "] " << scores[i] << " ";
    }
    std::cout << std::endl;
}

void printAverage(const std::vector<double>& scores){
    std::cout << "Average: " << calculateAverage(scores) << std::endl;
}

int main() {
    std::string studentName;
    int studentId;
    std::vector<double> scores;

    studentId = 12345;
    studentName = "Alice";

    scores.push_back(11);
    scores.push_back(12.5);
    scores.push_back(14.75);
    scores.push_back(19);

    printScores(studentName, studentId, scores);

    return 0;
}

Que fait ce code ?

Il est difficile d’ajouter des étudiants et leurs notes.
Nous allons donc créer une classe Student avec les trois attributs suivants :

Seul l’Id de l’étudiant est nécessaire pour construire l’objet. L’Id est immuable : une fois initialisé par le constructeur, il ne peut plus être modifié. Cela est rendu possible en utilisant const devant l’attribut.

Initialiser un attribut const

Un attribut immuable (const) ne peut être initialisé que dans l’initializer list en C++. Par exemple :

class MyClass{
private:
    const int mAttribute;
public:
    MyClass(int valueName) : mAttribute(valueName){
        // Constructor body
    }
}

Cet attribut ne peut pas être initialisé dans le Constructor body.
Par exemple, le code suivant retournera une erreur de compilation :

class MyClass{
private:
    const int mAttribute;
public:
    MyClass(int valueName) {
        mAttribute = valueName;
    }
}

Le nom de l’étudiant peut être modifié. Au début, il est vide (par défaut, un string someString non initialisé est == ""). Nous n’allons pas gérer les erreurs potentielles venant d’un nom vide dans cet exercice.

Le vector des notes de l’étudiant ne sera pas accessible. Les seuls accès se feront à travers l’affichage (printScores) et l’ajout de notes via la fonction appendScore, qui ajoute une note à la fin du vector en utilisant push_back. Il n’y a pas de notes au début, mais nous allons aussi ignorer les erreurs potentielles venant d’un vector vide dans cet exercice.

Créez la classe Student avec les méthodes appropriées (en incluant les fichiers .h et .cpp correspondants), et ajoutez-y les fonctions pour calculer la moyenne et afficher les notes.
Modifiez les directives de main.cpp pour inclure student.h et les bibliothèques nécessaires.

User input (Bonus)¶

L’intérêt d’avoir une classe Student est de faciliter l’entrée des données de plusieurs étudiants.
Pour pouvoir saisir les informations de plusieurs étudiants, nous allons écrire plusieurs fonctions pour gérer les saisies utilisateur.

Créez un fichier user-input.cpp ainsi que le fichier header associé.
Voici des déclarations de fonctions pour vous aider :

void inputNumberOfStudents(int& number);
void inputStudentId(int& id);
void inputStudentName(Student& student);
void inputStudentScores(Student& student);
Student createStudentFromInput();
void printAllScoresAndAverages(const std::vector<Student>& students);

Voici le code de inputStudentScores pour vous aider :

void inputStudentScores(Student& student) {
    double score;
    std::cout << "Enter score (-1 to stop): ";
    std::cin >> score;

    while (score != -1) {
        student.appendScore(score);
        std::cout << "Enter score (-1 to stop): ";
        std::cin >> score;
    }
}

Implémentez les fonctions données et modifiez le main pour récupérer les saisies utilisateur et afficher les notes ainsi que les moyennes de chaque étudiant.

Revenez aux objectifs et cochez les points que vous avez maîtrisés. Revenez sur les points que vous n’avez pas encore bien compris. Appelez votre encadrant si besoin.

Travaux Pratiques

TP2 : Comment renommer les choses ?

Travaux Pratiques

TP4 : Build system et documentation