« INFO517 : Programmation C » : différence entre les versions

De Wiki du LAMA (UMR 5127)
Aller à la navigation Aller à la recherche
 
(64 versions intermédiaires par 5 utilisateurs non affichées)
Ligne 1 : Ligne 1 :
Cours du semestre 5 de la license STIC INFO.
Cours du semestre 5 de la licence STIC INFO.


* Responsable pour 2010--2011: [http://www.lama.univ-savoie.fr/~lachaud Jacques-Olivier Lachaud]
== Organisation ==
* Jacques-Olivier Lachaud (C/TD/TP), Xavier Provençal (TP)


Pensez à consulter les [[Comment compiler le C ?|indications pour compiler un petit programme sur une machine des salles de TP]].
Responsable pour 2008--2009: [http://www.lama.univ-savoie.fr/~vaux Lionel Vaux].


== Quelques ressources pour l'étudiant (2010-2011) ==
10 séances de cours/TD (1h30) et 3 séances de TP (4h).


# Notes de cours [http://www.lama.univ-savoie.fr/~lachaud/Cours/INFO517/Cours/notes-de-cours.ps PostScript] [http://www.lama.univ-savoie.fr/~lachaud/Cours/INFO517/Cours/notes-de-cours.pdf PDF]
== Objectifs du cours ==
# Fiches de TD
#* TD 1 et 2 : tableaux, entrées-sorties [http://www.lama.univ-savoie.fr/~lachaud/Cours/INFO517/TDs/td-1.ps PostScript] [http://www.lama.univ-savoie.fr/~lachaud/Cours/INFO517/TDs/td-1.pdf PDF]
#* TD 3 : exercices sur les pointeurs [http://www.lama.univ-savoie.fr/~lachaud/Cours/INFO517/TDs/td-2.ps PostScript] [http://www.lama.univ-savoie.fr/~lachaud/Cours/INFO517/TDs/td-2.pdf PDF]
# TPs et autres travaux pratiques [http://www.lama.univ-savoie.fr/~lachaud/Cours/INFO517/Tests/doc/html/index.html Pages des TPs]
#* Pour la première fois, on pourra aussi regarder la page [[Comment_compiler_le_C_%3F]]
#* Si vous n'accédez pas aux pages "manual" en salle TP, on les trouve en ligne : [[http://www.linux-france.org/article/man-fr/ Manual pages]]
# Autres ressources


N'hésitez pas à contribuer au wiki, et en particulier à cette page:
* Principes généraux et particularités du langage (programmation impérative, typage fort, adressage mémoire)
clarifications, compléments, exemples… Si vous n'avez pas compris un point
* Syntaxe
particulier, vous pouvez signaler votre problème sur la page de discussion
* Bibliothèque standard (pour les entrées-sorties et l'interaction avec le système d'exploitation)
(onglet en haut de cette page) ou par les moyens habituels. Il sera ensuite
* Gestion de la mémoire
très positif de revenir sur cette page et de consigner ce qui vous posait
* Bonnes pratiques
problème et ce qui vous a permis de mieux comprendre.
* Outils et concepts:
** automatisation de la compilation (make),
** analyse de l'exécution et déboguage (gdb, valgrind),
** documentation (doxygen),
** boîte à outils graphique (gtk+)


== Déroulement (2010-2011) ==
== Séances ==


Ceci n'est qu'une prévision.
=== Cours/TD 1 : lundi 22 septembre 2008 ===


* (Cours 1): lundi 20 septembre. Langage C, intérêts et défauts. Compilation. Eléments de base du langage (types simples, variables, expressions). (=> I.5).
Présentation tout-en-un.
* (TD 1): mercredi 29 septembre. Instructions et structures de contrôle usuelles (conditionnelles, boucles) (=> I.10)
* (TD 2): jeudi 30 septembre. TD 1 tableaux, fonctions en C, E/S simples.
* (Cours 2): vendredi 1er octobre. Fonctions, passage de paramètres, pointeurs (=> II.5).
* (TD 3): vendredi 1er octobre. TD 1 tableaux, fonctions en C, E/S simples (II).
* (Cours 3): lundi 4 octobre. Fonctions, passage de paramètres, pointeurs, allocation dynamique (=> II.10)
* (Cours 4): lundi 4 octobre. Un exemple complet : les piles en C (II.11).
* (TP 1): mercredi 6 octobre. Boucles, puissance 4, tracés avec gnuplot, récursivité.
* (TD 4): vendredi 8 octobre. Exercices simples sur les pointeurs.
* (TD 5): lundi 11 octobre. Pile d'exécution. Structures auto-référents. Début skip-liste.
* (TP 2): mercredi 13 octobre. Tetris texte.
* (TD 6): vendredi 15 octobre. Skip-listes. Compilation séparée et bonnes habitudes de développement C.
* (TP 3): jeudi 21 octobre. Tetris graphique avec GTK.


== Historique ==
Le but de ce cours est de fournir le minimum vital aux étudiants pour:
* écrire un programme simple et court utilisant les types de base
* le compiler et l'exécuter
* trouver de la documentation


* Responsable pour 2009--2010: Emilie Charrier (C/TD/TP)
Après cette première séance, les étudiants devraient être capable de s'amuser un peu avec le langage.
* Responsable pour 2008--2009: Lionel Vaux (C/TD/TP)


== Ressources pour l'étudiant (avant 2010) ==
==== Les exemples vus en cours ====


Cet enseignement comprendra 10 séances de cours/TD (1h30) et 3 séances de TP (4h).
<tt>bateau.c</tt>
<source lang="c">
#include <stdio.h>


La distinction entre cours et TD restera floue. Je vous demanderai
int main () {
généralement d'écrire quelques petits programmes d'une semaine sur l'autre.
/* Écrit une chaîne */
Autant que possible, envoyez-moi vos fichiers sources à l'adresse
puts("Bateau !");
<tt>lionel.vaux@univ-savoie.fr</tt>, afin que je puisse évaluer le niveau de
chacun et ajuster le contenu des séances suivantes.


<em>Et dites-moi si ça ne
/* Renvoie la valeur de sortie en cas de succès */
va pas, ou je risque d'avancer trop vite.</em>
return 0;
}
</source>


<tt>euros-francs-v1.c</tt>
<source lang="c">
#include<stdio.h>


=== Objectifs du cours ===
/* Écrit une table de conversion euros/francs
* pour euros = 0, 5, 10, ..., 100 :
* version initiale */
main()
{
int euros, euros_max, pas ;
float francs, un_euro ;


==== Cours/TD ====
un_euro = 6.55957 ; /* taux de conversion */
* Principes généraux et particularités du langage: programmation impérative, typage fort à la compilation, adressage mémoire explicite

* Syntaxe de base
pas = 5 ; /* pas d'itération */
* Bibliothèque standard: entrée-sorties et interaction avec le système d'exploitation
euros = 0 ; /* valeur initiale */
* C avancé:
euros_max = 100 ; /* valeur maximale */
** allocation dynamique
** modèle mémoire (pile, tas, code)
while (euros <= euros_max) {
** pointeurs sur structures
francs = un_euro * euros ;
** pointeurs sur fonctions
printf("%d\t%f\n", euros, francs) ;
* Bonnes pratiques
euros = euros + pas ;
}
}
</source>

<tt>euros-francs-v2.c</tt>
<source lang="c">
#include<stdio.h>

/* Écrit une table de conversion euros/francs
* pour euros = 0, 5, 10, ..., 100 :
* correction de l'alignement */
main()
{
int euros, euros_max, pas ;
float francs, un_euro ;

un_euro = 6.55957 ; /* taux de conversion */

pas = 5 ; /* pas d'itération */
euros = 0 ; /* valeur initiale */
euros_max = 100 ; /* valeur maximale */
while (euros <= euros_max) {
francs = un_euro * euros ;
printf("%3d\t%6.2f\n", euros, francs) ;
euros = euros + pas ;
}
}
</source>

<tt>euros-francs-v3.c</tt>
<source lang="c">
#include<stdio.h>

/* Écrit une table de conversion euros/francs
* pour euros = 0, 5, 10, ..., 100 :
* avec un `for' */
main()
{
int euros ;
for (euros = 0 ; euros <= 100 ; euros = euros + 5)
printf("%3d\t%6.2f\n", euros, 6.55957*euros) ;
}
</source>

<tt>euros-francs-v4.c</tt>
<source lang="c">
#include<stdio.h>

#define UN_EURO 6.55957 /* un euro en francs */


==== En TP ====
/* Écrit une table de conversion euros/francs
* un TP de mise en route et de précision de la notion de compilation en C
* pour euros = 0, 5, 10, ..., 100 :
* un projet logiciel sur les deux dernières séances (8h)
* définition pour le préprocesseur */
main()
{
int euros ;
for (euros = 0 ; euros <= 100 ; euros = euros + 5)
printf("%3d\t%6.2f\n", euros, UN_EURO*euros) ;
}
</source>


==== Outils et concepts (survol théorique et utilisation optionnelle en TP) ====
<tt>arrondi.c</tt>
* automatisation de la compilation (make),
<source lang="c">
* analyse de l'exécution et déboguage (gdb et DDD),
#include<stdio.h>
* boîte à outils graphique (gtk+)


=== Supports ===
#define INCR 0.00001 /* incrément pour le test de précision */
#define NUM 100000 /* nombre de pas */


* Exercices de TD :
/* Calcule 100000*0.00001=1 ? */
*# la [http://www.lama.univ-savoie.fr/~vaux/ens/INFO517-TD1.pdf feuille 1] ;
main()
*# la [http://www.lama.univ-savoie.fr/~vaux/ens/INFO517-TD2.pdf feuille 2] et une archive [http://www.lama.univ-savoie.fr/~vaux/ens/liste.tar.gz <tt>liste.tar.gz</tt>] comprenant une solution pour l'implémentation des listes et des listes triées (les piles ont été traitées en [[INFO517-cours7|séance 7]]).
{
float accu ;
int i ;
accu = 0 ;
for (i=0 ; i < PAS ; i=i+1)
accu = accu + INCREMENT ;
printf("%d=%f?\n",PAS*INCREMENT,accu) ;
}
</source>


* Devoir à la maison : le sujet [http://www.lama.univ-savoie.fr/~vaux/ens/INFO517-DM1.pdf <tt>INFO517-DM1.pdf</tt>] et les fichiers sources [http://www.lama.univ-savoie.fr/~vaux/ens/dm1.c <tt>dm1.c</tt>] et [http://www.lama.univ-savoie.fr/~vaux/ens/mat.c <tt>mat.c</tt>] associés.
<tt>copie-v1.c</tt>
<source lang="c">
#include<stdio.h>


* Examens :
/* Copie l'entrée standard sur la sortie standard */
*# sujet [http://www.lama.univ-savoie.fr/~vaux/ens/INFO517-Partiel1.pdf <tt>INFO517-Partiel1.pdf</tt>] et corrigé [http://www.lama.univ-savoie.fr/~vaux/ens/INFO517-Partiel1-correction.pdf <tt>INFO517-Partiel1-correction.pdf</tt>].
main()
*# sujet [http://www.lama.univ-savoie.fr/~vaux/ens/INFO517-Partiel2.pdf <tt>INFO517-Partiel2.pdf</tt>] et corrigé [http://www.lama.univ-savoie.fr/~vaux/ens/INFO517-Partiel2-correction.pdf <tt>INFO517-Partiel2-correction.pdf</tt>].
{
*# sujet [http://www.lama.univ-savoie.fr/~vaux/ens/INFO517-Terminal.pdf <tt>INFO517-Terminal.pdf</tt>] et corrigé [http://www.lama.univ-savoie.fr/~vaux/ens/INFO517-Terminal-correction.pdf <tt>INFO517-Terminal-correction.pdf</tt>].
int c;
*# sujet [http://www.lama.univ-savoie.fr/~vaux/ens/INFO517-Rattrapage.pdf <tt>INFO517-Rattrapage.pdf</tt>] et corrigé [http://www.lama.univ-savoie.fr/~vaux/ens/INFO517-Rattrapage-correction.pdf <tt>INFO517-Rattrapage-correction.pdf</tt>].


=== Séances de Cours/TD ===
c = getchar();
while (c != EOF) {
putchar(c);
c = getchar();
}
}
</source>


# [[INFO517-cours1|lundi 22 septembre 2008]].
<tt>copie-v2.c</tt>
#* mise en route: exemples de programmes simples et compilation;
<source lang="c">
#* syntaxe de base: types, déclarations, affectations, boucles, entrées et sorties simples (caractère par caractère);
#include<stdio.h>
# [[INFO517-cours2|lundi 29 septembre 2008]]
#* fonctions;
#* tableaux et chaînes;
#* récursion;
# [[INFO517-cours3|lundi 6 octobre 2008]]
#* exercices (feuille 1);
# [[INFO517-cours4|lundi 13 octobre 2008]]
#* adresses et pointeurs;
#* passage par adresse;
#* les tableaux comme pointeurs;
#* opérateur <tt>sizeof</tt>;
#* arithmétique de pointeurs;
#* allocation des variables locales: le problème des tableaux;
#* allocation dynamique: <tt>malloc()</tt>, <tt>free()</tt>, <tt>realloc()</tt>;
# [[INFO517-cours5|lundi 20 octobre 2008]]
#* modèle mémoire: pile, tas, segment de code;
#* différence entre déclaration de tableau et déclaration de pointeur;
#* affichage des données de la pile d'exécution, adresses de retour;
# [[INFO517-cours6|lundi 3 novembre 2008]]
#* types complexes: <tt>struct</tt>, <tt>union</tt>, <tt>enum</tt>;
#* premier partiel;
# [[INFO517-cours7|lundi 10 novembre 2008]]
#* pointeurs vers <tt>struct</tt>;
#* structures récursives;
#* exemple: les piles (FILO);
#* <tt>Makefile</tt>s;
#* exercices (feuille 2);
# [[INFO517-cours8|lundi 17 novembre 2008]]
#* correction du premier partiel;
#* exercices (suite de la feuille 2);
# [[INFO517-cours9|lundi 24 novembre 2008]]
#* préparation du TP1
#* entrées et sorties dans des fichiers
#* opérations bit-à-bit;
# [[INFO517-cours10|lundi 1er décembre 2008]]
#* deuxième partiel;
#* pointeurs sur fonctions;
#* une session DDD;


=== Séances de TP ===
/* Copie l'entrée standard sur la sortie standard :
* assignation comme valeur */
main()
{
int c;


Les sujets de TP se trouvent sur
while ((c = getchar()) != EOF) {
[http://www.lama.univ-savoie.fr/~vaux/ens/INFO-517-TP cette page].
putchar(c);
}
}
</source>


# mercredi 15 octobre 2008 : [http://www.lama.univ-savoie.fr/~vaux/ens/INFO-517-TP/TP0.html TP0 — Préliminaires]
==== Exercices pour le 29 septembre ====
# vendredi 28 novembre 2008 : [http://www.lama.univ-savoie.fr/~vaux/ens/INFO-517-TP/TP1.html TP1 — Formats d'image]
# vendredi 12 décembre 2008 : [http://www.lama.univ-savoie.fr/~vaux/ens/INFO-517-TP/TP2.html TP2 — Affichage et interface graphique]


==Références==
* Au choix:
*# Sur la machine et le système de votre choix, écrire et compiler un programme C (par exemple <tt>bateau.c</tt>), puis envoyer le fichier source et le binaire obtenu à l'adresse <tt>lionel.vaux@univ-savoie.fr</tt>.
*# Ne pas y parvenir et alors me contacter au plus tôt pour y remédier. Ensuite revenir au choix 1, évidemment.
* Modifier l'un des fichiers <tt>euros-francs-v?.c</tt> pour afficher une ligne d'en-tête alignée sur les résultats (et quelques fioritures). C'est-à-dire que la sortie doit ressembler à:
Euros: Francs:
0 -> 0.00
5 -> 32.80
10 -> 65.60
15 -> 98.39
20 -> 131.19
...
* Écrire un programme <tt>francs-euros.c</tt> qui affiche une table de conversion dans le sens contraire (les comptes ronds sont en francs).
* Écrire un programme qui affiche la valeur entière, de type <tt>int</tt>, de <tt>EOF</tt> (vérifier qu'elle n'est pas dans l'intervalle entier <tt>[0..255]</tt>).
* Écrire un programme qui affiche la valeur entière du «&nbsp;caractère&nbsp;» <tt>€</tt> (il est possible que vous ne compreniez pas très bien ce qui vous arrive: on en parlera).
* Écrire un programme qui compte le nombre de caractères (au sens de <tt>getchar()</tt>) dans un fichier.


* ''The C programming language'', de Kernighan et Ritchie;
Autant que possible, envoyez-moi vos fichiers sources à l'adresse <tt>lionel.vaux@univ-savoie.fr</tt>, afin que je puisse évaluer les niveaux de chacun et ajuster le contenu de la prochaine séance. <em>Et dites-moi si ça ne va pas, ou je risque d'avancer trop vite.</em>
* ''Le langage C'', version française du précédent;
* Le polycopié de Bernard Cassagne, disponible [http://www-clips.imag.fr/commun/bernard.cassagne/Introduction_ANSI_C.html ici], au format [http://www-clips.imag.fr/commun/bernard.cassagne/Introduction_ANSI_C.html html] (consultable en ligne) ou [ftp://ftp.imag.fr/pub/labo-CLIPS/commun/C/Introduction_ANSI_C.pdf pdf];
* Le wikilivre [http://fr.wikibooks.org/wiki/Programmation_C ''Programmation C'']: un livre de cours sur le mode wikipedia.

Dernière version du 17 février 2012 à 07:59

Cours du semestre 5 de la licence STIC INFO.

Pensez à consulter les indications pour compiler un petit programme sur une machine des salles de TP.

Quelques ressources pour l'étudiant (2010-2011)

  1. Notes de cours PostScript PDF
  2. Fiches de TD
  3. TPs et autres travaux pratiques Pages des TPs
    • Pour la première fois, on pourra aussi regarder la page Comment_compiler_le_C_?
    • Si vous n'accédez pas aux pages "manual" en salle TP, on les trouve en ligne : [Manual pages]
  4. Autres ressources

N'hésitez pas à contribuer au wiki, et en particulier à cette page: clarifications, compléments, exemples… Si vous n'avez pas compris un point particulier, vous pouvez signaler votre problème sur la page de discussion (onglet en haut de cette page) ou par les moyens habituels. Il sera ensuite très positif de revenir sur cette page et de consigner ce qui vous posait problème et ce qui vous a permis de mieux comprendre.

Déroulement (2010-2011)

Ceci n'est qu'une prévision.

  • (Cours 1): lundi 20 septembre. Langage C, intérêts et défauts. Compilation. Eléments de base du langage (types simples, variables, expressions). (=> I.5).
  • (TD 1): mercredi 29 septembre. Instructions et structures de contrôle usuelles (conditionnelles, boucles) (=> I.10)
  • (TD 2): jeudi 30 septembre. TD 1 tableaux, fonctions en C, E/S simples.
  • (Cours 2): vendredi 1er octobre. Fonctions, passage de paramètres, pointeurs (=> II.5).
  • (TD 3): vendredi 1er octobre. TD 1 tableaux, fonctions en C, E/S simples (II).
  • (Cours 3): lundi 4 octobre. Fonctions, passage de paramètres, pointeurs, allocation dynamique (=> II.10)
  • (Cours 4): lundi 4 octobre. Un exemple complet : les piles en C (II.11).
  • (TP 1): mercredi 6 octobre. Boucles, puissance 4, tracés avec gnuplot, récursivité.
  • (TD 4): vendredi 8 octobre. Exercices simples sur les pointeurs.
  • (TD 5): lundi 11 octobre. Pile d'exécution. Structures auto-référents. Début skip-liste.
  • (TP 2): mercredi 13 octobre. Tetris texte.
  • (TD 6): vendredi 15 octobre. Skip-listes. Compilation séparée et bonnes habitudes de développement C.
  • (TP 3): jeudi 21 octobre. Tetris graphique avec GTK.

Historique

  • Responsable pour 2009--2010: Emilie Charrier (C/TD/TP)
  • Responsable pour 2008--2009: Lionel Vaux (C/TD/TP)

Ressources pour l'étudiant (avant 2010)

Cet enseignement comprendra 10 séances de cours/TD (1h30) et 3 séances de TP (4h).

La distinction entre cours et TD restera floue. Je vous demanderai généralement d'écrire quelques petits programmes d'une semaine sur l'autre. Autant que possible, envoyez-moi vos fichiers sources à l'adresse lionel.vaux@univ-savoie.fr, afin que je puisse évaluer le niveau de chacun et ajuster le contenu des séances suivantes.

Et dites-moi si ça ne va pas, ou je risque d'avancer trop vite.


Objectifs du cours

Cours/TD

  • Principes généraux et particularités du langage: programmation impérative, typage fort à la compilation, adressage mémoire explicite
  • Syntaxe de base
  • Bibliothèque standard: entrée-sorties et interaction avec le système d'exploitation
  • C avancé:
    • allocation dynamique
    • modèle mémoire (pile, tas, code)
    • pointeurs sur structures
    • pointeurs sur fonctions
  • Bonnes pratiques

En TP

  • un TP de mise en route et de précision de la notion de compilation en C
  • un projet logiciel sur les deux dernières séances (8h)

Outils et concepts (survol théorique et utilisation optionnelle en TP)

  • automatisation de la compilation (make),
  • analyse de l'exécution et déboguage (gdb et DDD),
  • boîte à outils graphique (gtk+)

Supports

  • Exercices de TD :
    1. la feuille 1 ;
    2. la feuille 2 et une archive liste.tar.gz comprenant une solution pour l'implémentation des listes et des listes triées (les piles ont été traitées en séance 7).

Séances de Cours/TD

  1. lundi 22 septembre 2008.
    • mise en route: exemples de programmes simples et compilation;
    • syntaxe de base: types, déclarations, affectations, boucles, entrées et sorties simples (caractère par caractère);
  2. lundi 29 septembre 2008
    • fonctions;
    • tableaux et chaînes;
    • récursion;
  3. lundi 6 octobre 2008
    • exercices (feuille 1);
  4. lundi 13 octobre 2008
    • adresses et pointeurs;
    • passage par adresse;
    • les tableaux comme pointeurs;
    • opérateur sizeof;
    • arithmétique de pointeurs;
    • allocation des variables locales: le problème des tableaux;
    • allocation dynamique: malloc(), free(), realloc();
  5. lundi 20 octobre 2008
    • modèle mémoire: pile, tas, segment de code;
    • différence entre déclaration de tableau et déclaration de pointeur;
    • affichage des données de la pile d'exécution, adresses de retour;
  6. lundi 3 novembre 2008
    • types complexes: struct, union, enum;
    • premier partiel;
  7. lundi 10 novembre 2008
    • pointeurs vers struct;
    • structures récursives;
    • exemple: les piles (FILO);
    • Makefiles;
    • exercices (feuille 2);
  8. lundi 17 novembre 2008
    • correction du premier partiel;
    • exercices (suite de la feuille 2);
  9. lundi 24 novembre 2008
    • préparation du TP1
    • entrées et sorties dans des fichiers
    • opérations bit-à-bit;
  10. lundi 1er décembre 2008
    • deuxième partiel;
    • pointeurs sur fonctions;
    • une session DDD;

Séances de TP

Les sujets de TP se trouvent sur cette page.

  1. mercredi 15 octobre 2008 : TP0 — Préliminaires
  2. vendredi 28 novembre 2008 : TP1 — Formats d'image
  3. vendredi 12 décembre 2008 : TP2 — Affichage et interface graphique

Références

  • The C programming language, de Kernighan et Ritchie;
  • Le langage C, version française du précédent;
  • Le polycopié de Bernard Cassagne, disponible ici, au format html (consultable en ligne) ou pdf;
  • Le wikilivre Programmation C: un livre de cours sur le mode wikipedia.
Récupérée de « http://os-vps418.infomaniak.ch:1250/mediawiki/index.php?title=INFO517_:_Programmation_C&oldid=5489 »