Liste de  cours langage c

Cours de didactique pour reviser le langage c complet


Télécharger



Cours de didactique pour réviser le  langage c  complet

I- Introduction

Langage créé dans les années 70, par la Bell Tel Lab,  par Kernighan Ritchie pour l’écriture du système UNIX.

Conçu comme :

super assembleur :


y;">. très puissant, syntaxe évoluée

. indépendant de la machinebmais :

. peu typé, peu de contrôles de types

. maintenance difficile

. la lecture peut être difficile si on utilise toute la puissance syntaxique

Utilisé comme langage évolué ( Pb !)

Il faut être prudent (à cause du manque de contrôle) [à l’encontre de la philosophie ADA]

2 normes : KR, ANSI

II- Notions de base.

1- Compilateur sensible à la casse.

Attention, lettre majuscule différente de lettre minuscule.

2- Commentaires.

/*  texte commentaire   */

3- Types de base.

a- Caractère :char.

Le type char permet de stocker des valeurs signées ou non (signed  ou unsigned) sur 1 octet. Par défaut, il s’agit de valeurs signées.

char :    valeurs comprises entre -128 et +127

signed char :   idem

unsigned char :  valeurs comprises entre 0 et +255

Le type char est signé à cause de la marque de fin de fichier EOF qui vaut -1.

b-   Entiers : int.

Les entiers peuvent être signés ou non (signed  ou unsigned), courts ou long (short ou long). Par défaut, il s’agit d’entiers courts signés.

int (ou short int ou signed int ou signed short int) : sur 2 octets

   Valeurs comprises entre -32768 et +32767

unsigned int (ou unsigned short int) : sur 2 octets

   Valeurs comprises entre 0 et +65535

long int (ou  long ou signed long int) :sur 4 octets

   Valeurs comprises entre -2.147.483.648 et +2.147.483.647

unsigned long int : sur 4 octets

   Valeurs comprises entre 0 et +4.294.967.295

c- Réels.

Pour stocker les réels, on dispose de deux types, le type flottant simple précision (float) et le type flottant double précision (double).

float : sur 4 octets (1octet pour l’exposant et son signe, 3 octets pour la mantisse et son signe)

Valeurs absolues comprises entre 9,9x 10-38 et 9,9x 10+38

double : sur 8 octets (11 bits pour l’exposant et son signe, 53 bits pour la mantisse et son signe)

Valeurs absolues comprises entre 9,9x 10-307 et 9,9x 10+307

4- Représentation des valeurs

a- Valeurs caractères.

1 caractère entre ‘ ‘

Combinaison de caractères

 ‘\n’ passage à la ligne

 ‘\t’ tabulation

 ‘\b’ back space

 ‘\r’ retour chariot

 ‘\f’ saut de page

 ‘\\’ back slash

Tout caractère peut être exprimé de manière octale

 ‘\0’ caractère NUL

 ‘012’ ‘\n’

b- Valeurs chaines de caractères.

″ chaîne ″

″ exemple de \n texte sur \n 3 lignes ″

un marqueur de fin de chaîne est ajouté  ‘\0’ NUL ASCII

Une chaîne occupe toujours un octet de plus que le nombre de caractères.

c- Valeurs entières.

Par défaut, les valeurs entières sont exprimées en base 10 et  stockées sur des short int.

Exemples :    -32      5678

Si on veut qu’elles soient stockées en long int, il faut faire suivre la valeur de L.

Exemple :   1234567L

Si on veut exprimer les valeurs en base 8 (ou 16), il faut faire précéder la valeur de O (ou Ox ou OX). Exemples :    020    correspond à (16)10        0x20 à (32)10

d- Valeurs réelles.

Elles sont exprimées en notation virgule fixe ou virgule flottante, et stockées en double.

Notation virgule fixe 3.14459     -10.0

 Notation virgule flottante (Mantisse, exposant)

      4e16           -8.2345 E-10

5- Déclarations.

a- constantes symboliques.

#define  <ident>  <expression>

#define PI  3.14592358

#define E  2.718281828

#define entier  int

#define debut  {

#define fin  }

Remarque :

les mot-clés commençant par # sont des directives de précompilation, qui sont traitées avant la compilation. La directive #define permet de remplacer dans le texte source toutes les occurrences de <ident> par <expression>.

b- Variables.

<type>  <ident1>, <ident2>, …, <identn>;

Exemples :

 int   i, j ;

 double  t ;

 long  k ;

 char  reponse ;

 int  tab[10] ; /* tableau de10 entiers*/

