View
111
Download
5
Category
Preview:
Citation preview
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
Recommended