Class basique.

Exemple simple de classes

class

Voir version :

Pas de dépendances

Télécharger :

#include <cstdlib>
#include <iostream>

using namespace std;

/* --------------------------- */

int pgcd (int m, int n)            // Algorithme d'Euclide (pour les matheux)
{
  if (n==0) return m;
  else return pgcd( n, m % n);
}

/* ---------------------------- */

class Fraction
{
private:
    int num;
    int denom;
public:
    Fraction(int,int);
    void Simplifie();
    void Affiche();
};

Fraction::Fraction(int n,int d)
{
    num=n;
    denom=d;
}

void Fraction::Simplifie()
{
    int p=pgcd(num,denom);
    num/=p;
    denom/=p;
}

void Fraction::Affiche()
{
    cout << num << "/" << denom << endl;
}

/* ------------------------------ */

int main()
{
    int n,d;
    cout << "entrez numerateur, puis denominateur" << endl;
    cin >> n;
    cin >> d;
    Fraction f(n,d);
    f.Simplifie();
    cout << "Votre fraction simplifiee" << endl;
    f.Affiche();
    system("PAUSE");
    return 0;
}




Commentaires


  Voici enfin du VRAI C++ : de l'objet

  Procédons :

  La fonction pgcd que vous voyez en haut, ne vous en occupez pas, dites vous que c'est juste 
  un outil qui dit quel est le plus grand diviseur d'une fraction, c'est des maths, 
  ça s'apprend en terminale S, dites vous, si elle vous gene, que c'est une fonction "magique"
  qui me servira pour la méthode Simplifie() qu'on verra apres.
	(si malgré tout, vous voulez la comprendre, sachez qu'elle est récursive, voyez 
	ma partie a venir sur la récursivité dans ce tutorial)



	Regardons au milieu du programme :
	je cree un ****** OBJET ******
	qui s'appelle "Fraction"


  l'objet se crée avec :

  class Fraction
  {
  ...


  };    //   <--- Mettez un point virgule ici, comme a la fin des struct


  Un objet, c'est une STRUCT avec des METHODES ASSOCIEES  (voir les struct avant de venir ici)
  Pourquoi une struct ?
  parce qu'on met dedans plusieurs variables.

  Ici, en l'occurrence, 2 int, "num" et "denom" (qui sont les numérateurs de la fraction)