Initialisation à la déclaration :

int   i = 0 ;

 double t = 0.1 ;

III- Les opérateurs.

1- Affectation.

<ident> =  <expression> ;

L’affectation peut être vue comme une fonction renvoyant la valeur affectée, on peut donc enchaîner les affectations.

  i = 3 ;

  f = -5E3 ;

  k = total + 1 ;

  c = 2 ;

  a = (b = c) + 4 ;  /* a vaut 6*/

Le membre de gauche doit être d’un type de base (pas d’affectation de tableau).

2- Incrémentation / Décrémentation.

préfixé sur une variable => avant accès

ou postfixé sur une variable => après accès

--

i=2;j=2 ;

k=i++;  /* k vaut 2, i  vaut 3 */

k=++j; /* k vaut 3 j vaut 3 */

i=2;j=2 ;

k=i--;  /* k vaut 2, i vaut 1 */

k=--j; /* k vaut 1 j vaut 1 */

3- Opérateurs arithmétiques.

- <exp>   /* moins unaire */

<exp1> – <exp2> /* soustraction */

<exp1> + <exp2> /* addition */

<exp1> * <exp2> /* multiplication */

<exp1> / <exp2> /* division */

<exp1> % <exp2> /* modulo */

 En ce qui concerne la division, si l’une des expressions est réelle, alors la division est réelle, sinon il s’agit d’une division entière.

Pour le modulo (reste de la division entière), le signe du reste est celui du dividende.

Exemples :

 15%2   /* vaut 1 */

 -15%2   /* vaut -1 */

 15%-2   /* vaut 1 */

 -15%-2   /* vaut -1 */

b * (a/b)+ a%b ≡ a

4- Opérateurs relationnels.

En C, il n’y a ni type ni valeur booléens. Les booléens sont exprimés par des int, la valeur 1 correspondant à VRAI et la valeur 0 à FAUX.

<exp1> == <exp2> /* égalité */

<exp1> != <exp2> /* différent */

<exp1> >  <exp2> /* supérieur */

<exp1> <  <exp2> /* inférieur */

<exp1> >= <exp2> /* supérieur ou égal */

<exp1> <= <exp2> /* inférieur ou égal */

Remarque : a < b < c  =>  VRAI

(avec a = 10,  b=20, c=15)

5- Opérateurs logiques.

<exp1> et <exp2> sont des expressions entières.

<exp1> && <exp2> /* ET logique */ 

 si <exp1> = 0, <exp2> n’est pas évalué

<exp1> || <exp2>   /* OU logique */  

si <exp1> = 1, <exp2> n’est pas évalué

!<exp1>     /* NON logique */

6- Opérateurs de bits.

<exp1> et <exp2> sont des expressions entières( int ou char).

~ <exp2>   /* complément à 1 */

<exp1> & <exp2>  /* ET bit à bit */

<exp1> | <exp2> /* OU inclusif bit à bit */

<exp1> ^ <exp2> /* OU exclusif bit à bit */

<exp1>  <<  <exp2> /* décalage à gauche */

La valeur de <exp1> est décalée à gauche de valeur de <exp2> bits.

<exp1>  >>  <exp2> /* décalage à droite */

La valeur de <exp1> est décalée à droite de valeur de <exp2> bits. Si <exp1> est unsigned, remplissage à gauche par des 0. Sinon, remplissage par des 0 si <exp1>  positive ou nulle, ou remplissage par des 1 si <exp1> est négative (Mais à vérifier en fonction du compilateur).

7- Opérateur conditionnel.

(<exp1>) ? <exp2> : <exp3>

si <exp1> ≠ 0 , l’opérateur renvoie  <exp2> sinon <exp3>

8- Opérateur virgule.

<exp1>,<exp2>

L’opérateur virgule est un séquenceur d’actions. <exp1> est d’abord évaluée, mais son résultat n’est pas pris en compte, puis <exp2> est évaluée  et retournée.  Une telle formulation n’a de sens que si <exp1> produit un « effet de bord ».

Exemple :

 a=b +(c=2,++c) ;

Utilisation de 2 variables de contrôle dans une boucle for :

 for(i=0,j=MAX;i<MAX;i++,j--)

 {-----}

9- Affectation composée.

<exp1>  <op> = <exp2>

<op> pouvant être l’un des opérateurs suivants : +,-,*,/,%,>>,<<,&,|,^

Cette formulation équivaut à : (<exp1>) = <exp1> <op> (<exp2>)

Exemples :

