Vous êtes sur la page 1sur 40

Structure d’un programme en C

#include <stdio.h>
#include <stdlib.h>

int main()
{
printf(« Programmation en C\n");
return 0;
}

• #include pour indiquer au compilateur d’ajouter une librairie (stdio,


stdlib,conio,math, string,…)
• main ( ) contient le programme à exécuter
• printf( ) instruction d’affichage

• Utiliser un IDE : Code::Blocks, ou Visual C++ ou autre pour


– Saisir, modifier, enregistrer et exécuter un programme en C
IDE
Types de données
Les types de données traités dans un programme les caractères, les
entiers, les réels, les chaines de caractères, les pointeurs, les
structures.
Caractères : Symboles alphanumériques (a,z,!,1,9) + caractères spéciaux (retour à la
ligne, tabulation, etc..)
\n : retour à la ligne
\t : tabulation
\f : nouvelle page
\' : apostrophe
\0 : caractère nul (indique la fin d'une chaîne de caractères)
ex : 'a', '1', '\n‘
Entiers
ex : 0 , -12, 328
Réels
3.14, 2.3 e+4
Variables
Les variables permettent de traiter les données d’un programme (saisie,
calcul, affichage). Pour utiliser une variable il faut la déclarer (nom,
type), l’initialiser.
Déclaration
type nom;
Les types de données :
int pour les entiers :
int pgcd
float pour les réels :
float moyenne
char pour les caractères :
char voyelle
Le nom est une suite de caractères sans accent ni espace, il doit être
explicite et commence par une lettre
Variables

Initialisation des variables


à l'exécution :
int i;
i = 0;
à la compilation
int i = 0;
Pour la conversion des variables d’un type à un autre on utilise le cast :
variable=( type ) expression
int a; float x; char c;
a=2;
x=(float) a; //conversion d’un réel en entier
Programme

Calculer la somme de 2 entiers


#include <stdio.h>
int main()
{
int a,b,s;
a=2;
b=3;
s=a+b;
printf(‘’la somme est: %d\n’’,s);
return 0;
}
Les entrées/sorties (lecture/écriture)
Pour la lecture des données au clavier, on utilise la fonction
scanf (format, arg1,arg2,……,argn)
exemple :
int i; float x;
scanf("%d %f", &i,&x);
Format des données
%c : donnée de type caractère simple
%d : donnée de type entier
%f : donnée de type flottant
%s : donnée de type chaîne de caractères
Les entrées/sorties (lecture/écriture)
Pour l’écriture des données on utilise la fonction
printf(format, arg1,arg2,…..,argn);
Exemples :
printf("bon"); printf("jour");printf("\n") bonjour
i=j=1;
printf("i=%d\n",i) i=1
printf("%d%d%d\n",i,j,i+j); 112

Autres fonctions d'E/S


getchar() : sert à la lecture de caractères isolés
la valeur de getchar() est le code ascii du caractère lu
char c;
c = getchar();
Les entrées/sorties (lecture/écriture)
putchar(caractère)

Exemple
char c;
c='a';
putchar ( c );
putchar ('\n');
putchar('b');
Les entrées/sorties (lecture/écriture)
gets, puts permettent de lire et écrire des chaînes de caractères

exemple :
#include <stdio.h>
int main()
{
char ligne[80];
gets(ligne);
puts(ligne);
return 0;
}
Opérateurs

Opérateurs bi-opérandes
+ , -,* , / , % (modulo)
Opérateurs unaires (un opérande)
incrémentation, décrémentation : ++ (+1) , -- (-1)
exemple :
int i =1;
++i;
printf("%d",i) ; -> 2;
Syntaxes : ++i ou i++
++i : la valeur de i est d'abord incrémenté, la valeur résultat est
utilisée dans l'expression courante
i++ : la valeur courante de i est utilisée dans l'expression courante,
puis i est incrémenté
Opérateurs d'affectation

Affectation et opération : +=, -=, *=, /=, %=,<<= , >>=, &=, |=,
^=

Syntaxe : variable opérateur =expression


équivalent à : variable = variable opérateur expression

Exemple :
int i;
i= 3;
i+=2; (i=i+2;)
printf("%d\n",i); -> 5
Opérateurs relationnels et logiques
Valeur logique :
0 : faux
#0 : vrai

Relationnels : >= , > , == , <, <= , !=


La valeur de l'expression est 1 si l'expression est vraie , 0 si elle est fausse
Exemple : 2 < 3 vaut 1 , 2 > 3 vaut 0

test d'égalité == et l'affectation =

Logiques : && "et" logique , || "ou" logique, ! "non" logique


Opérateur conditionnel

Syntaxe
expression1 ? expression2 : expression3

est équivalent à :
if (expression1) expression2; else expression3;

Exemple :
maximum = (x>y) ? x : y;

if (x>y) maximum =x ; else maximum = y;


Fonctions mathématiques
inclure le fichier d'en tête math.h
fonctions mathématiques

Fonction Explication Exemple

exp(x) fonction exponentielle y=exp(x)

log(x) logarithme naturel y=log(x)

log10(x) logarithme à base 10 y=log10(x)

pow(x,y) xy z=pow(x,y)

sqrt(x) racine carrée de x y=sqrt(x)

fabs(x) valeur absolue y=fabs(x)

floor(x) arrondir en moins floor(1.9) renverra 1

ceil(x) arrondir en plus ceil(1.4) renverra 2

sin(x) sinus de x y=sin(x)

cos(x) cosinus de x y=cos(x)

tan(x) tangente de x y=tan(x)


Structures de contrôle
Alternative en C

if (expression) action1 ;
else action2 ;

fin de l'instruction if


if (z == 3) {
printf("calcul juste");
z=z+10;
}
else printf ("problème");
printf ("%d",z);

Switch en C
Sélection multiple : en C, la sélection ne peut être qu'une comparaison
à des constantes


switch (z) {
case 3 : printf("ok"); break;
case 4 : printf("PB1"); break;
default : "printf ("PB2");
};

Itération en C
Ex: imprimer tous les nombres de 1 à 10

TANT QUE : while (condition) action; x=1;


while (x <=10) {
printf("%d\n",x);
x=x+1;
};

JUSQU'À CE QUE : do action while (condition);
x=1;
do {
printf("%d\n",x);
x=x+1;
}
while (x <= 11);

Itération en C

La boucle for simule un compteur

for(x=1; x≤10; x=x+1)


printf("%d\n",x);

x est un compteur, 1 valeur initiale du compteur, 10 valeur finale, +1


pas d’incrémentation
Nombres pseudo aléatoires
Pour générer des nombres aléatoires entre 0 et un max.
srand (time (NULL));
nb_alea = rand() % 100; // nombre aléatoire entre 0 et 100
srand (time (NULL)) permet d'initialiser le générateur de nombres
pseudoaléatoire.
rand() renvoie un nombre compris entre 0 et RAND_MAX
inclure le fichier d'en tête time.h pour les heures
inclure le fichier d'en tête stdlib.h pour les nombres aléatoires
Tableaux
Lorsque on veut traiter plusieurs données de même type, on
utilise le concept de tableau
Exemple
int tab[100];
int : type des éléments du tableau
tab : identificateur (nom du tableau)
100 : nombre d'éléments du tableau (dimension)

tab peut recevoir 100 entiers identifiés de 0 à 99


le premier est tab[0]
le second tab[1]
..
le dernier tab [99]
Tableaux

Exemples :
stocker les 100 premiers nombres pairs : 0,2,4,...,196,198

int i, t[100];
for (i=0; i < 100; i=i+1)
t[i]= 2*i;
Matrices
int mat[2][2];
for(i=0;i<2;i++)
for(j=0;j<2;j++)
scanf(‘’%d’’,&mat[i][j]);
Chaînes de caractères

Pour les chaines de caractères on utilise des tableaux de


caractères.
Convention : le dernier caractère utile est suivi du caractère
\0
Exemples :
char t[10]; (9 caractères max, puisque une case réservée pour \0;
strcpy(t,"abcdefghi") 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 0
chaque lettre est accessible par son indice
char t[12];
strcpy(t,"abcdefghi"); 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 0 ? ?
Initialisation char t[12]= "abcdefghi"; ou char t[]= "abcdefghi";

Constante chaîne de caractères


#define ceciestuntexte "azssddqsdqsd"
Fonctions de manipulations de chaînes de
caractères
Rappel : une chaîne de caractères est un tableau de caractères. Le caractère \0
marque la fin de la chaine.

#include "string.h"
....
char S1[]="abcd";
char S2[20];
S2 = S1 ; incorrect
strcpy(S2,S1);

Les tableaux de mots ou matrices


char mots[2][15];
for(i=0;i<2;i++)
scanf(‘’%s’’,mots[i]);
Fonctions de manipulations de chaînes de
caractères

strlen(char * s) : donne la longueur de s, le 0 final non compris


strcat (char * s1, char * s2): ajoute s2 à la fin de s1
strcmp(char * s1, char * s2): compare les chaines. Valeur de retour :
>0 si s1 > s2
=0 si s1 = s2
<0 si s1 < s2
"abc" < "abcd"
"aa"< "ab"
"aa" < "b "
Lecture/Ecriture dans fichiers

Un fichier va contenir des données stockés sur disque


Ex. un fichier de personne, de notes, …

Déclaration :
FILE * variable-interne
ex : FILE * f; // f est une variable spéciale de type "fichier"
Ouverture de fichier : fopen
Ouverture et affectation
variable = fopen("nom du fichier sur disque",mode d'ouverture)
mode d'ouverture :
'r' = read = lecture
'w' = write = écriture
'a' = append = écriture à la fin

fopen renvoie la valeur NULL (=0) si pb sur le fichier physique

Exemple
FILE * f;
f = fopen ("c:\texte.txt", "r");
if (f==NULL) printf ("le fichier est absent\n");
else printf ("ok\n");
Fermeture du fichier : fclose

Syntaxe
fclose (variable interne)

Exemple :
FILE * f;
f= fopen (fichier1, "r");
….
fclose (f);

f= fopen (fichier2,"w");

Lecture/Ecriture dans fichier

Lecture :
fgetc()
exemple
c=fgetc(f);

fscanf()
exemple
fscanf(f,"%s’’,s1) le 1er argument est la variable interne fichier
le caractère EOF indique la fin de fichier
La fonction feof(f) teste la fin de fichier
Ecriture
fputc ()
fprintf (f,"%d",i)
Exercice
Afficher à l'écran le contenu d'un fichier
main()
{
FILE * f;
char fichier[100]; char mot[20];
/* acquisition du nom */
scanf("%s",fichier);
/*ouverture*/
f=fopen(fichier,"r");
if (f==NULL) printf("erreur\n");
else
{
while (!feof(f))
{
fscanf(f,’’%s’’,mot);
printf("%s",mot);
}
fclose (f);
}
Lecture et écriture de fichiers binaires
FILE *f;
int x[10];
fwrite(x,10,1,f);
fread(x,10,1,f);
Fonctions
Les fonctions permettent de structurer un programme , de faciliter sa
maintenance et sa lisibilité
Déclaration
type nom (type_arg1 arg1, …, type_argn argn) {

return (valeur retournée);
}

int som(int a, int b)


{
int s;
s=a+b;
return s;
}

Le type de la fonction ne peut être que :


int, float, char, ou adresse de
Type de la fonction
Appel de la fonction
nomFonction(arguments)
total=som(x,y)
Une fonction peut ne pas renvoyer de valeur.
Exemple
void som(int a,int b)
{
int s;
s=a+b;
printf(‘’la somme de %d %d est %d’’,a,b,s);

Dans ce cas, le type de la fonction est : void


Visibilité des variables

variables globales
Les variables déclarées avant la 1ere fonction peuvent être utilisées dans
toutes les fonctions. Ces variables sont dites globales.

#include "stdio.h"
int i;

void f1 () {
i = i+1;
}

void main(){
i=0;
f1();
printf("%d\n",i) -> 1
}
Visibilité des variables
variables locales
Les variables déclarées dans une fonction ne peuvent être utilisées
que dans cette fonction. Ces variables sont dites locales.

void f1 () {
int i;
i = i+1;
}
void main(){
i=0; -> ERREUR : i n'existe pas pour main
...
}
Visibilité des variables

Les arguments d'une fonction sont des variables locales de la fonction.


void f1 (int i) {
i = i+1; /* i est une variable locale de la fonction */
}
void main(){
int j=1;
f1(j);
printf("%d\n",j)
}
Variable static
la variable conserve sa valeur à travers les appels de la
fonction

void inc( ) void inc( )


{ {
int i=0; static int i=0;
i++; i++;
printf ("%d", i); printf ("%d", i);
} }

1, 1, 1, 1, … 1, 2, 3, 4, …
Récursion
Définitions :
Une notion est dite récursive quand elle fait référence à elle-même
Exemple :
n! = n*(n-1)!

int facto (int n) {


int p;
if (n==0) return (1);
else {
p = n * facto(n-1); /* appel récursif à la fonction facto */
return (p);
}

Lors du calcul de facto(n) il y a n appels à la fonction facto.


Récursion
Exemple 2 : Suite récurrente : Suite de Fibonacci (récursion double);
Un = Un-1 + Un-2
U1 = U0 =1

int fibo (int n) {


if ((n==0) || (n==1)) return (1);
else return ( fibo(n-1) + fibo (n-2) ); /* appel récursif à la fonction fibo */
}

Vous aimerez peut-être aussi