Cours langage c

Initiation à la programmation : Le langage C

Plan Algorithmique et programmation Présentation du langage C Variables, types et opérateurs Entrées-sorties Structures de contrôle Fonctions Structures de données complexes Entrées-sorties avancées

Caractéristiques du C Langage compilé Programmation modulaire Langage bas-niveau (bits, octets et adresses) Ecriture de systèmes d’exploitation Le C mirage de la portabilité entre machines ?

Programmation modulaire UN programme C est composé de PLUSIEURS modules Un module est un fichier .c Un module est composé de fonctions C -> Structuration des programmes

Compilation séparée Exécutable Préprocessing Compilation Edition de liens Optimisation fichier1.c fichier2.c fichier3.c fichier1.h fichier2.h fichier3.h Programme fichier1.o fichier2.o fichier3.o

Les variables Bout de mémoire réservé pour le stockage d’une donnée (nombre) Variable caractérisé par son nom et par son type Le nom répond aux conventions d’écriture Le type répond aux types définis par le C mais ses caractéristiques changent d’une machine à l’autre

Types entiers char ( character -> caractère) int ( integer -> entier) Peuvent être modifiés avec les mots clés signed , unsigned , short et long char définit une variable censée contenir un caractère ASCII. unsigned char définit un octet. Valeur entre 0;255. signed char définit un octet. Valeur entre -128;127.

Types entiers (2) int définit un entier. Il peut être signé ou pas, short ou long. L’intervalle d’un entier dépend de sa taille et donc de la machine cible de la compilation Pas de type booléen, il est remplacé par les entiers !!!

Types à virgule float (floating point -> virgule flottante) : Petit nombre à virgule double (double precision) : Deux fois plus précis qu’un float long double : Encore plus précis implémenté que sur les serveurs de calcul

Les types : La taille Pentium II Sparc Alpha char 8 bits 8 bits 8 bits short 16 bits 16 bits 16 bits int 16 bits 32 bits 32 bits long 32 bits 32 bits 64 bits float 32 bits 32 bits 32 bits double 64 bits 64 bits 64 bits long double 64 bits 64 bits 128 bits

Déclaration Toute variable doit être déclarée avant d’être utilisée Exemples de déclaration : int aVariable; int aVariable,twoVariables; unsigned long int anInteger; double aFloatingPointNumber; long double aVeryLongFloat; float aFloat,anAnotherFloat;

Les opérateurs Programme manipule des variables Trois types d’opérateurs : Unaire Binaire Ternaire

Les opérateurs (2) Problème du symbole égal a=b : a prend la valeur de b (affectation) est-ce que a est égal à b ? (égalité) En C : a=b; /* <- affectation */ a==b; /* <- test d’égalité */

Les opérateurs unaires Opérateurs arithmétiques : ++, --,+,- int increment,decrement,inverse; increment++; decrement--; Opérateur logique : ! int false,true; true=!false;

Les opérateurs unaires (2) Opérateurs divers : sizeof int sizeOfInt,sizeOfDouble; int test; sizeOfInt=sizeof(test); sizeOfDouble=sizeof(double);

Les opérateurs binaires Opérateurs arithmétique : +,-,*,/,% int a,b,c,d,e; a=5; b=12; b=b-a; c=b/a; d=b%a; e=c+d; float a,b,c,d,e; a=5.0; b=12.0; b=b-a; c=b/a;

Les opérateurs binaires (2) Opérateurs logiques : <,<=,>,>=,!=,==,&&,|| Utilisation avec une structure conditionnelle int a,b,max; a=5; b=12; if (a<b) { max=b; } else { max=a } int a,b,c; a=5; b=12; c=12; if ( (b>=a) && (b!=c) ) { b=c; }

Les opérateurs binaires (4) Opérateurs d’affectation : +=,-=,*=,/=, %= int a,b; a=1; b=32; a+=b; /* Equivalent to a=a+b; */ b*=a; /* Equivalent to b=b*a; */

Les entrées-sorties : Les flux Entrée standard stdin -> clavier Sortie standard stdout -> écran Sortie d’erreur stderr Programme C

Les entrées-sorties : Affichage à l’écran Inclure le fichier stdio.h (STandarD Input Output) printf(“format”,var1,var2,…); print formatted

