Introduction à la programmation orientée objet en C

Formation introduction à la programmation orientée objet en C, tutoriel & guide de travaux pratiques en pdf.

I – Les mécanismes du langage C utilisés
I-A – Les pointeurs
I-B – Les flèches
I-C – Les pointeurs de fonctions
I-D – Un cast (changement de type
I-E – Le cast (changement de type) des pointeurs
I-F – Les types énumérés
I-G – Les types structurés
II – L’utilisation des mécanismes pour la Programmation Orientée Objet
II-A – Modélisation d’une classe
II-B – Les constructeurs
II-C – Le this
II-D – Le destructeur
II-E – Les méthodes
II-F – Conseils et avantages
II-G – Exemple complet
II-G-1 – La classe Stylo
II-G-2 – Définition du type en C dans le header (stylo.h
II-G-3 – Définition de la classe en C dans le fichier source C (stylo.c
II-G-4 – Utilisation dans un programme

Les mécanismes du langage C utilisés

Les « pointeurs » ont une réputation de mal-aimé. Dés qu’on en parle, on pense :
• complexités
• difficultés à résoudre les bugs
• débordement de mémoire (coredump)
Or, ce n’est ni plus ni moins qu’une adresse mémoire. Vous déplacez simplement votre référentiel de la variable à son adresse (un peu comme si vous ne vous adressez pas à un interlocuteur par nom mais par son lieu d’habitation).
Dans notre cas, les pointeurs doivent devenir vos alliés et vous devez apprendre à les maîtriser. L’autre objectif de ce document est de montrer comment avec quelques règles simples, il est possible de devenir copain-copain avec eux.

Les pointeurs

Un pointeur est une adresse mémoire (on parle aussi de référence). Il est très fréquemment utilisé avec des allocations dynamiques (malloc, free ou realloc). Lors de la déclaration d’une variable, nous la matérialisons par une étoile. (ex : int i; i contient un entier et int *i; contient une référence (une adresse) sur une variable contenant un entier).
Il est utilisé dans le passage de paramètres par adresse (la valeur du paramètre est susceptible d’évoluer).

Les flèches

Les flèches constituent un raccourci dans l’utilisation du pointeur.
Courant->Suivant est équivalent à (*Courant).Suivant. Le parenthésage est très important, il indique l’ordre dans lequel il faut lire.

Remarques :

• (*Courant).Suivant : on accède à la propriété « suivant » de l’objet à l’adresse Courant
• *Courant.Suivant : on accède à l’objet adressé par l’information « Courant. Suivant »
I-C – Les pointeurs de fonctions
En C, il n’existe pas de procédures au sens strict du terme. Nous assimilons une procédure à une fonction qui retourne un objet non défini (void).
Les fonctions, qui ne sont pas seulement du code, sont aussi des adresses statiques (en interne). Elles indiquent l’adresse dans le segment de code du début de son corps. Pour disposer de fonctions « dynamiques » (comme une fonction variable), il existe un dispositif qui est le pointeur de fonction : void (*Ecrire)(void) : Ecrire est un pointeur sur une fonction qui n’accepte aucun paramètre et qui ne retourne rien.
Ecrire est donc une variable contenant l’adresse d’une fonction.
L’affectation de cette variable se fait comme sur l’exemple ci-dessous :

void Ecrire_fonction(void)
{
printf("Bonjour") ;
return ;
}
void Traitement(void)
{
/* ... */
Ecrire = Ecrire_fonction;
/* ou */
Ecrire = (void (*)(void))Ecrire_fonction;
/
* caste Ecrire_fonction en un pointeur sur une fonction ne prenant pas de paramètres et ne retournant rien */
/* ... */
}

Un cast (changement de type)

C’est un mécanisme qui permet de convertir de manière explicite le type d’une valeur en un autre type.

Exemple :

int i ;
float f=10.546 ;
i=(int)f ; /* converti le réel f en entier */

Le cast (changement de type) des pointeurs

Le cast de pointeurs permet de modifier le type de l’objet référencé par une adresse.

Exemple :
t_Individu *Individu ;
t_Fonctionnaire *Fonctionnaire ;
Individu=(t_Individu *)Fonctionnaire ; /* un fonctionnaire est un individu */

Les types énumérés

Cela permet (au contrainte de #define) de définir des constantes et de les regrouper sous un même type.

Exemple :
typedef enum { VRAI=1, FAUX=0, TRUE=1, FALSE=0} e_Booleen ;

Les types structurés

Un type structuré permet de regrouper au sein d’une même entité un ensemble de propriétés cohérentes (ex : nom, prénom, civilité pour un individu). Ils sont utilisés aussi pour la construction de listes chaînées, d’arbres, …

typedef struct
{
e_Civilite Civilite;
char Nom[40];
char Prénom[40];
} t_Individu ;

…

Si le lien ne fonctionne pas correctement, veuillez nous contacter (mentionner le lien dans votre message)
Introduction à la programmation orientée objet en C (242.24 KO) (Cours PDF)