Voici donc la suite de la première partie, nous verrons ici à utiliser les typedef et à créer des énumérations.
1 – Typedef
En langage C, il est possible de créer des synonymes de types. Cela peut nous éviter d’avoir à recoder une partie de code répétitive. On peut faire cela grâce au mot-clé typedef de cette manière ci :
Code c:
typedef Type SynonymeDuType;
En fait on crée ici un synonyme du type Type, les deux deviennent alors interchangeable. Ainsi si l’on souhaite créer un synonyme du type int (sans gros intérêt certes mais c’est pour l’exemple ), et bien il faudrait faire comme cela :
Code c:
typedef int synonymeDeInt;
Les deux types devenant interchangeable, rien ne empèche maintenant d’écrire :
Code c:
synonymeDeInt variable = 10;
qui reviendra donc à écrire :
Code c:
int variable = 10;
Mais là ou le typedef devient intéressant c’est qu’il nous permet de créer un synonyme d’une structure, ce qui évite d’avoir sans cesse à réécrire le mot clé struct.
Ainsi le code de la première partie deviendra :
Code c:
struct MaStructure {
int var1;
long var2;
double varN;
}var3;
typedef struct MaStructure MaStructure;
/* On créer notre synonyme */
void fonction(struct MaStructure *maStructure);
int main()
{
MaStructure maStructure;
/* On utilise le synonyme donc plus besoin du mot-clé struct */
fonction(&maStructure);
printf(« %dn », maStructure.var1);
printf(« %ldn », maStructure.var2);
printf(« %lfn », maStructure.varN);
return EXIT_SUCCESS;
}
/* Plus besoin de struct ici aussi */
void fonction(MaStructure *maStructure)
{
maStructure->var1 = 10;
maStructure->var2 = 40000;
maStructure->varN = 12.5;
}
Il faut bien penser à créer le synonyme juste après la déclaration de la structure pour ne pas avoir à rajouter le mot clé struct.
Voilà vous savez maintenant utiliser typedef pour créer des synonymes.
2 – Les énumérations
Le langage C nous permet aussi de créer ce que l’on appel des énumérations. En fait il s’agit simplement de créer des constantes qui prendront des valeurs définies (entières si on ne le précise pas). Ces valeurs pourront être ensuite utilisée dans notre programme. Voici comment créer une énumération.
Code c:
enum nomDeLEnumeration {Constante1, Constante2, ConstanteN};
Ces constantes seront donc remplacées par des valeurs à la compilation. Si on ne précise pas ces valeurs alors la premières constante prendra la valeur 0, la deuxième la valeur 1 et ainsi de suite.
Dans notre énumération Constante1 sera donc égal à 0, Constante2 = 1 et ConstanteN = N-1 (ici 2). Si l’on souhaite définir nous-même les valeurs il suffit de l’indiquer à l’aide du signe égal.
Code c:
enum Plan {X, Y = 3, Z};
Ici X prendra la valeur 0 car on n’a pas spécifié de valeurs, Y prendra la valeur 3 et Z prendra la valeur 4 et non 1 ou 2. Car une constante non-défini suivant une qui est définie dans une énumération prend comme valeur celle de la constante qui la précède à laquelle on ajoute 1. Donc ici Z sera bien égal à 4. (car 3+1).
Utilisons maintenant ces constantes dans notre programme, mais avant créer un synonyme de votre énumération car tout comme pour une structure, il faut utiliser un mot-clé pour utiliser une énumération (enum)
Code c:
enum Plan {X, Y = 3, Z};
typedef enum Plan Plan;
int main()
{
Plan var1 = X;
Plan var2 = Y;
Plan var3 = Z;
printf(« var1 = %dn », var1);
printf(« var2 = %dn », var2);
printf(« var3 = %d », var3);
return EXIT_SUCCESS;
}
On peut aussi utiliser nos constantes dans un switch par exemple :
Code c:
enum Plan {X, Y = 3, Z};
typedef enum Plan Plan;
int main()
{
Plan var4 = Z;
switch(var4)
{
case X : printf(« var4 vaut X »); break;
case Y : printf(« var4 vaut Y »); break;
case Z : printf(« var4 vaut Z »); break;
default : printf(« Erreur ! »); break;
}
return EXIT_SUCCESS;
}
Code console:
var4 vaut Z
Voilà vous savez maintenant comment utiliser les énumérations.
Dans la prochaine partie nous parlerons plus en détail de la mémoire vive et le langage C et vous apprendrez que ce que je vous disais au début sur celle-ci n’est pas totalement vrai
Nous verrons aussi comment créer une union.