• Like
  • Save
Cours langage c
Upcoming SlideShare
Loading in...5
×

Cours langage c

  • 4,662 views
Uploaded on

par : http://coursuniversite.com …

par : http://coursuniversite.com
Cours langage c

More in: Education , Business
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
  • Nice Coures c'est bon
    Are you sure you want to
    Your message goes here
No Downloads

Views

Total Views
4,662
On Slideshare
0
From Embeds
0
Number of Embeds
0

Actions

Shares
Downloads
0
Comments
1
Likes
14

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide
  • exemple du grep : tant qu’il y une ligne si cette ligne contient le modèle l’afficher
  • Exemples de fonctions --------------------- int max(int a,int b) /* fonction avec 2 args en mode in */ { int maxAB; /* maxAB n'est definie que dans max */ if(a>b) { maxAB=a; } else { maxAB=b; } return(maxAB); /* retour obligatoire de la fonction du meme type que max */ } Exemples de procedures ---------------------- void impNumero(int num) /* procedure d'affichage d'un entier */ { printf("­­­­­%d­­­­­\\n",num); } /* PAS de return */ void dessineCarre(int x,int y, int cote) { ... /* dessine un carre a l'ecran */ } void echange(int *a, int *b) /* procedure d'echange des valeurs de deux variables (mode in­out) */ { int temp; /* temp n'est definie que dans echange */ temp=*a; /* on utilise * pour acceder a la valeur */ *a=*b; /* on utilise * pour modifier la valeur */ *b=temp; }

