Algorithmique et langage C

1. Algorithmique et langage C

2. Les traitements Comment utiliser les données

3. Les procédures paramètres void start_procedure(typeB val1,typeB val2) {…} void do_procedure() {…} Les procédures sont stockées en mémoire, elles regroupent un ensemble d’instruction 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 j’ai déclaré les 3 procédures suivantes void end_procedure(typeA rototo) {…}

4. Les fonctions paramètres par référence par valeur Les fonctions sont stockées en mémoire, elles regroupent un ensemble d’instruction 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 j’exécute toto =ma_fonction(&tutu, tata,…,titi); • Donc ? tutu = tata+10 et toto = titi

5. 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);

6. La fonction mainlà ou ça commence (c’est 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 d’entré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 d’entré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

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

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

9. Les opérateurs numériques =  affectation usuelle +=  -=  *=  /=  %=  affectation +  addition -  soustraction *  multiplication /  division %  modulo Calcul 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;

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

11. Les opérateurs bit à bit >>  à droite <<  à gauche &  et |  ou ^  xor ~  non >>= <<= &= |= ^= décalage logique assignation Soit A == 3,un unsigned short int alors A << 2 donne 12 Mais si A = 65 536 A << 1 donne 0 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 (1111111111110011) Soit en décimal (12 – 216)? A == 1 A == 13 A == 12 65523

12. Les opérateurs : la priorité

13. 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 litet exécute le contenu de l'adresse du pointeur. • il incrémente le pointeur de la taille du contenu. • Il litet exécute le contenu de l'adresse du pointeur. • il incrémente le pointeur de la taille du contenu. • Il litet 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 jusqu’au plantage système ... Exemple d’instruction : a=b*c^2;

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

15. Les structures de contrôle PrimordialeLangage bas niveau (assembleur) goto (ou jump enassembleur) 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;

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

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

18. Les structures itératives début si is_car wash_it(current_car); current_car=pop(); oui non fin début wash_it(current_car); current_car=pop(); si is_car oui non À nombre d’occurrence 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); fin

19. Les structures itératives for ( i=0; {total+=car_list[i].bill;} i < nb_cars; i++) début i=0; total+=car_list[i].bill; i++; si i<nb_cars oui 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;} non fin À nombre d’occurrence connu

20. Ceux qui restent • 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 l’ité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;}

21. Les fonctions C…et les variables locale, globale Renvoi 0 Renvoi 20 Une variable globale est déclaré hors de tout bloc. Donc elle est visible de tout les blocs contenu. L’exception à la règle est que si une variable est déclaré au sein du bloc porte le même nom, c’est cette variable locale qui est utilisé short int a = 0; void fonc_qui_fait_pas_grand_chose() { long int a = 200000; 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;}

22. 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 l’on reconnait en C par le # en début de ligne. #include "nom-de-fichier"  chemin complet (C:\toto\tutu\toto.h) #include <nom-de-fichier>  nom du fichier compris dans la bibliothèque standard ( exemple : stdio.h)

23. Les macros C…les définitions et conditionnelles #define <nom> <corps> 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 l’identificateur est déjà défini en tant que macro #ifdef identificateur si l’identificateur n’est pas défini en tant que macro #ifndef identificateur sinon #else Fin condition #endif

24. 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). L’intérêt essentiel de ces modules est que l’on peut les réutiliser! il faut donc les développer pour qu’ils soient le plus réutilisable possible!!! Un module toto en C est représenté par 2 fichiers : Un fichier d’en-tête (publique)  toto.h Un fichier source (privée)  toto.c

25. Les fichiers d’en-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

26. Les fichiers sources (.c) C’est là ou l’on définit le corps des fonctions Il doit en premier lieu inclure son fichier d’en-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; }

27. 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