Premiere différence : elle contient des PROTECTIONS :
*****************************************************

  par exemple, juste avant f.Simplifie(), mettez par exemple : 
  f.num = 3;
  pour mettre a jour le numérateur !

  que se passe t il ?  --> ERREUR 
  Pourquoi ? 

  Parce que ces données sont PRIVATE.
  En gros, moi qui aie écrit la classe, je vous interdit d'y toucher directement.

  Pourquoi ?
  C'est une question de rigueur :

	Voici un exemple :
	Je vous vend un téléphone :
	Vous avez le droit d'appuyer sur les boutons qui se trouvent dessus.
	Mais je vous interdit de l'ouvrir pour aller modifier des choses.
	Pourquoi ? Pour pas que vous cassiez tout !!
	En effet, si vous touchez tout dedans, qui me dit qu'apres, ça marchera encore ?
	Pour la classe (l'objet), c'est la meme chose : 
	si je vous permet de tout changer comme ça, alors vous pouvez y faire planter.

	L'idée est un concept a comprendre :
	c'est une boite noire. Dessus, il y a des boutons pour la faire marcher.
	Les données utilisées dedans, vous n'avez pas a y toucher. Pire, je les protege 
	pour m'assurer que vous ne les touchiez pas.
	Quand on fait de gros gros programmes, on comprend cette partie d'utilité des classes :
	Un programmeur fait une classe, il fait les boutons de la boite noire, et vous donne celle
	ci pour que vous l'exploitiez. Il y a protégé de façon a ce que son utilisation soit toujours bonne
	car je rappelle qu'une mauvaise utilisation, et pouf ! ça plante...

  Bref, je pourrai en parler longtemps, c'est une philosophie a comprendre. La philosophie Objet.



Voyons maintenant ce qui est proposé en PUBLIC : (vous aurez le droit d'y manipuler)
	Fraction(int,int);
	void Simplifie();
	void Affiche();

Commençons par la première :

  Fraction(int,int);

on dirait une fonction, sauf :
- elle n'a pas de valeur de retour (pas de void, de int ou autre)
- elle a le MEME nom que la classe.

--> Une telle fonction s'appelle un ******** CONSTRUCTEUR *********

Remarquez dans le main :

	Fraction f(n,d);

  si ça avait été une structure, j'aurais fait :

	Fraction f;

  La, je passe des parametres lors de la création, donc de la CONSTRUCTION.

  Donc DES que je crée une INSTANCE de classe, un constructeur est appelé.
  (une instance est une valeur. On parle de valeur de variable, et d'instance de classe)
  (ici, on crée l'instance f. Je pourrais créer une deuxieme fraction g, on aurait alors 
  2 instances de la classe fraction, mais 2 instances de la meme classe !!)

	On met donc dans le constructeur tout ce qu'on veut qu'il soit fait quand l'instance est construite.
	Ici, et c'est courant, on veut qu'il remplisse les variables.

  Regardons comment elle est implémentée :


Fraction::Fraction(int n,int d)
{
	num=n;
	denom=d;
}


  Elle est faite comme une fonction, sauf que l'on met devant Fraction::
  pour signifier que ce que l'on implémente appatient à Fraction.

  Et donc, du coup, dedans, on est DANS la classe, et donc, on peut manipuler les données privées.
  donc ici, je peux directement faire ce que je veux de num et de denom...




La question qui tue :

Et si je met juste
Fraction f;
ça fait quoi ?

--> c'est interprété comme si vous écriviez :

Fraction f();

or, avez vous un constructeur

Fraction();
??
NON.

Donc ça va gueuler si vous faites cela.
On verra plus tard, en parlant du polymorphisme de fonctions, comment avoir plusieurs constructeurs.
(y'a que le mot qui est compliqué "polymorphisme de fonctions", car ça, c'est simple...)


Fonction suivante :

	void Simplifie();

  c'est une fonction normale, comme on a l'habitude de voir, sauf qu'elle est DANS une classe
  donc on appelle ce genre de fonctions une METHODE de la classe Fraction.

  d'ailleurs, pour bien s'en rendre compte, en l'implémentant, on parle de Fraction comme pour le constructeur :

void Fraction::Simplifie()		// <--- Méthode Simplifie DE fraction

  Comme Simplifie appartient a la classe, il a le droit de lire ou modifier les données privées
  il ne se gene pas, et simplifie la fraction (ça, on voit ça au college) mais avec la méthode
  d'Euclide (ça, on voit ça en fin de lycée)

  Peut importe comment il fait !!!!

  C'est aussi ça le C++, J'AI FAIT LA CLASSE, je vous la donne.
  Vous pouvez l'utiliser. PEUT IMPORTE COMMENT JE L'AI FAITE !!!
  Je vous dit juste qu'elle contient une méthode Simplifie() et qu'elle fait bien son boulot !!
  Je l'ai testée, ça roule :)
  Alors utilisez la, apres, quelle importance de savoir comment je l'ai faite :)
(Apres, si vous etes matheux et curieux, regardez (ouvre donc la boite noire), mais a priori, cela ne regarde que l'auteur de la classe)


La méthode Affiche()

rien de bien nouveau la dedans !! :)


Voila la base des classes !!

Regardez le main pour savoir comment utiliser tout cela (usage du "." comme dans les struct)



En bref : 

Les classes, c'est des boites noires, protégées, avec des méthodes pour les utiliser.
L'auteur de la classe prévoit de bonnes méthodes, pour que sous outil marche bien.
Il empeche l'ouverture de la boite noire, pour ne pas rendre une instance incohérente.

On manipule ensuite une Fraction simplement. Regardez le main...


Laissez un commentaire / post a comment