Le C++

- Commentaires : /* remarques */ ou // remarques jusque fin de la ligne
- Inline:l'ensemble des instructions est recopié à chaque appel :

Inline int Max (int N1, int N2)
{

return (N1 > N2 ? N1 :N2)

}

A chaque appel de la fonction Max, le code est recopié.

- Référence ou alias
Une référence permet l’accès indirecte à une variable, elle permet de passer des paramètres qui pourront être modifiés par une fonction.

Int I = 0 ;
int& R=I ;

R++ ; I vaut alors 1

La définition de R équivaut à *(&i) c.a.d. contenu de l’adresse de I

ceci est valable aussi pour char, struct, ... et même pour class !

- Sur-définition :

int max (int n1, int n2) ;
float max (float n1, float n2) ;
char * max (char* ch1, char* ch2) ;

- La déclaration :
La variable ou objet peut être déclaré(e) n’importe où, même dans une instruction.

Ex. :

for (int i = 0, i < 10, i++) {...}

Où dans une fonction
{

int j =10 ;
int i = 2 ;
int k = max(j,i) ;

}

- Allocation dynamique :
int *p
p = new int ;

char *ch ;
ch = new char[100] ;

struct st_fiche *f ;
f = new struct st_fiche ;
f->age = 20 ;

- Désallouer :
delete ch
delete p

- Argument par défaut :
Il est possible d'indiquer les valeurs par défaut pour des arguments qui ne seraient pas renseignés:

Soit une fonction max qui retourne la valeur la plus grande entre 2 paramètres passés:

extern int max (int = 0 ; int = 1) ;

ou extern int max (int i = 0 ; int j = 1) ;

i = 10 ;
i = max(i) ; // réponse 10 car i est le premier paramètre et est = 10, le second paramètre n'étant pas renseigné implique la valeur par défaut 1 (j = 1 par défaut est < i)
i = -1 ;
i = max(i) ; // i recevra 1 car j > i

- Les flux
# include <stdio.h>
cout << « Salut » << ‘\n’ // Affichage Salut

int val ;
cin >> val // Saisie

- Création d’une classe

Exemple de création d’une classe : la classe date

#include <iostream>
class date
{
   	int jour ;
   	int mois ;
   	int annee ;
   
   	public :
   	date(int j = 1, int m = 1, int a = 1970) ; // Constructeur, sont indiqués les valeurs à prendre par défaut si l’appel au contructeur    se fait sans valeur)
   	~date (void) ; // Destructeur (facultatif)
   	void changer (int j, int m, int a) ;
   	void afficher (void) ;
} ;

date::date (int j, int m, int a)
{
   	jour = j ;
  	mois = m ;
   	annee = a ;
}

void date::changer (int j, int m, int a)
{
   jour = j ;
   mois = m ;
   annee = a ;
}

void date::afficher (void)
{
   cout << « Le « jour <<’/’  mois     ‘/’  annee
}

main()
{
   date d(10,4,1994) ; //d est une instance de date
   d.afficher() ;
   int j, m, a ;

   cin >>j ;
   cin >> m ;
   cin >> a ;
   d.changer (j, m, a) ;
}

A savoir:

D est une instance de classe date. Le code que nous lançons en tapant d.afficher() est celui de la classe date. Il n'y a en effet pas de duplication du code de la classe date vers l'instance d (inutile de surcharger la mémoire !).

Par contre et évidemment, les données sont bien dupliquées dans l'instance d…

Pour les méthodes sans types, il faut préciser void ! Microsoft C++ ne dira pas forcement grand chose à la compilation si vous ne le faîtes pas, mais d'autres compilateurs un peu plus regardant ne seront pas tout à fait d'accord !

Constructeur/destructeur

Pour initialiser une instance de classe, vous pourrez utiliser un constructeur. Il devra s'écrire de la manière suivante:

public:

nom_de_la_classe (Eventuels paramètres qui pourront être initialisés par défaut)

par exemple date(int j = 1, int m = 1, int a = 1970)

Le destructeur sert lui à libérer les ressources utilisées par l'instance.

~nom_de_la_classe()

Le nom du constructeur comme le destructeur devant impérativement porter le nom de la classe ! Ce sont les deux seules méthodes qui ont cette possibilité.

Dérivation/héritage simple

Dérivation/héritage simple de la classe date vers une classe spécialisée : dater
Il s'agit en fait de se créer une nouvelle classe ayant ses propres propriétés, et qui reprendra les propriétés d'une autre classe (la classe de base).

Il est alors possible de rendre les méthodes de la classe héritée accessibles depuis l'extérieur en indiquant public.
Ou encore d'interdire les méthodes de cette classe depuis l'extérieur en indiquant protected. Bien entendu, votre classe spécialisée peut toujours accéder aux méthodes de la classe de base si celles-ci ne sont pas private !

class dater:public date
{
   int heure ;
   int minute ;
   int seconde ;
   
