Notions de Base

Le langage C

Hidouci W.K. / Langage C / ALSDD / ESI

Structure d'un programme
Un fichier source peut contenir :
- des directives pour le préprocesseur (lignes commençant par #)
- des constructions de type (struct, union, enum, typedef)
- des déclarations/définitions de variables et de fonctions

/* directives du préprocesseur */
#include <stdio.h>
#define MAXVAL 300

/* définition d'une variable globales */

int x = 10;

/* définition de la fonction principale : main */

int main( void )
{
int i = 0; /* variable locale */
while ( i < x )
{
printf( "La valeur de i est %d \n", i );
i++;
}
return 0;
}
Les types (Les tailles dépendent de l’implémentation)

Les entiers :
char , signed char , unsigned char 1 octet ou plus
short , signed short , unsigned short 2 octets ou plus
int , signed int , unsigned int 4 octets ou plus
long , signed long , unsigned long 4 octets ou plus
long long , signed long long , unsigned long long 8 octets ou plus
enum <nom> { <cst1> , <cst2> [ = val ], … }

Les réels :
float 4 octets ou plus
double 8 octets ou plus
long double 12 octets ou plus

Les constructeurs de types dérivés :

struct... , union ..., * (pointeur) , [ ] (tableaux) , ( ) (fonctions)

Ex :
struct point
double x ;
double y ;
} p;

int tab[10];
Les instructions du langage C

instruction-composée { [déclarations...] [instructions ...] }

instruction-expression exp ;

instruction-goto goto etiq ;

Instruction-étiquetée etiq:instruction

instruction-if if (exp) instruction [else instruction]

instruction-switch switch(exp) { liste de case... }

instruction-while while (exp) instruction

instruction-do do instruction while (exp) ;
instruction-for for(exp ; exp ; exp) instruction

instruction-break break ;
instruction-continue continue ;

instruction-return return ; ou return exp ;

instruction-vide ;
Les instructions du langage C

switch ( <exp> ) {
case <exp-cste> : <instr>; … [break;]
case <exp-cste> : <instr>; … [break;]
…
[default : <instr>; … ]
}

for ( <exp>; <exp>; <exp> )

<instr>

break ;
permet de sortir d'un switch ou d'une boucle

continue ;
dans une boucle, permet de sauter l'itération courante et passer à la prochaine

return [exp] ;
permet de sortir d'une fonction avec éventuellement un résultat = exp
Les expressions exp → Cste / Var / exp_complexe

= affectation exp1 = exp2

() appel de fonction exp1 ( exp2 , exp3 , … )

() type cast (exp1) exp2 ex : x = (float) i / j ;

sizeof type en mémoire sizeof(exp) ou sizeof exp

[] indexation exp1 [ exp2 ]

. ou -> sélection d’un champ exp . NomChamp ou exp->nomChamp

* indirection *exp
& adresse &exp

++ incrémentation exp++ ou ++exp

-- décrémentation exp-- ou --exp

! négation ! exp
== égalité exp1 == exp2
!= différence exp1 != exp2

&& ET logique exp1 && exp2 ex : x == 1 && y > 3

|| OU logique exp1 || exp2

? conditionnelle exp1 ? Exp2 : exp3 ex : x = (y>0 ? 1 : 0) ;

… … …
Exemples

if ( ( (x = y - 10) % 2) == 0 )
printf( " x est paire\n " );
else
printf( " x est impaire\n " ) ;
(on affecte à x la valeur y-10, ensuite on vérifie si le reste de la division de x par 2 est égal à 0)

x = (y = 1); ou alors
x = y = 1;

x = x+y; ou alors
x += y;

x = x+1; ou alors
x++; évaluation de l'exp avant l’incrémentation de x, ou alors
++x; évaluation de l'exp après l’incrémentation de x
(dans les 3 cas x s'incrémente)

x = 3;
y = x++;
(la val de x est 4 et celle de y est 3)

x = 3;
y = ++x;
(la val de x est 4 et celle de y est 4)
Ce petit programme C lit des caractères depuis l’entrée standard et compte :
le nombre de ‘a’ (nba), le nombre de ‘b’ (nbb), le nombre de ‘c’ (nbc)
et le nombre de caractères blancs (espace ‘ ‘, tabulation ‘\t’ et fin de ligne ‘\n’)

#include <stdio.h>

int main( void )

{
int c;
int nba = 0, nbb = 0, nbc = 0, blancs = 0;

while ( (c = getchar( ) ) != EOF )

switch (c) {
case 'a' : nba++; break;
case 'b' : nbb++; break;
case 'c' : nbc++; break;
case ' ' :
case '\t':
case '\n': blancs++;
}

printf( "nb a = %d \t nb b = %d \t nb c = %d \t nb car blancs = %d\n", nba, nbb, nbc, blancs );

return 0;
}