Classe

Passer de C à C++

Les ajouts du C++ par rapport au C

• Mécanisme de POO (Programmation Orientée Objet)
  • Encapsulation
    • il y a des champs et des fonctions publique ou privé
  • Polymorphisme
  • Template (patron de classe ou de fonction)
  • Référence
  • Exceptions
  • Espace de noms
  • Héritage

flowchart TD
 1[Voiture]-->2[Camion]
 1-->3[Vélo]
 1-->4[Voiture]

Exemple de modélisation d’une fraction en C++

#include<cstdio>

int calcPGCD(int a, int b) {
    if(b == 0) return a;
    return pgcd(b, a % b);
}

struct Fraction {
    int num; // numérateur
    int den; // dénominateur
    int pgcd;

    void afficher(void) { /* c'est une méthode, pas une fonction, elle est
                           * liée à un objet */
        printf("%d/%D\n", num, den);     
    }

    Fraction produit(Fraction b) {
        Fraction res;
        res.num = num * b.num;
        res.den = den * b.den;

        return res;
    }

    void agrandir(int a) {
        num *= a;
        den *= a;
    }

    void calculePGCD(void) {
        pgcd = calcPGCD(num, den);
    }

    void simplifierFraction(void) {
        calculePGCD(); // Wow! on utilise une méthode de l'objet
        num = num / pgcd;
        den = den / pgcd;
    }

};

int main() {
    // Définition d'une fraction
    Fraction a;
    a.num = 6;
    a.den = 2;
    a.afficher();

    // Utilisation d'une méthode de l'objet
    Fraction c = a.produit(b);
    c.afficher();

    // On peut donner modifier la valeur de l'objet
    c.agrandir(2);
    c.afficher();

    // Encore une exemple
    c.calculePGCD();
    printf("PGCD: %d\n", c.pgcd);

    // Encore un exemple
    a.afficher();
    a.simplifierFraction();
    a.afficher();
}

On ajoute un constructeur à notre programme

#include<cstdio>

int calcPGCD(int a, int b) {
    if(b == 0) return a;
    return pgcd(b, a % b);
}

struct Fraction {
    private : // attributs/membre privés, pas accessible à l'extérieur de la classe
    int num; // numérateur
    int den; // dénominateur

    // Constructeur du programme quand aucun argument renseigné
    Fraction(void) { }
    
    public : // attribut/membre publics, accessible à l'extérieur de la classe
    int pgcd;

    // Constructeur du programme quand 2 arguments renseignés
    Fraction(int nump, int denp) {
        printf("Appelle d'un constructeur\n");
        num = nump;
        den = denp;
        pgcd = calcPGCD(nump, denp);
    }

    void afficher(void) { /* c'est une méthode, pas une fonction, elle est
                           * liée à un objet */
        printf("%d/%D\n", num, den);     
    }

    Fraction produit(Fraction b) {
        Fraction res;
        res.num = num * b.num;
        res.den = den * b.den;

        return res;
    }

    // Accesseur num
    void setNum(int pnum) {
        num = pnum;
        pgcd = calculePGCD();
    }

    // Accesseur den
    void setDen(int pden) {
        den = pden;
        pgcd = calculePGCD();
    }

    void agrandir(int a) {
        num *= a;
        den *= a;
    }

    void calculePGCD(void) {
        pgcd = calcPGCD(num, den);
    }

    void simplifierFraction(void) {
        calculePGCD(); // Wow! on utilise une méthode de l'objet
        num = num / pgcd;
        den = den / pgcd;
    }
};

int main() {
    // Définition d'une fraction
    Fraction a(6, 2);
    printf("PGCD: %d\n", a.pgcd);

    // Modification du dénominateur
    a.setDen(3);
    printf("PGCD: %d\n", a.pgcd); // incroyable, le PGCD reste vrai !
    
    a.afficher();
    a.simplifierFraction();
    a.afficher();
}

struct ou class sont équivalent, la seule différence est que l’intérieur d’une struct est publique par défaut à l’instar du contenu d’une class qui est privée par défaut

// Différence entre struct et class
struct MaClasse {
    // public: implicite
};

class MaClasse {
    // private: implicite
};

On peut définir une méthode d’une struct en dehors de la struct. C’est mieux de définir directement à l’intérieur que à l’extérieur quand même

struct MaClasse {
    int maMethode();
};

int MaClasse::maMethode() {
    return 3;
}

Il est préférable de définir une class à l’extérieur du fichier .cpp, dans un fichier .hpp.

Fichier xd.hpp

#ifndef xd
#define xd

struct MaClasse {
    int maMethode(void);
};

int MaClasse::maMethode(void) {
    return 3;
}

#endif

Fichier main.cpp

#include <iostream>
#include "xd.hpp"

using namespace std;

int main(void) {
    MaClasse a;
    cout << a.maMethode() << endl;
}