i +=3 ;  /* i=i+3 */

x *= y+1 ;  /* x=x*(y+1) */

a /= b–c ;  /* a=a/(b–c) */

10- Forceur de type.

(<nouveau-type> ) <exp>

<nouveau-type> est un type de base ou un pointeur.

...

Dans ce tableau, les opérateurs sont présentés selon leurs priorités décroissantes du haut vers le bas. La plupart des opérateurs sont binaires, sauf ceux marqués explicitement unaires, ainsi que l’opérateur ternaire ?:.

Lorsqu’une expression comporte des opérateurs de même priorité, l’évaluation se fait de la gauche vers la droite, sauf en ce qui concerne les opérateurs de la seconde ligne et de l’avant dernière ligne du tableau.

12- Impression formatée.

printf(″<chaîne de contrôle>″, <suite d’expressions>) ;

<chaîne de contrôle> est une chaîne de caractères contenant des caractères ordinaires à imprimer tels quels, et des spécifications de format commençant par le symbole %,contenant au moins un caractère indiquant le format d’impression. Chaque spécification de format correspond à l’une des expressions de <suite d’expressions>(selon l’ordre d’apparition).

 d entier décimal signé

 u entier décimal non signé

 o entier octal non signé

 x,X entier hexadécimal non signé

 f réel en notation virgule fixe [-]dddd.dddddd

 e,E réel en notation virgule flottante [-]d.ddddd E[-]ddd

 c caractère

 s chaîne de caractères

<chaîne de contrôle> peut ne pas contenir de spécification de format, auquel cas la chaîne sera affichée telle quelle.

Exemples :

printf(″\nBonjour″);

int i=3, j=4 ;

printf(″\nLa valeur de i est %d et celle de j est %d″, i, j);

Il est possible de préciser entre le symbole % et le caractère de spécifiation de format, une ou plusieurs informations numériques, définissant le nombre de caractères à imprimer.

 %nd indique que la valeur décimale est imprimée sur une zone de n caractères, cadrée à droite

 %m.n f, indique que la valeur réelle est imprimée sur m caractères, dont n chiffres après la virgule. Si m est insuffisant, la partie entière reste prioritaire.

 %m:nE, indique que la valeur réelle est imprimée sur m caractères, dont n chiffres après la virgule (virgule comprise) pour la mantisse.

Exemples :

printf(″/%d/ \n″, 337);  /* imprime /337/   */

printf(″/%10d/ \n″, 337);  /* imprime /      337/   */

printf(″/%-10d/ \n″, 337);  /* imprime /337      /   */

printf(″/%4.2f/ \n″, 1234.56); /* imprime /1234.56/  */

printf(″/%10.3f/ \n″, 1234.56); /* imprime /  1234.560/  */

printf(″/%10:3E/ \n″, 1234.56); /* imprime /  1.23E+03/  */

printf(″%d %c\n″, 336,336); /* imprime 336 P  */

printf(″%d %c\n″, ‘A’,’A’); /* imprime 65 A  */

printf(″%Ld %d\n″, 65616,65616); /* imprime 65616 80  */

13- Lecture formatée.

Le scanf fonctionne sur le même principe que le printf, la suite d’expressions étant remplacée par une suite d’adresses de variables. Pour avoir l’adresse d’une variable, il faut faire précéder l’identificateur du symbole &. Pour les chaînes de caractères, qui sont en fait des tableaux de caractères, ce ne sera pas nécessaire, car le nom d’un tableau est identique à l’adresse de son premier élément.

char libelle[MAX];

-----

scanf(″%d%f″,&pourcentage,&prix);

scanf(″%s″,libelle);

Données tapées au clavier :

25

--------

--------

295.75 chaussure type danse

les affectations produites seront :

pourcentage 25

prix    295.75

libelle  chaussure

Une spécification de format contenant le symbole * après % indique que la donnée correspondante doit être ignorée lors de la lecture.

Exemple :

scanf(″%d%*s%d%*s%d%*s″,&heures,&minutes,&secondes) ;

17 H 35 min 30 secondes

Affectations produites:

Heures  17

Minutes  35

Secondes 30

IV- Les instructions et structures de contrôle.

1- Séquence.

C’est un bloc d’instructions entre accolades.

{ a1 ; a2 ; }

;  terminaison d’instruction

{

 <déclarations locales>

   <suite instructions>   joue le rôle d’une instruction

}

...

V- Les sous-programmes en C.

1- Généralités.