Les entrées-sorties : Affichage à l’écran Exemples : printf(“Hello world !”); Encore plus fort : printf(“Hello world !\n”); int nbApples=6,nbEat=2; printf(“I’ve %d apples, I eat %d of them, it remains %d apples\n”,nbApples,nbEat, nbApples-nbEat);

Les entrées-sorties : Lecture au clavier Inclure le fichier stdio.h (STandarD Input Output) scanf(“format”,&var1,&var2,…); scan formatted

Les entrées-sorties : Lecture au clavier Exemple 1 : int nbApples; printf(“How many apples do you have ?\n”); scanf(“%d”,&nbApples); Exemple 2 : int nbApples, nbPersons; printf(“How many persons are you and how many apples do you have ?\n”); scanf(“%d %d”,&nbPersons,&nbApples);

Représentation des types Précision %e.d : e nombre de chiffres dans la partie entière d nombre de chiffres dans la partie décimale Types Format char %c int %d %x %o float ou double %f long double %Lf char[] %s

Les conditionnelles : if…else (1) if (condition) { instructions; } condition instructions vrai faux

Les conditionnelles : if…else (2) if (condition) { instructions1; } else { instructions2; } condition instructions1 vrai faux instructions2

Les conditionnelles : if…else (3) int a,b,c,d; if (a<b) { if (c<d) { instructions1; } else { instructions2; } } … … else { instructions3; }

Les conditionnelles : switch…case (1) switch (expression) { case constante1: instructions1; break; case constante2: instructions2; break; … … default: instructionsDefault; break; }

Les conditionnelles : switch…case (2) expression constante1 default ... instructionsD instructions1 instructions2

Les itérations : La boucle for Syntaxe : for (exp1;exp2;exp3) { instructions; } Toutes ces expressions influent sur la variable d’itérations qui compte le nombre d’itérations exp1 : Initialisation exp2 : Condition d’arrêt exp3 : Mise à jour

Les itérations : La boucle for vrai faux Initialisation Condition d’arrêt Mise à jour exp2 exp1 instructions exp3

Les itérations : La boucle while Syntaxe : while (condition) { instructions; } Tant que condition vraie exécuter les instructions condition instructions vrai faux

Les itérations : La boucle do…while Syntaxe : do { instructions; } while (condition) ; Exécuter les instructions tant que condition vraie condition instructions vrai faux

Les itérations Utilisation des différents types de boucles : for : boucle basée sur une variable d’itération dont on connaît a priori le début et la fin while ou do…while : boucle dont on ignore a priori quand arrivera la condition de fin Une boucle doit respecter uniquement ses conditions d’arrêt : pas de break !

Fonctions et procédures Structuration de la programmation Plus simple Modulaire Clarté de programmation Réutilisabilité -> briques de programmation

Les procédures Déclaration : void nomProcedure(listeParamètres) { DéclarationDesVariables; Instructions; } Utilisation : nomProcedure(listeParamètres);

Les fonctions Déclaration : type nomFonction(listeParamètres) { DéclarationDesVariables; Instructions; return variable; } Utilisation : type variable; variable=nomFonction(listeParamètres);

Les paramètres Paramètres en entrée Contenu d ’une variable Constante Paramètres en entrée-sortie Pointeur sur une variable

Portée des variables Deux types de variables : Globales, définies pour tout le programme Locales, définies pour une partie du programme Globales déconseillées Locales non-définies à l’extérieur de la fonction Possibilité de définition de locales pour chaque bloc de programme

Fonction particulière : main Déclaration du main : int main(int argc, char* argv[]) int main() void main() Code de retour utilisé par le programme appelant

Plan … Structures de contrôle Fonctions Structures de données complexes Tableaux Structures Pointeurs Entrées-sorties avancées

Définition Trois types de structures de données complexes : Tableaux Structures Pointeurs

Les tableaux (1) « Structure de données permettant de rassembler une suite de valeurs de même type en leur donnant un nom commun et en accédant aux valeurs de la suite par un indice »

Les tableaux (2) int anArray [7] -> 9 3 12 1 1 2 0 anArray[3] v void main() { int anArray[7]; anArray[0]=9; anArray[1]=0; anArray[2]=3; ... } 0 2 3 4 5 6 1 !

Les tableaux (3) 0 2 3 4 5 6 1 float anArray[7] -> anArray[3] v void main() { float anArray[7]={9.5,0.2,3.1,5.8,1,1.2,6}; anArray[0]=9.5; anArray[1]=0.2; anArray[2]=3.1; ... } 9.5 0.2 3.1 5.8 1 1.2 6

