Cours gratuits » Cours informatique » Cours programmation » Cours langage C » Ebook : Support de Cours Langage C de Florence HENRY

Ebook : Support de Cours Langage C de Florence HENRY

Problème à signaler:

Télécharger



★★★★★★★★★★3.5 étoiles sur 5 basé sur 1 votes.
Votez ce document:

Ebook : Support de Cours Langage C de Florence HENRY

Chapitre 1 Les bases

1.1 La structure d’un programme

Un programme simple se compose de plusieurs parties :

– des directives de précompilation

– une ou plusieurs fonctions dont l’une s’appelle obligatoirement main(), celle-ci constitue le programme principal et comporte 2 parties :

– la déclaration de toutes les variables et fonctions utilisées

tyle="text-align: justify;">– des insctructions

Les commentaires débutent par /* et finissent par */, ils peuvent s’étendre sur plusieurs lignes.

1.1.1 Les directives de précompilation

Elles commencent toutes par un #.

commande signification

#include <stdio.h> permet d’utiliser les fonctions printf() et scanf()

#include <math.h> permet d’utiliser les fonctions mathématiques

#define PI 3.14159 définit la constante PI

#undef PI à partir de cet endroit, la constante PI n’est plus définie

#ifdef PI si la constante PI est définie, on compile les instructions 1, sinon, les instructions 2 instructions 1 ...

#else

instructions 2 ...

#endif

Parmi ces directives, une seule est obligatoire pour le bon fonctionnement d’un programme :

#include <stdio.h> . En effet, sans elle, on ne peut pas utiliser les fonctions utiles pour l’affichage à l’écran : printf() et la lecture des données au clavier : scanf(). Nous verrons le fonctionnement de ces fonctions plus tard.

1.1.2 La fonction main()

Elle commence par une accolade ouvrante { et se termine par une accolade fermante }. À l’intérieur, chaque instruction se termine par un point-virgule. Toute variable doit être déclarée.

main(){

int i ; /* declaration des variables */ instruction_1 ;

instruction_2 ;

...

}

Exemple de programme simple :

#include <stdio.h>

/* Mon 1er programme en C */

main(){

printf("Hello world\n") ;

}

1.2 La compilation sous Unix

Une fois le programme écrit, on ne peut pas l’exécuter directement. Pour que l’ordinateur comprenne ce que l’on veut lui faire faire, il faut traduire le programme en langage machine. Cette traduction s’appelle la compilation.

On compile le programme par la commande cc prog.c, où prog.c est le nom du programme. La compilation crée un fichier exécutable : a.out. On peut vouloir lui donner un nom plus explicite, et pour cela, à la compilation, on compile avec la commande cc -o prog prog.c qui va appeler le programme exécutable prog au lieu de a.out.

On démarre alors le programme avec la commande ./prog.

4 Chapitre 2

Variables et constantes

2.1 Les constantes

Constantes entières 1,2,3,...

Constantes caractères ’a’,’A’,...

Constantes chaînes de caractères "Bonjour"

Pas de constantes logiques Pour faire des tests, on utilise un entier. 0 est équivalent a faux et tout ce qui est 6= 0 est vrai.

2.2 Les variables

2.2.1 Noms des variables

Le C fait la différence entres les MAJUSCULES et les minuscules. Donc pour éviter les confusions, on écrit les noms des variables en minuscule et on réserve les majuscules pour les constantes symboliques définies par un #define. Les noms doivent commencer par une lettre et ne contenir aucun blanc. Le seul caractère spécial admis est le soulignement (_). Il existe un certain nombre de noms réservés (while, if, case, ...), dont on ne doit pas se servir pour nommer les variables. De plus, on ne doit pas utiliser les noms des fonctions pour des variables.

2.2.2 Déclaration des variables

Pour déclarer une variable, on fait précéder son nom par son type.

Il existe 6 types de variables :

type signification val. min val. max

char caractère codé sur 1 octet (8 bits) −2

7 2

7 −1

short entier codé sur 1 octet −2