Transcript

  • 1. Initiation à la programmation : Le langage C
  • 2. 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
  • 3. 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 ?
  • 4. 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
  • 5. 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
  • 6. 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
  • 7. 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.
  • 8. 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 !!!
  • 9. 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
  • 10. 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
  • 11. 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;
  • 12. Les opérateurs
    • Programme manipule des variables
    • Trois types d’opérateurs :
      • Unaire
      • Binaire
      • Ternaire
  • 13. 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é */
  • 14. Les opérateurs unaires
    • Opérateurs arithmétiques : ++, --,+,-
    • int increment,decrement,inverse;
    • increment++;
    • decrement--;
    • Opérateur logique : !
    • int false,true;
    • true=!false;
  • 15. Les opérateurs unaires (2)
    • Opérateurs divers : sizeof
    • int sizeOfInt,sizeOfDouble;
    • int test;
    • sizeOfInt=sizeof(test);
    • sizeOfDouble=sizeof(double);
  • 16. 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;
  • 17. 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; }
  • 18. 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; */
  • 19. 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
  • 20. Les entrées-sorties : Les flux Entrée standard stdin -> clavier Sortie standard stdout -> écran Sortie d’erreur stderr Programme C
  • 21. Les entrées-sorties : Affichage à l’écran
    • Inclure le fichier stdio.h (STandarD Input Output)
    • printf(“format”,var1,var2,…);
    • print formatted
  • 22. 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 applesn”,nbApples,nbEat, nbApples-nbEat);
  • 23. Les entrées-sorties : Lecture au clavier
    • Inclure le fichier stdio.h (STandarD Input Output)
    • scanf(“format”,&var1,&var2,…);
    • scan formatted
  • 24. 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);
  • 25. 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
  • 26. 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
  • 27. Les structures de contrôle
  • 28. Les conditionnelles : if…else (1)
    • if (condition)
    • {
    • instructions;
    • }
    condition instructions vrai faux
  • 29. Les conditionnelles : if…else (2)
    • if (condition)
    • {
    • instructions1;
    • }
    • else
    • {
    • instructions2;
    • }
    condition instructions1 vrai faux instructions2
  • 30. Les conditionnelles : if…else (3)
    • int a,b,c,d;
    • if (a<b)
    • {
    • if (c<d)
    • {
    • instructions1;
    • }
    • else
    • {
    • instructions2;
    • }
    • }
    … else { instructions3; }
  • 31. Les conditionnelles : switch…case (1)
    • switch (expression)
    • {
    • case constante1:
    • instructions1;
    • break;
    • case constante2:
    • instructions2;
    • break;
    … default: instructionsDefault; break; }
  • 32. Les conditionnelles : switch…case (2) expression constante1 default ... instructionsD instructions1 instructions2
  • 33. 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
  • 34. Les itérations : La boucle for vrai faux Initialisation Condition d’arrêt Mise à jour exp2 exp1 instructions exp3
  • 35. Les itérations : La boucle while
    • Syntaxe :
    • while (condition)
    • {
    • instructions;
    • }
    • Tant que condition
    • vraie exécuter les
    • instructions
    condition instructions vrai faux
  • 36. Les itérations : La boucle do…while
    • Syntaxe :
    • do
    • {
    • instructions;
    • }
    • while (condition) ;
    • Exécuter les
    • instructions tant que
    • condition vraie
    condition instructions vrai faux
  • 37. 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 !
  • 38. 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
  • 39. Fonctions et procédures
    • Structuration de la programmation
      • Plus simple
      • Modulaire
    • Clarté de programmation
    • Réutilisabilité -> briques de programmation
  • 40. Les procédures
    • Déclaration :
    • void nomProcedure(listeParamètres)
    • {
    • DéclarationDesVariables;
    • Instructions;
    • }
    • Utilisation :
    • nomProcedure(listeParamètres);
  • 41. Les fonctions
    • Déclaration :
    • type nomFonction(listeParamètres)
    • {
    • DéclarationDesVariables;
    • Instructions;
    • return variable;
    • }
    • Utilisation :
    • type variable;
    • variable=nomFonction(listeParamètres);
  • 42. Les paramètres
    • Paramètres en entrée
      • Contenu d ’une variable
      • Constante
    • Paramètres en entrée-sortie
      • Pointeur sur une variable
  • 43. 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
  • 44. 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
  • 45. Plan
    • Structures de contrôle
    • Fonctions
    • Structures de données complexes
      • Tableaux
      • Structures
      • Pointeurs
    • Entrées-sorties avancées
  • 46. Définition
    • Trois types de structures de données complexes :
      • Tableaux
      • Structures
      • Pointeurs
  • 47. 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  »
  • 48. 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 !
  • 49. 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
  • 50. Les tableaux (4)
    • Parcours de la totalité d’un tableau :
    • #define ARRAY_SIZE 1000
    • for (i=0;i<ARRAY_SIZE;i++)
    • {
    • }
  • 51. 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(&quot;Element %d not found !n&quot;,element); else printf(&quot;Element %d found at indice %dn&quot; ,element,i); }
  • 52. 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);
  • 53. 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
  • 54. 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
  • 55. 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
  • 56. 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, …)
  • 57. 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
  • 58. 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; 
  • 59. 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]= &quot;hello0&quot; ; aString[0]=‘h’; aString[1]=‘e’; ... strcpy(aString, &quot;hello&quot; ); } 0 o l l e h
  • 60. 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)
  • 61. Les chaînes de caractères (4)
    • Affichage avec printf :
    • printf(“%sn”,myString);
  • 62. 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);
  • 63. 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 ?
  • 64. Plan
    • Structures de contrôle
    • Fonctions
    • Structures de données complexes
      • Tableaux
      • Structures
      • Pointeurs
    • Entrées-sorties avancées
  • 65. 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
  • 66. 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 .
  • 67. 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
  • 68. 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; }
  • 69. 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; }
  • 70. Plan
    • Structures de contrôle
    • Fonctions
    • Structures de données complexes
      • Tableaux
      • Structures
      • Pointeurs
    • Entrées-sorties avancées
  • 71. Plan
    • Introduction à la notion de pointeurs
    • Pointeurs et tableaux
    • Passage de paramètres avec les pointeurs
    • Structures dynamiques
    • Conclusion
  • 72. Utilité des pointeurs
    • Tableaux alloués à la demande (allocation dynamique)
    • Passages de paramètres par adresse
    • Structures dynamiques
  • 73. Définition
    • Nouveau type de données
    • Son contenu est une adresse mémoire
    • Adresse mémoire &quot;pointe&quot; sur une autre variable -> &quot;pointeur&quot;
  • 74. Notation
    • Déclaration d'un pointeur :
      • <type pointé>* <nom du pointeur>
    • Opérateurs :
      • Indirection (*)
      • Référence (&)
    • Attention <type>* est différent de * !!!
  • 75. 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
  • 76. 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);
  • 77. Affectations
    • Affectation de pointeurs
      • pointeur1=pointeur2;
    • Affectation d'une valeur pointée
      • variable=*pointeur;
    • Affectation de rien
      • pointeur=NULL;
  • 78. 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;
  • 79. 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)++; }
  • 80. Plan
    • Introduction à la notion de pointeurs
    • Pointeurs et tableaux
    • Passage de paramètres avec les pointeurs
    • Structures dynamiques
    • Conclusion
  • 81. 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
  • 82. 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;
  • 83. 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]; */
  • 84. 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);
  • 85. 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); }
  • 86. 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}
  • 87. 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)); }
  • 88. Plan
    • Introduction à la notion de pointeurs
    • Pointeurs et tableaux
    • Passage de paramètres avec les pointeurs
    • Structures dynamiques
    • Conclusion
  • 89. 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
  • 90. Passage de paramètres void main() { int a,b; a=5; fonction(a,&b); } void fonction(int parRecopie, int* parAdresse) { parRecopie=10; *parAdresse=15; }
  • 91. Plan
    • Introduction à la notion de pointeurs
    • Pointeurs et tableaux
    • Passage de paramètres avec les pointeurs
    • Structures dynamiques
    • Conclusion
  • 92. 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.
  • 93. 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;
  • 94. 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; */ }
  • 95. 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
  • 96. 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
  • 97. Listes chaînées : Insertion
    • Insertion d’un élément :
    Racine Données Pointeur Données Pointeur Données Pointeur
  • 98. Listes chaînées : Destruction
    • Destruction d’un élément :
    Racine Données Pointeur Données Pointeur Racine Données Pointeur
  • 99. 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 !
  • 100. 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;
    • }
  • 101. 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
  • 102. Listes doublement chaînées : Destruction
    • Destruction d’un élément :
    Racine Données Pointeur Pointeur Données Pointeur Pointeur Données Pointeur Pointeur
  • 103. Plan
    • Introduction à la notion de pointeurs
    • Pointeurs et tableaux
    • Passage de paramètres avec les pointeurs
    • Structures dynamiques
    • Conclusion
  • 104. 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
  • 105. 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
  • 106. Accès aux fichiers
    • Ouverture d’un fichier :
    • FILE* fopen(char* name, char* mode);
    • Fermeture d’un fichier :
    • int fclose(FILE* fileDes);
  • 107. 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...);
  • 108. Lecture (2)
    • Lecture en vrac :
    • size_t fread(void* ptr,size_t size,size_t nmemb,FILE* fileDes);
  • 109. 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...);
  • 110. Ecriture (2)
    • Ecriture en vrac :
    • size_t fwrite(const void* ptr,size_t size,size_t nmemb,FILE* fileDes);
  • 111. Ecriture
    • Ecriture dans un fichier :
    • int putc(FILE* fileDes);
  • 112. Plan
    • ...
    • Entrées-sorties
    • Structures de contrôle
    • Fonctions
    • Structures de données complexes
    • Entrées-sorties avancées
    • Bêtisier
    • Conclusion
  • 113. Bêtisier
    • Erreurs de programmation les plus souvent rencontrées
    • Ne provoquent pas d ’erreur de compilation
    • Assez difficiles à trouver
  • 114. Bêtisier
    • if ( a = b )
    • if ( a == b);
    • if ( a > b )
    • if ( x > y )
    • x = y;
    • else
    • ...
  • 115. 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++;
  • 116. Conclusion
    • Première expérience de la programmation
    • C langage système -> pas assez strict pour un premier langage
    • Base des langages