Une seule classe de sous-programme, la fonction, qui regroupe les notions de fonction et de procedure de PASCAL ou ADA.

Une seule syntaxe de déclaration, mais deux syntaxes différentes d’appel, selon qu’il s’agisse d’une fonction ou d’une procedure.

Toutes les fonctions d’un programme sont au même niveau, il n’y a pas d’imbrication possible.

2- Déclaration de fonction.

en C KR

<type-résultat> <ident-fonction>(<liste de paramètres formels>)

<déclarations de paramètres formels>)

{ <déclarations locales>

   <instructions>

}

Attention, ici, la spécification, c’est-à-dire l’en-tête, ne mentionne pas les types des paramètres.

En C ANSI

<type-résultat> <ident-fonction>( <déclarations de paramètres formels>)

{ <déclarations locales>

   <instructions>

}

Ici, la spécification, c’est-à-dire l’en-tête, mentionne les types des paramètres, ce qui est plus rigoureux, surtout dans le cadre de l’utilisation de bibliothèques.

<type-résultat>  qui indique le type du résultat renvoyé par la fonction, doit être un type de base ou un pointeur. Ce ne peut être un tableau ou une structure (sauf en C ANSI). Si <type-résultat> est  absent, il est considéré comme int.

Remarques :

Pas de ; après l’en-tête

Le corps de la fonction comportera  un ou plusieurs return(<expression>) de manière à retourner le résultat.

Si la fonction joue le rôle d’une procedure, <type-résultat> doit être remplacé par void, et le corps de la fonction ne comportera pas de return.

Exemple d’une fonction renvoyant le maximum de 2 entiers passés en paramètres :

int maxEntiers(int a, int b)

{if(a>b)

 return a ;

 else

 return b ;

}

3- Appel de fonction.

Syntaxe :

 <ident-fonction>(liste de paramètres effectifs)

Les paramètres effectifs sont des expressions du même type que les paramètres formels correspondants.

Un seul mode de transmission des paramètres en C, par valeur. Rappelons le fonctionnement de la transmission par valeur :

Les paramètres formels jouent le rôle de variables locales dans lesquelles sont recopiées les valeurs des paramètres effectifs correspondants. Dans ce mode de transmission, l’information venant des paramètres est entrante vis-à-vis du sous-programme.

Si l’on veut modifier de l’information dans l’appelant par le biais des paramètres, il faut que les paramètres formels soient déclarés comme pointeurs, et travailler par indirection dans le corps de la fonction.

Remarque :

Une fonction peut s’appeler récursivement.

4- Portée des déclarations.

a- Variables locales.

toute variable déclarée dans un bloc est locale à ce bloc et globale pour toute la hiérarchie descendante des blocs imbriqués. Le domaine de visibilité est le bloc de déclaration.

Les identificateurs d’un même bloc doivent être tous différents.

Les identificateurs d’un bloc peuvent être les mêmes que ceux d’un bloc englobant, mais ces derniers deviennent inaccessibles.

b- Attributs des variables locales :

auto (par défaut) : variable locale automatique, la place mémoire associée est prise dans la pile d’exécution et libérée lors du retour à l’appelant.

static : variable locale ayant la propriété de rémanence, non allouée dans la pile. Si elle est l’objet d’une initialisation à le déclaration, cette dernière n’a lieu que lors du premier appel à la fonction.

register : attribut réservé aux variables entières ou pointeur, très utilisées qui vont être représentées par un registre. Cette possibilité est plutôt dédiée à la programmation système.

c- Variables externes.

Ce sont des variables déclarées en dehors de toute fonction, en conséquence, elles deviennent globales pour toutes les fonctions du fichier source de déclaration et même pour d’autres fichiers source compilés séparément.

fichier1.c    fichier2.c

La variable i déclarée extern dans fichier2.c est celle de fichier1.c. Si on veut qu’une variable externe soit inaccessible depuis d’autres fichiers sources, il faut la déclarer static.

5- Structure d’un programme.

Il est possible d’organiser le programme de diverses manières, soit :

int f1(int n)

{-------;

--------

--------

}

float f2(int n)

{-------;

--------

--------

}

void main()

{-------;

--------

m = f1(10) ;

y = f2(21) ;

--------

}

soit :

int f1(int );

float f2(int );

void main()

{-------;

--------

m = f1(10) ;

y = f2(21) ;

--------

}

int f1(int n)

{-------;

--------

--------

}

float f2(int n)

{-------;

--------

--------

}

Il est à noter que dans la première configuration, f2() peut appeler f1() mais f1() ne peut appeler f2().