7 2

7 −1

int entier codé sur 4 octets −2

31 2

31 −1

long entier codé sur 8 octets −2

63 2

63 −1

float réel codé sur 4 octets ∼ −1038 ∼ 1038 double réel codé sur 8 octets ∼ −10308 ∼ 10308

On peut faire précéder chaque type par le préfixe unsigned, ce qui force les variables à prendre des valeurs uniquement positives.

Exemples de déclarations :

déclaration signification

int a ; a est entier

int z=4 ; z est entier et vaut 4

unsigned int x ; x est un entier positif (non signé)

float zx, zy ; zx et zy sont de type réel

float zx=15.15 ; zx est de type réel et vaut 15.15 double z ; z est un réel en double précision char zz ; zz est une variable caractère char zz=’a’ ; zz vaut ’a’

Il n’y a pas de type complexe.

2.3 Les opérateurs

Le premier opérateur à connaître est l’affectation "=". Exemple : {a=b+" ;} Il sert à mettre dans la variable de gauche la valeur de ce qui est à droite. Le membre de droite est d’abord évalué, et ensuite, on affecte cette valeur à la variable de gauche. Ainsi l’instruction i=i+1 a un sens.

Pour les opérations dites naturelles, on utilise les opérateurs +, -, *, /, %.

% est l’opération modulo : 5%2 est le reste de la division de 5 par 2. 5%2 est donc égal à 1.

Le résultat d’une opération entre types différents se fait dans le type le plus haut. Les types sont classés ainsi :

char < int < float < double

Par ailleurs, l’opération ’a’+1 a un sens, elle a pour résultat le caractère suivant à a dans le code

ASCII.

En C, il existe un certain nombre d’opérateurs spécifiques, qu’il faut utiliser prudemment sous peine d’erreurs.

++ incrémente la variable d’une unité.

- - décrémente la variable d’une unité.

Ces 2 opérateurs ne s’utilisent pas avec des réels. Exemples d’utilisation :

i++ ; /* effectue i=i+1 */

i- - ; /* effectue i=i-1 */

Leur utilisation devient délicate quand on les utilise avec d’autres opérateurs. Exemple :

int i=1 , j ;

j=i++ ; /* effectue d’abord j=i et ensuite i=i+1 */

/* on a alors j=1 et i=2 */

j=++i ; /* effectue d’abord i=i+1 et ensuite j=i */

/* on a alors j=2 et i=2 */

Quand l’opérateur ++ est placé avant une variable, l’incrémentation est effectuée en premier. L’incrémentation est faite en dernier quand ++ est placé aprés la variable. Le comportement est similaire pour

- -.

D’autres opérateurs sont définis dans le tableau qui suit :

i+=5 ; /* i=i+5 */

i-=3 ; /* i=i-3 */

i*=4 ; /* i=i*4 */

i/=2 ; /* i=i/2 */

i%=3 ; /* i=i%3 */

Pour finir, ajoutons que les opérateurs qui servent à comparer 2 variables sont :

== égal à != différent de

< inférieur <= inférieur ou égal

> supérieur >= supérieur ou égal

&& ’et’ logique || ’ou’ logique

ATTENTION !

Ne pas confondre l’opérateur d’affectation = et l’opérateur de comparaison ==

Chapitre 4

Les instructions de contrôle

Ce sont des instructions qui permettent de notamment faire des tests et des boucles dans un programme.

Leur rôle est donc essentiel. Pour chaque type d’instruction de contrôle, on trouvera à la fin de la partie 4 les organigrammes correspondant aux exemples donnés.

4.1 Les instructions conditionnelles

4.1.1 Les tests if

L’opérateur de test s’utilise comme suit :

if (expression) then {instruction ;}

/* Si expression est vraie alors instruction est executee */

if (expression) {

instruction 1 ;

} else {

instruction 2 ;

}

/* Si expression est vraie alors l’instruction 1 est executee */

/* Sinon, c’est l’instruction 2 qui est executee */

if (expression 1) {

instruction 1 ;

} else if (expression 2){

instruction 2 ;

} else if (expression 3){

instruction 3 ;

} else {

instruction 4 ; }

/* Souvent, on imbrique les tests les uns dans les autres */

Remarque : les instructions à éxécuter peuvent être des instructions simples {a=b ;} ou un bloc d’instructions {a=b ; c=d ; ...}.

Comme nous l’avons déjà vu, une expression est vraie si la valeur qu’elle renvoie est non nulle.

ATTENTION ! les expressions (a=b) et (a==b) sont différentes :

if (a==b) vrai si a et b sont égaux

int b=1 ;

if (a=b) on met la valeur de b dans a. a vaut alors 1. l’expression est donc vraie

4.1.2 Les tables de branchement : switch

Cette instruction s’utilise quand un entier ou un caractère prend un nombre fini de valeurs et que chaque valeur implique une instruction différente.

switch(i) {

case 1 : instruction 1 ; /* si i=1 on exécute l’instruction 1 */

break ; /* et on sort du switch */

case 2 : instruction 2 ; /* si i=2 ... */

break ;

case 10 : instruction 3 ; /* si i=10 ... */

break ;

default : instruction 4 ; /* pour les autres valeurs de i */

break ;

}

ATTENTION ! on peut ne pas mettre les break ; dans les blocs d’instructions. Mais alors on ne sort pas du switch, et on exécute toutes les instructions des case suivants, jusqu’à rencontrer un break ;.

Si on reprend l’exemple précédent en enlevant tous les break, alors

? si i=1 on exécute les instructions 1, 2, 3 et 4

? si i=2 on exécute les instructions 2, 3 et 4

? si i=10 on exécute les instructions 3 et 4

? pour toutes les autres valeurs de i, on n’exécute que l’instruction 4.

4.2 Les boucles

4.2.1 La boucle for

Elle permet d’exécuter des instructions plusieurs fois sans avoir à écrire toutes les itérations. Dans ce genre de boucle, on doit savoir le nombre d’itérations avant d’6etre dans la boucle. Elle s’utilise

ainsi :

for (i=0 ; i<N ; i++) {

instructions ... ;

}

Dans cette boucle, i est le compteur. Il ne doit pas être modifié dans les instuctions, sous peine

de sortie de boucle et donc d’erreur.

? La 1ere ` instruction entre parenthèses est l’initialisation de la boucle.

? La 2eme `est la condition de sortie de la boucle : tant qu’elle est vraie, on continue la boucle. ? Et la 3eme ` est l’instruction d’itération : sans elle, le compteur reste à la valeur initiale et on ne sort jamais de la boucle.

4.2.2 La boucle while

Contrairement à la boucke for, on n’est pas obligés ici de connaître le nombre d’itérations. Il n’y a pas de compteur.

while (expression) {

instructions ... ;

}

L’expression est évaluée à chaque itération. Tant qu’elle est vraie, les instructions sont exécutées.

Si dès le début elle est fausse, les instructions ne sont jamais exécutées.

ATTENTION ! Si rien ne vient modifier l’expression dans les instructions, on a alors fait une boucle infinie : while (1) { instructions } en est un exmple.

Exemple d’utilisation :

#include <stdio.h>

main(){

float x,R ;

x=1.0 ;

R=1.e5 ;

while (x < R) {

x = x+0.1*x ;

printf("x=%f",x) ;

}

}

4.2.3 La boucle do ... while

À la différence d’une boucle while, les instructions sont exécutées au moins une fois : l’expression est évaluée en fin d’itération.

do {

instructions ... ;

} while (expression)

Les risques des faire une boucle infinie sont les mêmes que pour une boucle while.

4.2.4 Les instructions break et continue break fait sortir de la boucle.

continue fait passer la boucle à l’itération suivante.

13

sortie de la boucle

i++

i<N ?

i=0

instructions ;

{

}

Organigramme

d’une boucle for

faux

vrai

entree dans le for

Les boucles

{

instructions;

}

sortie

du

while

expression ?

entree du while

vrai

faux

Organigramme

d’une boucle while

{

instructions;

}

sortie

du

while

expression ?

vrai

faux

Organigramme

entree du do ... while

d’un do ... while

Les tests

entree dans le if

{

}

instructions 4;

i=10 ?

{

instructions 3;

}

instructions 1;

}

{

i=2 ?

}

instructions 2;

{

break ?

break ?

break ?

entree du switch

Organigramme d’un switch

expression 1 ?

{

}

instruction 1;

expression 2 ?

{

}

instruction 2;

expression 3 ?

{

}

instruction 3;

{

}

instruction 4;

faux

faux

faux

vrai

vrai

vrai

entree dans le if

Exemple 3 d’organigramme d’un if Sortie du

switch sortie

du if

{

}

vrai

Exemple 1 d’organigramme d’un if

sortie

du if

expression 1 ?

{

}

instruction 1;

{

}

instruction 2;

faux

vrai

entree dans le if

Exemple 2 d’organigramme d’un if sortie

du if expression 1 ? instruction 1;

FIG. 4.1 – Organigramme récapitulatif des structures de contrôle.

14

Chapitre 5

Les fonctions

Créer une fonction est utile quand vous avez à faire le même type de calcul plusieurs fois dans le programme, mais avec des valeurs différentes. Typiquement, pour le calcul de l’intégrale d’une fonction mathématique f . Comme en mathématique, une fonction prend un ou plusieurs arguments entre parenthèses et renvoie une valeur.

5.1 Déclaration

On déclare une fonction ainsi :

type nom( type1 arg1 , type2 arg2, ... , typen argn) { */ prototype */ déclaration variables locales ;

instructions ;

return (expression) ;

}

type est le type de la valeur renvoyée par la fonction. type1 est le type du 1er argument arg1

... . Les variables locales sont des variables qui ne sont connues qu’à l’intérieur de la fonction.

expression est évaluée lors de l’instruction return (expression) ;, c’est la valeur que renvoie

la fonction quand elle est appelée depuis main().

La 1ere `

ligne de la déclaration est appelée le prototype de la fonction.

Exemple de fonction :

float affine( float x ) { /* la fonction ’affine’ prend 1 argument réel */

/* et renvoie un argument réel */

int a,b ;

a=3 ;

b=5 ;

return (a*x+b) ; /* valeur renvoyee par la fonction */

}

On n’est pas obligés de déclarer des variables locales :

float norme( int x, int y ){ /* la fonction ’norme’ prend 2 arguments */

/* entiers et renvoie un résultat réel */

return (sqrt(x*x+y*y)) ; /* sqrt est la fonction racine carree */

}

On peut mettre plusieurs instructions return dans la fonction :

float val_absolue( float x ) {

if (x < 0) {

return (-x) ;

} else {

return (x) ;

}

}

Une fonction peut ne pas prendre d’argument, dans ce cas-là, on met à la place de la déclaration des arguments, le mot-clé void :

double pi( void ) { /* pas d’arguments */

return(3.14159) ;

}

Une fonction peut aussi ne pas renvoyer de valeur, son type sera alors void :

void mess_err( void ) {

printf("Vous n\’avez fait aucune erreur\n") ;

return ; /* pas d’expression après le return */

}

5.2 Appel de la fonction

Une fonction f() peut être appelée depuis le programme principal main() ou bien depuis une autre fonction g() à la condition de rappeler le prototype de f() après la déclaration des variables de main() ou g() :

#include <stdio.h>

main(){

int x,y,r ;

int plus( int x, int y ) ;

x=5 ;

y=235 ;

r=plus(x,y) ; /* appel d’une fonction avec arguments */

}

int plus( int x, int y ){

void mess( void ) ;

mess_err() ; /* appel d’une fonction sans arguments */

return (x+y)) ;

}