Les tableaux (4) Parcours de la totalité d’un tableau : #define ARRAY_SIZE 1000 for (i=0;i<ARRAY_SIZE;i++) { … }

Les tableaux (5) Recherche dans un tableau : #define ARRAY_SIZE 1000 void main() { int searchingArray[ARRAY_SIZE]; int element,i=0; initialization(searchingArray,&element,ARRAY_SIZE); while((i< ARRAY_SIZE) && (searchingArray[i]!=element)) i++; if (i== ARRAY_SIZE) printf("Element %d not found !\n",element); else printf("Element %d found at indice %d\n" ,element,i); }

Les tableaux (6) Tableaux et fonctions Passage de paramètres void readMarks(float markArray[], int nbMark) Utilisation dans la fonction: markArray[3]=9.75 Appel : readMarks(GTR1Marks,nbStudentGTR1);

Les tableaux (7) Résumé : Parcours de tous les éléments du tableau -> boucle for Parcours partiel d’un tableau en connaissant les bornes inférieures et supérieures -> boucle for Parcours partiel d’un tableau lorsque la borne supérieure ou inférieure n’est pas connue -> boucle while ou do…while

Les chaînes de caractères Chaîne de caractères -> tableau spécial o l l e h Chaîne de caractères Tableau de caractères Fin de chaîne Attention prévoir un caractère de plus pour le \0 !!! \0 o l l e h

Les chaînes de caractères (2) Ordinateur ne comprend que le binaire Représentation des caractères par un nombre entier : c ’est l ’ASCII ASCII : American Standard Code for Information Interchange Tableau de correspondance entre lettre et représentation ASCII -> table ASCII

Les chaînes de caractères (3) l’ASCII Proposé par l ’ANSI (AN Standards Institute) en 1963, finalisé en 68, utilisé à partir de 80 Créé par Bob Bemer d’IBM Codage sur 7 bits avec en plus l’ escape caracter 32 premiers caractères sont des caractères de contrôle (7 est une sonnerie, 8 effacement du caractère précédent, 13 retour à la ligne, …)

Les chaînes de caractères (3) l’ASCII Exemple de codage ASCII : Notation ASCII décimale Notation humaine Notation ASCII hexadécimale 104 101 108 108 111 0 h e l l o \0 68 65 6C 6C 6F 0

Les chaînes de caractères (4) l’ASCII C ’est l ’ordinateur qui gère la conversion Utiliser de préférence la notation humaine (c ’est plus clair pour les humains…) ‘ A’ est équivalent à 65, ‘a’ à 97, etc. Ex : char mLetter=‘a’+12;

Les chaînes de caractères (2) 0 2 3 4 5 1 char aString [6] -> aString[3] v #include <string.h> void main() { char aString[6]= "hello\0" ; aString[0]=‘h’; aString[1]=‘e’; ... strcpy(aString, "hello" ); } \0 o l l e h

Les chaînes de caractères (3) Initialisation d’une chaîne : Lors de la déclaration Element par élément Fonctions dédiées : scanf (stdio.h) strcpy (string.h)

Les chaînes de caractères (4) Affichage avec printf : printf(“%s\n”,myString);

Les chaînes de caractères (5) Les fonctions standard Longueur : length=strlen(myString); Copie : strcpy(myString,”hello”); Concaténation : strcat(myString,”lo”); Comparaison : strcmp(string1,string2); Transformation en entier : integer=atoi(myString); Transformation en flottant : floatingPoint=atof(myString);

Les tableaux à plusieurs dimensions 2 dimensions Déclaration : int matrix[LINE_SIZE][COL_SIZE]; Utilisation : matrix[4][3]=4; 3 dimensions Est-ce bien utile ?

Structures en C Tableau : ensemble de valeurs de même type Structure : ensemble de valeurs de types différents Une structure s’utilise comme un type de données

Structures : Définition struct Student { char firstName[50]; char lastName[50]; int age; }; int main() { struct Student toto; toto.age=19; return 0; } Champ Définition de la structure Ne pas oublier le ; Déclaration d’une variable Accès aux champs avec .

Structures : Définition Définition globale ou dans le header (.h) mot-clef struct devant la déclaration de variable (possibilité d’utiliser un typedef) . est l ’opérateur d ’accès aux champs

