# C Les structures, les fonctions, les pointeurs ça vous fait rêver ? Bienvenue dans le langage C ! # [C] Kit de base ## [![formation-langage-c-avance.jpg](https://wiki.neopipe.fr/uploads/images/gallery/2023-07/scaled-1680-/i8Cformation-langage-c-avance.jpg)](https://wiki.neopipe.fr/uploads/images/gallery/2023-07/i8Cformation-langage-c-avance.jpg) ## Introduction Le langage C est un langage de bas niveau qui doit être compilé avant d'être exécuté. ## Variables En C, les variables ont 4 caractéristiques : - Un **type** (int, float, char ou void) - Un **identifiant** (un nom). - Une **valeur** (correspondant au type). - Une **adresse mémoire** (en hexadécimale). Voici les différents types de variables avec leur taille associé en octet ainsi que leurs valeur minimum et maximum : [![Types de variables.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-09/scaled-1680-/types-de-variables.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-09/types-de-variables.png) #### Déclaration - Entier : ```c int myInteger = 0; ``` - Flottant : ```c float myFloat = 26.34; ``` - Caractère : ```c char myChar = 'J'; ``` ```c // Avec le code ASCII (caractère 'A') char myChar = 65; ``` - Chaîne de caractères (tableau de char terminant par '\\0') : ```c char name[256]="Elieroc"; ``` - Tableau : ```c int monTableau[5]={1, 4, 7}; ``` - Constante (en majuscule) : ```c const float PI = 3.14; ``` - Statique (la valeur reste en mémoire après avoir quittée la fonction appelante) : ```c static int maVariableStatique = 2; ``` - Préprocesseur (constante dont la valeur est remplacée par le compilateur lors de la compilation) : ```c #define LONGUEUR (15) ``` ## Bibliothèques - Standard : ```c #include ``` - Standard Input/Output : ```c #include ``` - String (pour les chaînes de caractères : ```c #include ``` Assert (pour les vérifications) : ```c #include ``` ## Fonctions #### Déclaration / Implémentation En C, on distingue le prototype d'une fonction de son implémentation. Le prototype n'est pas indispensable mais utile lorsqu'on souhaite implémenter les fonctions après la fonction main par exemple. - Prototypage : ```c float calculator(float op1, float op2); ``` - Implémentation : ```c float calculator(float op1, float op2){ return op1 + op2; } ``` #### Type et valeur de retour Chaque fonction a un type qui doit correspondre à sa valeur de retour : ```c int myFunc(){ return 3; } ``` Cette valeur de retour peut être stockée dans une variable : ```c myVar=myFunc(); // '3' ``` #### Main Tout programme en langage C présente la fonction main qui sera naturellement appelée lors de l’exécution du programme : ```c int main(){ return 0; } ``` #### Printf La fonction **printf()** permet d'afficher des éléments dans la sortie standard (souvent il s'agit de la console). ```c printf("Hello world !"); ``` Elle prend en charge les flags pour afficher des variables : ```c printf("Mon entier : %d et mon flottant : %f \n", myInt, myFloat); ``` Remarque : On notera la présence du caractère '\\n' pour marquer le retour à la ligne. #### Scanf La fonction scanf() permet de récupérer des éléments de l'entrée standard (souvent il s'agit du clavier). Ici, la valeur est transmise dans la variable *myInt* : ```c scanf("%d", &myInt); ``` Remarque : Il fonctionne avec les flags comme *printf*. ## Commentaires Commentaire sur une seule ligne : ```c // Mon commentaire ``` Commentaire sur plusieurs lignes : ```c /* Mon commentaire en plusieurs lignes */ ``` ## Cast (transtypage) - Passer d'un flottant à un entier : ```c int myInteger = (int)myFloat; ``` ## Les flags Pour certaines fonctions, il peut être nécessaire d'utiliser des flags (ex : printf ou scanf). Voici la liste des flags les plus courants :
**Flags** **Types de variables**
%d int
%f float
%c char
%s string
## Les conditions ##### If ```c int niveau = 18; if (niveau < 5 || niveau == 18) { printf("Yop"); } ``` #### If / Else ```c int niveau = 18; if (niveau < 5 || niveau == 18) { printf("Yop"); } else { printf("Hoho"); } ``` #### Switch ```c int age = 18; switch(age) { case 18: printf("Tu as la majorité !"); break; case 100: printf("Tu es centenaire !"); break; default: break; } ``` #### Ternaire ```c int age = 16; (age == 15) ? printf("tu as 15 ans") : printf("Interdit pour toi"); ``` ## Les boucles #### While ```c int i = 0; while (i<10){ printf("Waou !\n"); i++; } ``` #### For ```c int i; for (i = 0 ; i<5 ; i++){ printf("Ce message est affiché 5 fois\n"); } ``` - Parcourir un tableau : ```c int monTableau[5]; for (int i = 0 ; i < 5 ; i++) { monTableau[i] = i*3; } ``` ## Tableaux Les tableaux en langage C ne sont capables de stocker qu'un seul type de valeur et ont une longueur prédéfinie. Par exemple, voici la déclaration d'un tableau de 5 entiers : ```c int mon_tableau[5] = {3, 5, 9, -6, -2}; ``` On peut parcourir chaque éléments du tableau avec des boucles : ```c for (int i = 0 ; i < 5 ; i++) { mon_tableau[i] = i*3; } ``` Remarque : La mention de l'identifiant d'un tableau dans le code fera référence à l'adresse du premier élément de celui-ci. On peut aussi déclarer des tableaux double dimensions : ```c int tableau_deux_dimensions[5][3] = { {4, 6, -1}, {-2, 6, 7}, {8, 5, 0}, {4, 3, 6}, {7, -9, 2} }; ``` Pour parcourir un tableau à deux dimensions et afficher les valeurs contenues : ```c for (int i = 0 ; i < 5 ; i++) { for (int j = 0 ; j < 3 ; j++){ printf("[%d]", tableau_deux_dimension[i][j]); } printf("\n"); } ``` ## Pointeurs Un pointeur est une variable qui stocke une adresse mémoire. #### Déclaration ```c int nb1 = 5; int *pt_nb1 = &nb1; ``` #### Utilisation - Le caractère **&** placé devant l'identifiant de la variable fait référence à l'adresse de celle-ci. - Le caractère **\*** placé devant l'identifiant de la variable fait référence à la valeur stockée dans la variable derrière le pointeur. ```c void exchange(float*nombreA, float*nombreB) { float tmp = *nombreB; *nombreB = *nombreA; *nombreA = tmp; } int main(){ float nombreA = 6.8; float nombreB = 9.45; printf("A = %.2f | B = %.2f\n", nombreA, nombreB); exchange(&nombreA, &nombreB); printf("A = %.2f | B = %.2f", nombreA, nombreB); return 0; } ``` #### Malloc La fonction **malloc()** permet d'allouer de l'espace mémoire pour une variable. Elle prend en paramètre la taille désirée du bloc mémoire en octet et renvoie l'adresse de ce bloc mémoire. #### Free La fonction **free()** permet de libérer l'espace mémoire pris par une variable. Elle prend en paramètre l'adresse du bloc mémoire de la variable à libérer et retourne *NULL*. ## Structures Les structures sont des variables complexes dont les caractéristiques sont fixées par le développeur. Elles sont l'ancêtre de l'objet et présente donc de grandes similitudes. Voici la syntaxe de la structure : ```c struct