PROGRAMMATION EN LANGAGE C
Licence Informatique 2ème année
Présentation du module
• Volume horaire en présentiel
• 18h Cours, 16h TD, 16h TP
• Validation des acquis : contrôle continu
• Comprendre : « travail continu » J
• QCMs
• Evaluation pratique (TP, Projet)
• Evaluation sur table
• Travail personnel : un langage de programmation s’acquiert par la pratique !
Organisation
• Toutes les informations du module seront disponibles sur http://mis.u-picardie.fr/~leve/enseignement.html
• En particulier, vous aurez accès :
• au planning des séances
• à la grille d’acquisition des connaissances du module
• aux cours magistraux
• aux énoncés de TP
INTRODUCTION
Historique
• Bell’s Lab (système UNIX)
• Brian W. Kernighan & Dennis M. Ritchie (1978)
• Norme ANSI (1989). ISO C-89
• Quelques modifications mineures en 1994-95
• Evolution du langage : C99
• Nouvelle norme : C11
Le langage C
Avantages Inconvénients
Universel (tout type de développement)
Lisibilité (plusieurs syntaxes pour une même tache)
Compact (Noyau avec très peu d’instructions)
Compact…
Rapide (bas niveau, proche de la machine)
Permissif (le développeur doit absolument savoir ce qu’il écrit !) Portable (Norme ANSI-C)
CHAPITRE 1
Syntaxe de base
« Comment écrire un algorithme simple en C »
Premier programme
main()!
{!
printf(« Bonjour tout le monde !! »);!
}!
!
• Edition
• À l’aide d’un éditeur de texte, le développeur programme les tâches souhaitées (en C bien sûr !!!)
• Exemples : emacs, nano, vi, Visual Studio, Xcode, Code::Blocks...!
• Compilation du code source C
• Compilateur le plus courant : gcc
Pré-compilation, compilation, édition de liens
fichier1.c
PROGRAMME
(réparti sur plusieurs modules)
fichier2.c fichier3.c
fichier1.o fichier2.o fichier3.o fichiers objets fichiers sources
fichier exécutable
PRE-COMPILATION + COMPILATION
EDITION DE LIENS
fichier binaire exécutable ou
bibliothèque
Compiler et exécuter un programme en ligne de commande
• Convention : les fichiers contenant les programmes C ont l’extension « .c »
• Exemple : prog.c
• Compilation par défaut
• cc prog.c
• La compilation crée un fichier exécutable, dont le nom par défaut est : a.out
• On exécute ce programme en tapant : a.out
• Compilation en choisissant le nom de l’exécutable
• cc –o prog prog.c
• Exécution en tapant : prog
Structure d’un fichier source
• IMPORTANT : tout programme comporte une fonction principale appelée « main ».
[Directives de pré-compilation]
[Déclaration d'objets externes]
- variables - fonctions
[Variables globales]
Fonctions
Structure d’une fonction
Entête!
{!
!
corps de la fonction!
! }!
Bloc =
accolade ouvrante +
Définitions des variables locales au bloc
+ Instructions
+
Accolade fermante Instruction = bloc
ou
Expression suivie de ;
ou
Instruction de contrôle (test,…)
Règles typographiques
• Compilateur sensible à la casse : les majuscules sont différenciées des minuscules
• Les quotes ’ (apostrophes)
• Ce qui est situé entre quotes est un caractère
• ‘a’ représente le caractère a
• ‘2’ représente le caractère ASCII 2
• Les guillemets ”!
• Ce qui est situé entre guillemets est une chaîne de caractères
• ”Ceci est une chaîne de caractères”!
• Toute instruction se termine par ;!
Commentaires
• Tout ce qui est situé entre « /* » et « */ »
• Sauf si le tout se trouve entre guillemets
• Ce qui est syntaxiquement impossible
• Commentaires « imbriqués »
• /* dans le /* commentaire */ hors du commentaire */!
• Commentaires partageant une chaîne de caractères
• Légal : int /* variable nombre */ nombre;!
• Illégal : int nom/* variable nombre */bre;!
• Avec le C99 : // commentaire à la C++!
Types de base en C
• Chaque donnée, variable ou constante, utilisée dans un programme C, a un type.
• Ce type détermine :
• la taille de la donnée (c-à-d le nombre d’octets consécutifs utilisés pour son stockage en mémoire)
• l’ensemble des valeurs que peut prendre la donnée
• les opérations que l’on peut effectuer sur cette donnée.
Types de base en C
• Types prédéfinis par le compilateur
• int : entier
• char : caractère (ou « byte »)
• Une donnée de type char est un entier signé
• Correspondance avec la table ASCII!
• Exemple : x = 'a' + 2; est équivalent à x = 65 + 2; ou à x = 'c’;
• float : flottants (nombres réels à virgule flottante)
• double (nombre réel en double précision)
• void : type générique (type vide)
• Qualificatifs
• Certains types peuvent être précisés par un qualificatif
• unsigned pour char et int
• short et long pour int (dans ce cas on peut omettre d’écrire int)
• le type long double est apparu pour représenter les nombres à partie décimale avec une très grande précision
• long long (C99)
Types de base en C
• Intervalles de valeurs
• ATTENTION : les valeurs possibles dépendent du Système d’Exploitation et de la machine utilisée !
• Seule garantie : taille(char)<=taille(int)<=taille(long)<=taille(long long)
• Intervalles de valeurs courants :
• char (1 octet = 8 bits)
• [-128, 127] ;
• [0, 255] si « unsigned » (non signé)
• int (32 bits)
• [-231, 231-1] ;
• [0, 232-1] si « unsigned »
• float (64 bits)
• [-10308, 10308]
Variables
• Quel nom (identificateur) donner à une variable ?
• Le nom le plus explicite possible quant à son rôle !
• Succession de caractères alphanumériques non accentués
• Pas d’espaces
• Au moins un caractère alphabétique non accentué
• Le 1er caractère est obligatoirement alphabétique non accentué
• Exemples :
• int variable_1; (valide)
• int 1_variable; (non valide)
Variables
• Attention : les mots réservés ne doivent pas être utilisés noms de variable !!!!
• Types de données :
char const double float int long short signed unsigned void
• Instructions de boucle
do for while
• Sélections
case default else if switch
• Divers
auto extern register static enum struct typedef union break continue goto return asm entry fortran sizeof volatile restrict inline…
Variables
• Lexique :
• La déclaration indique le nom et le type de la variable au compilateur
• La définition d’une variable réserve l’espace mémoire pour la stocker
(La définition d’une variable implique sa déclaration.)
• L’initialisation fixe une valeur à la variable lors de sa définition.
• Toute variable (ou fonction) doit être déclarée avant d’être utilisée.
• Déclaration : type nom_variable;!!
• Exemple : int x;
• Déclaration multiple : type var1, var2, var3; !!
• Domaine de validité : par défaut, une variable déclarée dans un bloc est valide et accessible jusqu’à la fin de ce bloc.
Constantes
• Mot réservé
• const!
• Syntaxe
• const <type> <nom de la constante>!
• Soumis aux mêmes règles syntaxiques que les variables
• Exemple
• const float pi = 3.14159;!
Affectation
• identificateur = expression!
• Exemple : i=1; // i prend la valeur 1 i=j;
i = ‘Z’; // valeur ASCII du caractère ‘Z’ (i.e. 90)
• Affectation multiple
• i=j=k=1; // i,j,et k prennent toutes la même valeur 1
• Les variables affectées doivent toutes être du même type
Expressions et opérateurs
• Une expression ?
• Formée à partir de constantes, d’identificateurs et d’autres expressions à l’aide d’opérateurs
• une expression a une valeur
• Exemple : 2+3, &i, ...!
• Une expression a un type
• ce type dépend du type des opérandes
• 2+3 est fondamentalement de type int!
• x = 2.5 + 3.2;!
• L'expression 2.5 + 3.2 implique que x soit de type float!
Expressions arithmétiques
• Opérateurs arithmétiques
• Binaires (Les priorités sont identiques à celles appliquées en mathématiques)
• +! : Addition (x + y)!
• - : Soustraction (x - y)!
• * : Multiplication (x * y)!
• / : Division (x / y)!
• % : Reste de la division entière (x % y)!
! ! (implique que les opérandes soient de type int)!
• Unaire
• - : Négation d'une valeur (Exemple : -x)
• Type!
• Le résultat d'une expression arithmétique est
• float si au moins l’un des opérandes est de type float!
• int sinon (éventuellement char)
• Exemple :
• 8.2/2 aura pour résultat 4.1 (type float)
• 5/2 aura pour résultat 2 (type int)
• Et 5%2 est égal à 1!
Expressions arithmétiques
• Evaluation
• De la gauche vers la droite en respectant les priorités arithmétiques
• Parenthésage
• Modifie les priorités classiques d'application des opérateurs arithmétiques
• x = a - b * c; ! !x = (a - b) * c;!
• Lève d'éventuels doutes ...
• x = a * b / c; ! !x = a * (b / c);!
Expressions arithmétiques
• Typiquement « C »
• i = i <opérateur> <expression>; #
• s'écrit également i <opérateur>= <expression>;!
• Exemple :
• i += 3; est équivalent à i = i + 3;!
• i *= j; est équivalent à i = i * j;!
• i /= (j+3); est équivalent à i = i / (j+3);!
• ...!
• Incrémentation/décrémentation
• i = i + 1; s'écrit souvent i++;!
• i = i - 1; s'écrit souvent i--;!
Conversion de type - cast
• Modifie le type d’une donnée en une autre
int x;
x=(int)3.14;
À utiliser avec prudence
Expressions logiques
• VRAI ou FAUX ?
Le type booléen n'est pas défini
• Règle générale
• Toute valeur (quel que soit son type) qui est égale à 0 a la valeur logique FAUX
• Toute valeur différente de 0 a la valeur logique VRAI
• Toute expression arithmétique a une valeur logique
• C'est une expression logique. L'inverse n'est pas vrai.
• Exemple : i=-2; (VRAI) i=0; (FAUX)
Expressions logiques
• Opérateurs de comparaison
• Binaires
• Egalité « == » : (attention à la confusion avec « = »)
• Différence « != » : signifie « not equal »
• Inégalité « < », « > », « <= », « >= »
• Unaire
• « Non » logique « ! » : si a est égal à 0 alors « !a » vaut VRAI
• Opérateurs logiques
• Binaires
• « ET » logique
• VRAI si tous les termes sont VRAI
• « && » ex: a = ((i > 1) && (k <= 3));!
• « OU » logique
• VRAI si au moins un des termes est VRAI
• « || » ex: a = ((i > 1) || (k <= 3));!
Expressions logiques « bit à bit »
• Opérations booléennes sur une ou deux valeurs entières.
char a = 5; /* soit 00000101 binaire */!
• Opérateurs binaires
• <<!
• Décalage vers la gauche (insertion d'un 0 sur la droite
• Exemple : a = a << 2; /* (ou a <<= 2;) */!
• Insère deux 0 à la droite de a soit 00010100 qui vaut 20!
• INFO: le décalage à gauche est une multiplication par 2
• >>!
• Décalage à droite avec insertion de 0!
• Exemple : a = a >> 2; /* (ou a >>= 2;) */!
• Insère deux 0 à la gauche de a soit 00000001 qui vaut 1!
• INFO: l'insertion de 0 à droite est une division entière par 2
• Attention : valeurs signées
Expressions logiques « bit à bit »
• char a = 5; /* soit 00000101 binaire */!
• Opérateurs binaires
• &!
• « ET » bit à bit
• Exemple : a = a & 1; /* (ou a &= 1;) */!
• Calcul du « ET » binaire de 00000101 et 00000001 soit 1!
• |!
• « OU » bit à bit
• Exemple : a = a | 8; /* (ou a |= 8;) */!
• Calcul du « OU » binaire de 00000101 et 00001000 soit 00001101 (c'est à dire 13)
• ^!
• « OU exclusif » bit à bit
• Exemple : a = a ^ 9; /* (ou a ^= 9;) */!
• Calcul du « XOR » de 00000101 et 00001001 soit 00001100!
• Opérateur unaire
• ~ : négation de tous les bits (~a est égal à 11111010)
Lecture/écriture sur ES standard
• printf( ) : Affichage sur sortie standard#
!printf(« chaîne formatée », i, j, ...);!
!
• scanf( ) : Saisie de valeurs au clavier
!scanf(« chaîne formatée », &i);!
• « & » précédent le nom des variables est obligatoire !!!
• Exemples de format :
• %d : int ; %f : float ; %c : char ; ... #
• Exemple
• scanf (« %d », &i );#
• scanf (« %d », &j);#
• printf(« i = %d, j = %d », i, j);#
Lecture/écriture sur ES standard
• Les formats
• %c : caractère
• %d : entiers (%4d : entier sur 4 caractères)
• %o : entier octal (précédé d'un « 0 »)
• %x : hexadécimal (précédé de « 0x »)
• %f : flottant (%.3f : avec 3 nombres aprés la virgule)
• %e, %E : flottant en notation exponentielle (ex : 2.5e5)
• %g : flottant (%f ou %e)
• %s : chaîne de caractères
• %p : pointeur (une adresse mémoire)
Lecture/écriture sur ES standard
• Les caractères spéciaux des chaînes de caractères
• \n #: Retour à la ligne
• \t : Tabulation
• \r : Retour chariot
• \b : Backspace
• \a : Sonnerie
• \» : Guillemet
• \' : Quote
• \\# : Anti-slash
• %% : « % »
Lecture/écriture sur ES standard
• La saisie et l'affichage en mode caractère
• getchar()!
• Saisie d'un caractère sur l'entrée standard
• Exemple : char c; c = getchar();!
• putchar()!
• Affichage d'un caractère sur la sortie standard
• Exemple : putchar(c);!