Dans la seconde configuration, déclarant uniquement des prototypes de fonctions avant le main(), toute fonction peut appeler n’importe quelle autre.

 6- Compilations séparées et projet.

Dans le cadre de la réalisation d’un projet informatique de taille conséquente, il convient de le découper en modules plus petits, compilés séparément, et regroupés lors de l’édition de liens en un seul module binaire exécutable.

...

VII- Les pointeurs.

1- Définition.

Un pointeur est une variable contenant l’adresse mémoire d’une autre variable.

2- Déclaration de pointeur.

En C, on doit déclarer le type de l’objet pointé. Exemples :

int * i ; char * p ; float * px, * py ;

aux déclarations factorisées, l’étoile doit être répétée. On a déclaré ici, un pointeur d’entier, un pointeur de caractère et deux pointeurs de réels.

3- Opérateur adresse.

L’opérateur & placé devant un identificateur permet de récupérer l’adresse mémoire de la variable.

int  i ; int * p ;

p=&i;

4- Opérateur d’indirection.

L’opérateur * placé devant un identificateur permet d’accéder au contenu de la cellule mémoire pointée. Toutes les opérations liées au type de l’objet pointé sont permises.

*p = 2; /* i prend la valeur 2 */

k = *P + 1 ; /* k prend la valeur 3 */

Attention :   *p++  équivaut à * (p++)

5- Arithmétique des pointeurs.

On peut ajouter ou retrancher un entier à un pointeur. La valeur effectivement ajoutée dépend du type de l’objet pointé. Une unité correspond à la taille mémoire de l’objet pointé.

Soit un tableau de 4 entiers. Le nom du tableau, nous le verrons plus tard, contient l’adresse du premier élément.

int  tab[4] ; int * p ;

p= tab;

p=p+3;/* p pointe maintenant vers le dernier element du tableau*/

6- Passage de paramètre par adresse dans les fonctions.

Nous avons vu qu’il n’y a qu’un seul mode de transmission des paramètres en C, la transmission par valeur. Si nous voulons avoir le mode par variable de PASCAL ou in out de ADA, il faut le simuler en déclarant le paramètre formel comme un pointeur, et en passant comme paramètre effectif l’adresse de la variable à modifier dans l’appelant.

Exemple d’une fonction travaillant comme une procedure en ADA, doublant la valeur de la variable entière passée en paramètre :

void doubleEntier(int * p)

{

* p= 2 * (*p) ;

}

main()

{int i= 10 ;

 doubleEntier(&i) ;

 printf("\n%d",i) ;/*affiche              20 */

}

Exemple d’une fonction travaillant comme une procedure en ADA, effectuant l’échange des valeurs de deux variables entières passées en paramètres :

void echange(int * a, int * b)

{

int aux ;

aux = *a ;

*a = *b ;

*b=aux ;

}

main()

{int i= 10 ,j= 20;

 echange(&i,&j) ;

 printf("\n%d,%d ",i,j) ;/*affiche  20,10 */

}

7- Relations entre tableaux et pointeurs.

a- Tableaux monodimensionnels.

Le nom du tableau est équivalent à un pointeur constant contenant l’adresse du premier élément.

int  tab[10] ;

tab   équivaut à     &tab[0]

L’expression d’indexation est traduite par le compilateur par une translation d’adresse suivie d’une indirection:

tab[i] est traduit par *(tab + i)

Attention, il est possible (bien que totalement déconseillé) d’effectuer une indexation sur une variable qui n’a pas été déclarée comme tableau. Ainsi :

tab[i] équivaut à     i[tab]

puisque i[tab] est traduit par  *(i + tab), identique à    *(tab + i)

Si un tableau est paramètre formel, la transmission est  implicitement par adresse, et le paramètre effectif correspondant est simplement le nom du tableau.

int sommeElements(int tab[], int N)

{

int i,somme=0 ;

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

somme+=tab[i];

return somme;

}

main()

{int T[4]={10,20,30,40};int s ;

 s=sommeElements(T, 4)

 printf("\n%d",s) ;/*affiche  100 */

}

b- Tableaux multidimensionnels.

Ce sont des tableaux de tableaux, on trouvera plusieurs paires de [] contenant des indices. C’est l’indice le plus à droite qui varie le plus vite du point de vue de l’implantation mémoire.

paramètre formel L’expression d’indexation est transformée par le compilateur en l’expression d’indirection suivante :

tab[i][j]=*(tab + i * taille_ligne + j)