void mess( void ) {

printf("Vous n\’avez fait aucune erreur\n") ;

return ;

}

Quand le programme rencontre l’instruction return, l’appel de la fonction est terminé. Toute instruction située après lui sera ignorée.

Chapitre 6

Les tableaux

6.1 Déclaration

Comme une variable, on déclare son type, puis son nom. On rajoute le nombre d’éléments du tableau entre crochets [ ] :

float tab[5] ; est un tableau de 5 flottants.

int tablo[8] ; est un tableau de 8 entiers.

ATTENTION !

? Les numéros des éléments d’un tableau de n éléments vont de 0 a n−1.

? La taille du tableau doit être une constante (par opposition à variable), donc int t1[n] ; où n serait une variable déjà déclarée est une mauvaise déclaration. Par contre si on a défini #define N 100 en directive, on peut déclarer int t1[N] ; car N est alors une constante.

On peut initialiser un tableau lors de sa déclaration :

float tab[5] = { 1, 2, 3, 4, 5} ; /* init. de tous les éléments de tab */

float toto[10] = {2, 4, 6} ; /* equ. à toto[0]=2 ; toto[1]=4 ; toto[2]=6 ; */

/* les autres éléments de toto sont mis à 0. */

6.2 Utilisation

Comme shématisé ci-contre, on accède à l’élément i d’un tableau en faisant

