Algorithmique et langage C

Les traitements Comment utiliser les données

Les procédures Les procédures sont stockées en mémoire, elles regroupent un ensemble dinstruction en prenant des entrées (appelées passage de paramètre). Elles se déclarent comme suit (en C) void ma_procedure(typeB val1,typeB val2,…,typeA valN) { start_procedure(val1,val2); do_procedure(); end_procedure(valN); return; } Cela veut dire que jai déclaré les 3 procédures suivantes paramètres void start_procedure(typeB val1,typeB val2) {…} void do_procedure() {…} void end_procedure(typeA rototo) {…}

Les fonctions Les fonctions sont stockées en mémoire, elles regroupent un ensemble dinstruction en prenant des entrées (appelées passage de paramètre) et générant des sorties. Elles se déclarent comme suit (en C) typeA ma_fonction(typeB *val1,typeB val2,…,typeA valN) { val2+=10; *val1=val2; return valN; } Alors quand jexécute toto =ma_fonction(&tutu, tata,…,titi); Donc ? paramètres par référencepar valeur tutu = tata+10 et toto = titi

Les fonctions… et les pointeurs (encore je sais… ) Soit la déclaration suivante typeA (*ptr_fonction) (typeB *val1,typeB val2,…,typeA valN); Alors je peux écrire ptr_fonction = &ma_fonction; Du coup quand je fais toto= (*ptr_fonction)(&tutu, tata,…,titi); Donne le même résultat que toto= ma_fonction(&tutu, tata,…,titi);

La fonction main là ou ça commence (cest pas trop tôt!!!) int main(int argc, char *argv[]) { cout << argv[0] << endl; system("PAUSE"); return EXIT_SUCCESS;} La fonction main admet 2 paramètres dentrées : argc est le nombre déléments du tableau de pointeur argv : Le premier élément (argv[0]) est le nom complet du fichier exécuté (c:\...\toto.exe) Les autres sont déterminer par les commandes passés en paramètre dentrée (faire cmd.exe) La fonction main retourne un entier : zéro si tout vas bien (représenté par EXIT_SUCCESS) sinon un code erreur

Les opérateurs les opérateurs permettent lassociation de variable renvoyant des valeurs ou les affectant ( = ) dans des lvalue (location value ou left value). elle peuvent être positionné à gauche et/ou à droite dune affectation. type simple (pointeur y compris) structure union alors que lon ne peut rien affecter dans les rvalue (read value ou right value). elle ne peuvent être positionné quà droite dune affectation. constante tableau fonction

Les opérateurs du langage C & obtention de ladresse * indirection -> sélection dans lobjet pointé pointeur sizeof(type) donne la taille de type (type) casting (expliqué précédemment). sélection dans objet [ ] indexation ( ) fonction, séquence type

Les opérateurs numériques + addition - soustraction * multiplication / division % modulo Calcul = affectation usuelle += -= *= /= %= affectation A ?= B; est la contraction de A = A ? B; ++ incrément -- décrément affectation (in/de)crémentation Appliqué à un élément, exemple A ++; veut dire A=A+1;

logique Les opérateurs booléens > supérieur à < inférieur à <= sup ou égal à >= inf ou égal à == égal à != différent de Comparaison && et || ou association ! non réflexion Entre 2 éléments, exemple A == A renvoi vrai Renvoi linverse de lélément, exemple !(A == A) renvoi faux

Les opérateurs bit à bit >> à droite << à gauche décalage & et | ou ^ xor ~ non logique Soit A un unsigned short int A = 5 & 9; (101 et 1001) donne A = 5 | 9; (101 ou 1001) donne A = 5 ^ 9; (101 xor 1001) donne A = ~ A=12; (1100) donne ( ) Soit en décimal (12 – 2 16 )? Soit A == 3, un unsigned short int alors A << 2 donne 12 Mais si A = A << 1 donne 0 >>= <<= &= |= ^= assignation A == 1 A == 13 A == 12

Les opérateurs : la priorité

Les instructions Les instructions sont stockées en mémoire. (chaque instruction a son adresse) le processus enchaîne les instructions grâce à une tête de lecture (un pointeur encore) : Il lit et exécute le contenu de l'adresse du pointeur. il incrémente le pointeur de la taille du contenu. Il lit et exécute le contenu de l'adresse du pointeur. il incrémente le pointeur de la taille du contenu. Il lit et exécute le contenu de l'adresse du pointeur. il incrémente le pointeur de la taille du contenu. … … jusqu'à la fin des instructions (si une fin réelle existe bien sûr). Ou jusquau plantage système... Exemple dinstruction : a=b*c^2;

Les instructions en C vide expression bloc goto if switch ou-case while do for break continue return {…}{…} expression; ; goto etiquette; if (condition) instruction [else instruction] while (condition) instruction do instruction while (condition) for (init;loop;end) instruction break; continue; return instruction switch (valeur) {ou-case … ou-case} case constante: instruction default : instruction