Structures : Imbrication struct Date { int jour,mois,annee; }; struct Etudiant { char nom[50]; char prenom[50]; int age; struct Date dateInscription; }; int main() { struct Etudiant toto; toto.dateInscription.jour=1; return 0; }

Tableaux de structures struct Etudiant { char nom[50]; char prenom[50]; int age; }; int main() { struct Etudiant gtr1[50]; gtr1[0].age=19; return 0; }

Plan Introduction à la notion de pointeurs Pointeurs et tableaux Passage de paramètres avec les pointeurs Structures dynamiques Conclusion

Utilité des pointeurs Tableaux alloués à la demande (allocation dynamique) Passages de paramètres par adresse Structures dynamiques

Définition Nouveau type de données Son contenu est une adresse mémoire Adresse mémoire "pointe" sur une autre variable -> "pointeur"

Notation Déclaration d'un pointeur : <type pointé>* <nom du pointeur> Opérateurs : Indirection (*) Référence (&) Attention <type>* est différent de * !!!

Représentation en mémoire Mémoire 18971 18979 18994 19002 18986 18984 int a; int* pointeurSurA; a=5; pointeurSurA=&a; 18994 5 pointeurSurA a

Pointeurs sur données Utilisation d'une variable déjà allouée pointeurSurDonnee=&variable; Allocation de mémoire pointeurSurDonnee=(int*)malloc(sizeof(int)); Libération de mémoire free(pointeurSurDonnee);

Affectations Affectation de pointeurs pointeur1=pointeur2; Affectation d'une valeur pointée variable=*pointeur; Affectation de rien pointeur=NULL;

Exemples (1) a désigne le contenu de a, 5 &a désigne l’adresse de a pointeurSurInt désigne l’adresse de a *pointeurSurInt désigne le contenu de a, 5 int a=5; int* pointeurSurInt; pointeurSurInt=&a;