tab[0]

float tab[5];

tab[1]

tab[2]

tab[3]

tab[4]

suivre le nom du tableau par le numéro i entre crochets. Un élément de tableau s’utilise comme une variable quelconque. On peut donc faire référence à un élément pour une affectation : x=tab[2], tab[3]=3, ou dans une expression : if (tab[i]

< 0).

6.3 Cas d’un tableau de caractères

Un tableau de caractères est en fait une chaîne de caractères. Son initialisation peut se faire de plusieurs façons :

char p1[10]=’B’,’o’,’n’,’j’,’o’,’u’,’r’ ;

char p2[10]="Bonjour" ; /* init. par une chaîne litterale */

char p3[ ]="Bonjour" ; /* p3 aura alors 8 éléments */

ATTENTION ! Le compilateur rajoute toujours un caractère null à la fin d’une chaîne de caractères.

Il faut donc que le tableau ait au moins un élément de plus que la chaîne litterale.

6.4 Tableau à 2 dimensions

Un tableau à 2 dimensions est similaire à une matrice. C’est en fait

ligne 0

ligne 1

tableau[1][0]

col. 0

col. 1

col. 2

int tableau[2][3];

un tableau de tableau à 1 dimension, il se déclare donc de la façon suivante

:

int tableau[2][3] ; /* tableau de 2 lignes et 3 colonnes */