Un paramètre formel tableau à plusieurs dimensions devra avoir le nombre d’éléments de chacune de ses dimensions renseigné, de façon à ce que le compilateur puisse transformer l’expression indicée en indirection.

VIII- Les chaînes de caractères.

Généralités.

Il n’y a pas de type chaîne de caractères en C. Une chaîne est représentée par un tableau de caractères contenant un caractère marqueur de fin de chaîne, ‘\0’. Toute fonction standard manipulant une chaîne devra connaître l’adresse de début de la chaîne, c’est-à-dire l’adresse de son premier caractère, et terminera son travail à la rencontre du caractère de fin ‘\0’.

1- Déclarations et initialisations de chaînes.

a- Tableau de caractères (dimensionné ou non).

char texte1[10]={‘e’,’x’,’e’,’m’,’p’,’l’,’e’,’\0’} ;

On réserve 10 caractères et on initialise comme un tableau, en n’omettant pas le caractère ‘\0’.

  char texte2[10]= "exemple";

Nous reviendrons plus tard sur le travail de la notation "". C alloue de la mémoire pour représenter la chaîne avec son ‘\0’, puis recopie cette zone mémoire dans la zone réservée pour le tableau texte2 . 10 octets ont été réservés, alors que 8 suffisaient.

char texte3[]= "exemple";

Dans ce cas, 8 octets ont été réservés, c’est-à-dire exactement la taille utile.

b- Pointeur de caractères.

char * texte4= "exemple";

Précisons maintenant le travail effectué par la notation "":

allocation de N+1 octets si la chaîne a une taille de N caractères.

Copie des N caractères dans la zone mémoire réservée.

Ajout de ‘\0’ à la fin

L’adresse de la zone mémoire allouée est renvoyée texte4 est un pointeur de caractères pointant vers cette zone mémoire allouée par "".

Attention, il y a une différence avec la déclaration de texte3[], on pourra faire, par la suite, texte4= "salut" mais on ne pourra pas faire texte3= "salut" , car un tableau est analogue à un pointeur constant (la dernière affectation reviendrait à modifier la valeur de l’adresse associée à texte3.

On portera également attention aux différences d’impression dans les exemples suivants :

printf("%c",* texte4) ;/*affiche :  e */

printf("%s", texte4) ;/*affiche :  exemple */

2- Tableau de chaînes de caractères.

On peut déclarer soit un tableau de caractères à 2 dimensions, soit un tableau de pointeurs de caractères à 1 dimension .

 char fruit[3][8]= {"pomme","abricot","orange"};

   char  *fruit[3]= {"pomme","abricot","orange"};

1- Saisie de chaîne.

scanf({"%s",<adresse début de chaine>)

Effectue la saisie d’une chaîne de caractères tapés au clavier, jusqu’à la rencontre du premier espace ou ‘\n’.

Attention

 char * nom ;

 scanf("%s",nom) ;

 ne produira pas d’erreur de compilation, mais les caractères lus vont être installés n’importe où en mémoire, puisqu’aucune place mémoire n’a été réservée.

gets(<adresse début de chaine>)

Effectue la saisie d’une chaîne de caractères tapés au clavier, jusqu’à la rencontre du premier ‘\n’. L’’\0’ est rajouté automatiquement.

gets renvoie l’adresse de début de chaîne ou NULL si on est en fin de fichier.

2- Impression de chaîne.

printf({"%s",<adresse début de chaine>)

puts(<adresse début de chaine>)

3- Fonctions de manipulation de chaîne.

a- Copie de chaînes.

strcpy( <adresse chaine1>, <adresse chaine2>)

recopie le contenu de la mémoire depuis <adresse chaine2> jusqu’à la rencontre d’un ‘\0’, à partir de <adresse chaine1>. Attention, le compilateur n’effectue aucune vérification quant à la réservation d’un espace mémoire suffisant pour stocker chaîne1.

b- Concaténation  de chaînes.

strcat(<adresse chaine1>, <adresse chaine2>)

concatène le contenu de la mémoire depuis <adresse chaine2> jusqu’à la rencontre d’un ‘\0’, au contenu de la mémoire à partir de <adresse chaine1>. Attention, le compilateur n’effectue aucune vérification quant à la réservation d’un espace mémoire suffisant pour stocker le résultat de la concaténation de chaîne1 et chaîne2.

c- Comparaison  de chaînes.

strcmp(<adresse chaine1>, <adresse chaine2>)

compare le contenu de la mémoire depuis <

137