   public:
   dater (int j, int m, int a, int h, int mn, int s) ;
   int change (int j, int m, int a, int h, int mn, int s);
   void affiche (void) ;
};

dater::dater (int j, int m, int a, int h, int mn, int s)
{
   changer (j, m, a) ;
   heure = h ;
   minute = mn ;
   seconde = s ;
}

int dater::change (int j, int m, int a, int h, int mn, int s)
{
   changer(j,m,a) ;
   if ((h<0) || (h>23)) return (-1) ;
   if ((mn < 0) || (mn > 59)) return (-1) ;
   if ((s < 0) || (s > 59)) return (-1) ;
   heure = h ;
   minute = mn ;
   seconde = s ;
   return (0) ;
}

void dater::affiche (void)
{
   afficher() ;
   cout << heure << « : » << minute << «    : » << seconde ;
}

Surcharge de méthodes

Il est possible d'avoir une méthode portant le même nom qu'une méthode de la classe parent. Dans ce cas, l'appel à la méthode de votre instance lancera bien la méthode de la classe dérivée.

Cependant, cette classe dérivée pourra toujours appeler la méthode de même nom de la classe parent. Il suffira pour cela d'indiquer le nom de la classe parent.

Par exemple

En fait, on peut toujours indiquer le nom de la classe à toutes les méthodes. Si vous ne le faites pas, le compilateur va associer automatiquement la méthode à la classe par défaut.

Fonction virtuelle

Les fonctions virtuelles permettent aux classes dérivées de remplacer totalement ou partiellement les méthodes de la fonction de base.

Dans l'exemple qui suit, surchage de la fonction afficher date pour afficher en plus l'heure dans la classe dérivée.

Dérivation/héritage multiple

Cas un peu particulier, il s'agit d'une classe qui hérite de n classes.

En principe, le cas ne devrait pas se produire bien souvent, et s'il se produit, il faudra peut-être revoir avant tout la conception, il y a peut-être un problème…

Le principe est identique à un héritage simple, mais au niveau de la définition de la classe dérivée, vous indiquerez les n classes de bases.

Class nomclassederivee :public classebase1, public classebase2, …

Se pose alors le problème d'ambiguïté possible entre les méthodes des différentes classes de base.

Par exemple, il existe une variable X dans la classe de base A et la classe de base B.
Pour lever toutes ambiguïtés, vous allez écrire dans la classe dérivée: Y=A::X pour accéder au X de la classe A.

Au niveau des constructeurs, le constructeur de la classe dérivée va lancer les constructeurs des classes de base dans l'ordre de définition de la classe dérivée puis le code du constructeur de la classe dérivée.

Au niveau des destructeurs, le constructeur de la classe dérivée fait l'inverse du constructeur…

Fonctions virtuelles pures

Les fonctions virtuelles pures permettent de déclarer l'existence de la fonction, sans pour autant avoir de définition concrète. Les classes dérivées devront obligatoirement définir exactement la fonction.

Par exemple: la fonction dessine de la classe forme est une fonction virtuelle pure.
Les classes dérivées devront déclarer cette fonction. Vous aurez alors dans la classe dérivée cercle la fonction pour dessiner un cercle, …

class forme {
public:
virtual void dessiner() const = 0; // = 0 signifie "virtuelle pure"
…
};

Classe abstraite

Vous avez vu dans le chapitre Notion objet que le terme véhicule était abstrait. Un véhicule pouvant être un avion, un camion, une voiture, …

Une classe de base abstraite (Abstract Base Class) va ainsi vous permettre de définir des fonctions virtuelles pures. En fait, une classe abstraite n'est définie que de fonctions virtuelles pures.

L'avantage, étant d'obliger les classes dérivées à définir exactement le contenu de ces fonctions.

Création dynamique d'une instance de classe

Pour le moment, vous n'avez fait que des créations statiques d'instances de classe, par exemple en tapant date d1 (20,3,1994);

Mais il est possible de créer des instances dynamiquement. En effet il est plutôt rare de connaître exactement le nombre d'instances qui seront créées !

Pour cela vous utiliserez la commande new

En commençant tout d'abord par créer un pointeur de type la classe à instancier, par exemple:

date *d1;

Puis en affectant une instance à ce pointeur en faisant

d1 = new date (20,3,1994); ce qui aura pour effet de déclencher le constructeur automatiquement.

Si les options par défauts définies dans la classe pour le constructeur vous suffisent, vous pouvez taper:

d1 = new date;

où encore

d1 = new date (20,3) Dans ce cas, l'année sera positionnée avec la valeur par défaut !

La compilation ne fonctionnera pas si un des paramètres du constructeur n'a pas de valeur par défaut !

La libération en mémoire se fera via la commande delete (d1); qui déclenchera automatiquement le destructeur.

Liens intéressants

Apprenez à programmer en C++ sur le site du zéro