Comme il est shématisé ci-contre, tableau[i][j] fait référence à l’élément de la ligne i et de la colonne i de tableau. Tout comme un élément d’un tableau à 1 dimension, tableau[i][j] se manipule comme n’importe quelle variable.

Chapitre 7

Les structures

Les structures permettent de rassembler des valeurs de type différent. Par exemple, pour une adresse, on a besoin du numéro (int) et du nom de la rue (char).

7.1 Déclaration

On déclare une structure ainsi :

struct adresse {

int numero ;

char rue[50] ;

} ;

Chaque élément déclaré à l’intérieur de la structure est appelé un champ. Le nom donné à la

structure est appelé étiquette de structure. Ici, on a en fait déclaré un type de structure, pas une

variable.

On déclare les variables associées à une structure de cette manière :

struct adresse chez_pierre , chez_julie ;

Car si la structure d’une adresse est toujours la même (numéro et nom de la rue), chez_pierre et

chez_julie, qui sont des struct adresse différentes, n’habitent pas au même endroit.

On peut initialiser une structure lors de sa déclaration :

struct adresse chez_pierre={ 15 , "rue_Dugommier" } ;

7.2 Manipulation

On accède aux données contenues dans les champs d’une structure et faisant suivre le nom de la

strucure par un point "." et le nom du champ voulu :

chez_julie.numero=19 ;

strcpy(chez_julie.rue,"avenue Pasteur") ;


140