Les structures de contrôle Primordiale Langage bas niveau (assembleur) goto (ou jump en assembleur) vers une adresse A (appelée étiquette) on affecte l'adresse A dans la tête de lecture du processus. En assembleur, il est assortie d'une condition booléenne –Valeur1 plus grande/petite que valeur2. –Valeurs égales. L'assembleur propose un mélange bigarré de ces « saut conditionnel ». En C on le déclare comme suit … mon_etiquette: … goto mon_etiquette;

Les structures conditionnelles Condition binaire if (is_car) {wash_it();} else {stop_procedure();} si is_car wash_it(); oui stop_procedure(); non début fin

Les structures conditionnelles Condition analogique switch (type_car) { case "VIP" : gloss_it(); case "MIP","VIP" : {aspire_in();break;} case "economic" : break; default : alert_security();} Si VIP Si MIP ou VIP Gloss_it(); Si economic aspire_in(); alert_security(); oui début fin

À nombre doccurrence inconnu while (current_car.is_car) { wash_it(current_car); current_car = pop();} ou do { wash_it(current_car); current_car = pop();} while (is_car); oui Les structures itératives si is_car wash_it(current_car); current_car=pop(); non début fin wash_it(current_car); current_car=pop(); début si is_car oui non fin

À nombre doccurrence connu for ( Les structures itératives total+=car_list[i].bill; début si i<nb_cars oui non fin i=0; i++; i < nb_cars; i=0;{total+=car_list[i].bill;} i++) Pour info : certains langage dont le php permettent des boucles sur un tableau : Foreach($car_list as $ptr_list => $car) { $total+=$car.bill;} ou $total+=$car_list[$ptr_list].bill;}

Vide rien à faire : for(;i!=end;i++) Bloc un bloc permet de mettre plusieurs instructions : { int i=10; char toto;} Continue ramène au début de litération suivante : For (int i =0;i<max;i++) { if (tab[i] == null) continue; *tab[i] = tab2[j]; j++;} return permet de retourner une valeur de fonction : int fonction_qui_renvoit_1() { return 1;} Ceux qui restent

Les fonctions C… et les variables locale, globale Une variable globale est déclaré hors de tout bloc. Donc elle est visible de tout les blocs contenu. Lexception à la règle est que si une variable est déclaré au sein du bloc porte le même nom, cest cette variable locale qui est utilisé short int a = 0; void fonc_qui_fait_pas_grand_chose() { long int a = ; return;} void fonc_qui_fait_un_peu_plus() { a = 20; return;} int main(int argc,char *argv[]) { fonc_qui_fait_pas_grand_chose(); cout << a << endl; fonc_qui_fait_un_peu_plus(); cout << a << endl << endl; system("PAUSE"); return EXIT_SUCCESS;} Renvoi 0 Renvoi 20

Les macros C… et le préprocesseur Le préprocesseur agit avant le compilateur. Il découpe, remplace et associe les divers fichiers du programme en un fichier global compilable. Il le fait par les macros que lon reconnait en C par le # en début de ligne. #include "nom-de-fichier" chemin complet (C:\toto\tutu\toto.h) #include nom du fichier compris dans la bibliothèque standard ( exemple : stdio.h)

Les macros C… les définitions et conditionnelles #define qui remplace tout nom présent dans le code pour le remplacer par corps, exemple : #define PI (22/7.0) On peut aussi définir des paramètres variables comme si dessous : #define INIT_PTR(type) ((type *) malloc(sizeof(type))) si lidentificateur est déjà défini en tant que macro #ifdef identificateur si lidentificateur nest pas défini en tant que macro #ifndef identificateur sinon #else Fin condition #endif

Les modules Les modules fournissent des ensembles de fonctions cohérent traitant un sujet spécifique. Cela permet de fractionner le fonctionnement du processus en unité fonctionnelle (interfaçage avec BDD, fonctions mathématiques, batch processing…) On peut regrouper des modules pour donner un package (logiciel, plugin). Lintérêt essentiel de ces modules est que lon peut les réutiliser! il faut donc les développer pour quils soient le plus réutilisable possible!!! Un module toto en C est représenté par 2 fichiers : Un fichier den-tête (publique) toto.h Un fichier source (privée) toto.c

Les fichiers den-tête (.h) Il comporte les définitions des fonctions utilisables ainsi que celles des macro et des structures. Il comporte des lignes de macro prévenant la double inclusion du fichier : #ifndef TOTO_H #define TOTO_H … int fonction_toto(void *ptr); #define tutu(riri,fifi,loulou) riri fifi[loulou]; typedef struct voiture { int type_car; char *name_car;} VOITURE; … #endif

Les fichiers sources (.c) Cest là ou lon définit le corps des fonctions Il doit en premier lieu inclure son fichier den-tête : #include "toto.h" Il doit ensuite écrire le corps des fonctions déclarées précédemment int fonction_toto(void *ptr) { int blabla = 0; int *merguez=&blabla; void *ptr_a_blabla = (void *)merguez; return *(int *)ptr_a_blabla; }

Liste des mots clef auto break case char const continue default do double else enum extern float for goto if int long register return short signed sizeof static struct switch typedef union unsigned void volatile while