Exemples (2) int main(int argc, char* argv[]) { int a,b; int* pointeurSurA; pointeurSurA=&a; b=a+1; /* ou b=*pointeurSurA+1 */ a=b*4; /* ou *pointeurSurA=b*4; a++; /* ou (*pointeurSurA)++; }

Tableaux et pointeurs Un tableau peut être géré avec des pointeurs Déclaration Allocation Accès Il y a un avantage pour la déclaration et l'allocation pas pour l'accès

Tableaux et pointeurs : Adressage Les formes suivantes sont équivalentes : &tableau[0] et pointeurSurInt tableau[i] et *(pointeurSurInt+i) pointeurSurInt++ passe à la case suivante Attention à ne pas vous embrouiller ! int tableau[100]; int* pointeurSurInt; pointeurSurInt=tableau;

Tableaux et pointeurs : Adressage int tableau[100]; int* pointeurSurInt; pointeurSurInt=tableau; /* ou pointeurSurInt=&tableau[0]; */ for (i=0;i<100;i++) tableau[i]=0; /* ou *(pointeurSurInt+i)=0; */ while (pointeurSurInt!=&tableau[99]) { *pointeurSurInt=0; pointeurSurInt++; } int tableau[100]; int* pointeurSurInt; pointeurSurInt=tableau; /* ou pointeurSurInt=&tableau[0]; */

Tableaux et pointeurs : Allocation dynamique Allouer de la mémoire suivant les besoins de l’utilisateur Trois principales fonctions : void* malloc(size_t size); void* calloc(size_t nmemb, size_t size); void free(void* ptr);

Tableaux et pointeurs : Allocation dynamique int main(int argc, char* argv[]) { int* tableau; int nombreCases; nombreCases=atoi(argv[1]); tableau=(int*)malloc(nombreCases*sizeof(int)); free(tableau); }

Tableaux et pointeurs : Tableaux à 2 dimensions Un tableau à 2 dimensions est un tableau de tableaux int tableau[2][3]={ {0,1,2}, {3,4,5} }; tableau[0] c ’est {0,1,2} tableau[1] c ’est {3,4,5}

Tableaux et pointeurs : Tableaux à 2 dimensions Déclaration statique : int tableau[4][10]; Déclaration et affectation dynamique : int main(int argc, char* argv[]) { int** tableau; int i; tableau=(int**)malloc(NB_COLONNES*sizeof(int*)); for (i=0;i<NB_COLONNES;i++) tableau[i]=(int*)malloc(NB_LIGNES*sizeof(int)); }

Passage de paramètres 2 modes de passages de paramètres à une fonction : Passage par recopie (par valeur) Passage par adresse Passage par adresse se fait par pointeur

Passage de paramètres void main() { int a,b; a=5; fonction(a,&b); } void fonction(int parRecopie, int* parAdresse) { parRecopie=10; *parAdresse=15; }

Structures dynamiques : Définition Structure de données dont la taille change au cours de l'exécution du programme Différent des tableaux qui ont une taille fixe Exemple : listes chaînées, listes doublement chaînées, etc.

Structures et pointeurs Pointeur sur structure : Passage par adresse dans une fonction Déclaration d ’un pointeur sur structure Les informaticiens sont paresseux : (*pointeurStructure).champ=5; pointeurStructure->champ=5;

Structures et pointeurs struct Etudiant { char nom[50]; char prenom[50]; int age; }; int main() { struct Etudiant toto; initialisation(&toto); return 0; } void init(struct Etudiant* initE) { (*initE).age=15; /* initE->age=15; */ }

Listes chaînées : Principe Structure contenant des données et un pointeur sur l'élément suivant Représentation : Racine Données Pointeur Données Pointeur

Listes chaînées : Principe Définition d’un élément de la liste : struct elementListeChainee { int donnee; struct elementListeChainee* elementSuivant; } La liste chainée est juste une succession d’éléments

Listes chaînées : Insertion Insertion d’un élément : Racine Données Pointeur Données Pointeur Données Pointeur

Listes chaînées : Destruction Destruction d’un élément : Racine Données Pointeur Données Pointeur Racine Données Pointeur

Listes chaînées : Avantages/inconvénients Complètement dynamique Gestion plus compliquée qu'un tableau Surcoût mémoire dû aux pointeurs Un seul sens !

Listes doublement chaînées : Principe Structure contenant des données, un pointeur sur l'élément suivant et sur l'élément précédent Ex : struct elementListeChainee { int donnee; struct elementListeChainee* elementPrecedent; struct elementListeChainee* elementSuivant; }

Listes doublement chaînées : Insertion Insertion d’un élément : Racine Données Pointeur Pointeur Données Pointeur Pointeur Données Pointeur Pointeur Données Pointeur Pointeur

Listes doublement chaînées : Destruction Destruction d’un élément : Racine Données Pointeur Pointeur Données Pointeur Pointeur Données Pointeur Pointeur

Conclusion Pointeurs incontournables Aspect le plus difficile du C Notation et déclaration peu claire Utilisation principale : Passage de paramètres Tableaux dynamiques Structures dynamique

Accès aux fichiers Ouverture d’un fichier : FILE* fopen(char* name, char* mode); Fermeture d’un fichier : int fclose(FILE* fileDes);

Lecture Caract è re par caractère : int getc(FILE* fileDes); Lit une chaine de caractères char* fgets(char* s,int size,FILE* fileDes); Lecture formatée : int fscanf(FILE* fileDes, char* format, variables...);

Lecture (2) Lecture en vrac : size_t fread(void* ptr,size_t size,size_t nmemb,FILE* fileDes);

Ecriture Caract è re par caractère : int fputc(int c,FILE* fileDes); Ecriture d’une chaine de caractères int fputs(const char* s,FILE* fileDes); Ecriture formatée : int fprintf(FILE* fileDes, const char* format, variables...);

Ecriture (2) Ecriture en vrac : size_t fwrite(const void* ptr,size_t size,size_t nmemb,FILE* fileDes);

Ecriture Ecriture dans un fichier : int putc(FILE* fileDes);

Plan ... Entrées-sorties Structures de contrôle Fonctions Structures de données complexes Entrées-sorties avancées Bêtisier Conclusion

Bêtisier Erreurs de programmation les plus souvent rencontrées Ne provoquent pas d ’erreur de compilation Assez difficiles à trouver

Bêtisier if ( a = b ) if ( a == b); if ( a > b ) if ( x > y ) x = y; else ...

Bêtisier (2) #define MAX =10 #define MAX 10; gcc test.c -o test for (i=0;i<=TAILLE_TABLEAU;i++) for (i=0;i!=MAX;i++) i++;

Conclusion Première expérience de la programmation C langage système -> pas assez strict pour un premier langage Base des langages

Cours langage c

Contenu connexe

Tendances

Similaire à Cours langage c

Plus de coursuniv

Dernier

Cours langage c

Notes de l'éditeur