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

paramètres

void start_procedure(typeB val1,typeB val2) {…}

void do_procedure() {…}

void end_procedure(typeA rototo) {…}

Les fonctionsLes 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 ?

paramètres

par référence par 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 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

afficParamEntree.exe

Les opérateursles 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

Les opérateurs du langage C

& obtention de l’adresse

* indirection

-> sélection dans l’objet 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 l’inverse 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 (1111111111110011)

Soit en décimal (12 – 216)?

Soit A == 3, un unsigned short int alors A << 2 donne

12

Mais si A = 65 536 A << 1 donne

0

>>= <<=&=|=^=

assignation

65523

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 jusqu’au plantage système ...

Exemple d’instruction : a=b*c^2;

Les instructions en Cvide

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 PrimordialeLangage 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 binaireif (is_car)

{wash_it();}

else

{stop_procedure();}

si is_car wash_it();oui

stop_procedure();

non

début

fin

Les structures conditionnelles

• Condition analogiqueswitch (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

oui

oui

début

fin

À 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);

oui

Les structures itératives

si is_carwash_it(current_car);

current_car=pop();

non

début

fin

wash_it(current_car);current_car=pop();

début

si is_caroui

non

fin

À nombre d’occurrence 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 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;}

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.

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;}

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 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)

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

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

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

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;

}

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