Vous êtes sur la page 1sur 126

Tutoriel de programmation C

C TUTORIEL DE PROGRAMMATION
Apprentissage simple et facile par tutorialspoint.com

tutorialspoint.com

je

COPYRIGHT & DISCLAIMERNOTICE

© Tout le contenu et les graphiques de ce tutoriel sont la propriété de tutorialspoint.com. Tout contenu de
tutorialspoint.com ou ce tutoriel ne peuvent pas être redistribués ou reproduits de quelque manière, forme ou forme que ce soit sans
l'autorisation écrite de tutorialspoint.com. Ne pas le faire est une violation des lois sur les droits d'auteur.

Ce tutoriel peut contenir des inexactitudes ou des erreurs et tutorialspoint ne fournit aucune garantie quant à l'exactitude du site ou de
son contenu, y compris ce tutoriel. Si vous découvrez que le site tutorialspoint.com ou le contenu de ce tutoriel contient des erreurs,
veuillez nous contacter à webmaster@tutorialspoint.com
ii

Table des matières


Présentation du langage C ............................................... ............... 1
Faits sur C ............................................... ................................................ 1
Pourquoi utiliser C? .................................................. ........................................... 2
Programmes C ................................................ .................................................. 2
C Configuration de l'environnement ............................................... ................ 3
Éditeur de texte ................................................ .................................................. . 3
Le compilateur C ............................................... ............................................. 3
Installation sous Unix / Linux ............................................. ................................ 4
Installation sous Mac OS .............................................. .................................... 4
Installation sous Windows ............................................... ................................ 4
C Structure du programme ............................................... ................. 5
C Exemple Hello World .............................................. ................................... 5
Compiler et exécuter le programme C ............................................. .......................... 6
Syntaxe de base C ............................................... .......................... sept
Jetons en C ............................................... .................................................. . sept
Les points-virgules; .................................................. .............................................. sept
Commentaires ................................................. .................................................. 8
Identifiants ................................................. .................................................. . 8
Mots-clés ................................................. .................................................. . 8
Espace blanc en C ............................................... ............................................ 9
C Types de données ............................................... .......................... dix
Types d'entiers ................................................ ............................................. dix
Types à virgule flottante .............................................. ..................................... 11
Le type de vide ............................................... ............................................. 12
Variables C ................................................ ............................ 13
Déclaration de variable en C ................................ Erreur! Signet non défini.
Initialisation de variable en C ............................... Erreur! Signet non défini.
Lvalues et Rvalues en C ............................................. ................................ 15
Constantes C et littéraux .............................................. .......... 17
Entiers littéraux ................................................ ............................................ 17
Virgule flottante littéraux .............................................. .................................... 18
Constantes de caractères ................................................ .................................... 18

iii

Littéraux de chaîne ................................................ ..............................................

Définition des constantes ................................................ .....................................

Le préprocesseur #define .............................................. ........................


L t lé t
Le mot-clé const ............................................... ..................................

C Classes de stockage ............................................... ..................

La classe de stockage automatique .............................................. ..................................

La classe de stockage du registre .............................................. .............................

La classe de stockage statique .............................................. .................................

La classe de stockage externe .............................................. ...............................

C Opérateurs ................................................ ...........................

Opérateurs arithmétiques ................................................ ..................................

Opérateurs relationnels ................................................ ...................................

Opérateurs logiques ................................................ .......................................

Opérateurs au niveau du bit ................................................ .......................................

Opérateurs d'affectation ................................................ ................................

Opérateurs divers ↦ sizeof & ternaire ............................................ ..................

Priorité des opérateurs en C .............................................. ............................

Prise de décision en C .............................................. ................

si déclaration ................................................ ...............................................

Syntaxe ................................................. .................................................. ..

Représentation schématique ................................................ ..........................................

Exemple ................................................. .................................................

if ... else instruction ............................................ ..........................................

Syntaxe ................................................. .................................................. ..

Représentation schématique ................................................ ..........................................

Exemple ................................................. .................................................

Instruction if ... else if ... else ...................................... ...............................

Syntaxe ................................................. .................................................. ..

Exemple ................................................. .................................................

Instructions if imbriquées ............................................... ...................................

Syntaxe ................................................. .................................................. ..

Exemple ................................................. .................................................

instruction switch ................................................ .......................................

Syntaxe ................................................. .................................................. ..

Représentation schématique ................................................ ..........................................

Exemple ................................................. .................................................

Instructions de commutateur imbriquées ............................................... ............................

Syntaxe ................................................. .................................................. ..

Exemple ................................................. .................................................

iii

Le ? : Opérateur ................................................ .........................................

Boucles C ................................................ ..................................

boucle while en C .............................................. .............................................

Syntaxe ................................................. .................................................. ..

Représentation schématique ................................................ ..........................................

Exemple ................................................. .................................................

boucle for en C .............................................. .................................................

Syntaxe ................................................. .................................................. ..

Représentation schématique ................................................ ..........................................

Exemple ................................................. .................................................

faire ... boucle while en C .......................................... ...........................................

Syntaxe ................................................. .................................................. ..


Représentation schématique ................................................ ..........................................
Exemple ................................................. .................................................

boucles imbriquées en C .............................................. ..........................................

Syntaxe ................................................. .................................................. ..

Exemple ................................................. .................................................

instruction break en C .............................................. ....................................

Syntaxe ................................................. .................................................. ..

Représentation schématique ................................................ ..........................................

Exemple ................................................. .................................................

instruction continue en C .............................................. ................................

Syntaxe ................................................. .................................................. ..

Représentation schématique ................................................ ..........................................

Exemple ................................................. .................................................

instruction goto en C .............................................. ......................................

Syntaxe ................................................. .................................................. ..

Représentation schématique ................................................ ..........................................

Exemple ................................................. .................................................

La boucle infinie ............................................... .........................................

Fonctions C ................................................ ............................

Définition d'une fonction ............................................... .....................................

Exemple ................................................. .................................................

Déclarations de fonction ................................................ .................................

Appel d'une fonction ............................................... ........................................

Arguments de fonction ................................................ ...................................

Appel de fonction par valeur .............................................. ...............................

Appel de fonction par référence .............................................. .........................

C Règles de portée ............................................... ........................

iii

Variables locales ................................................ ...........................................


Variables globales ................................................ .........................................
Paramètres formels ................................................ .....................................
Initialisation des variables locales et globales ............................................. ...
Tableaux C ................................................ .................................
Déclaration de tableaux ................................................ ....................................
Initialisation des tableaux ................................................ .................................
Accès aux éléments de la matrice ............................................... ....................
Tableaux multidimensionnels .............................................. .............................
Deux dimensions Tableaux .............................................. ...............................
Initialisation deux dimensions Tableaux ............................................. .............
Accès à deux dimensions éléments Array ............................................ .....
Passer des tableaux en tant qu'arguments de fonction ..................................
Voie-1 ............................................... .................................................. .....
Voie-2 ............................................... .................................................. .....
Voie - 3 ............................................... .................................................. ......
Exemple ................................................. .................................................
Tableau de retour de la fonction .............................................. .........................
Pointeur vers un tableau .............................................. .....................................
C Pointeurs ................................................ ..............................
Que sont les pointeurs? .................................................. ..................................
Comment utiliser les pointeurs? .................................................. .....................
Pointeurs NULL en C .............................................. ........................................
Arithmétique du pointeur ................................................ ..................................
Incrémenter un pointeur ............................................... ................................
Décrémentation d'un pointeur ............................................... ...........................
Comparaisons de pointeurs ................................................ ..............................
Tableau de pointeurs ............................................... .........................................
Pointeur à pointeur ............................................... ........................................
Passer des pointeurs vers des fonctions .............................................. ...........
Pointeur de retour des fonctions .............................................. .......................
Cordes C ................................................ ................................
C Structures ................................................ ...........................
Définition d'une structure ............................................... ...................................
Accès aux membres de la structure ............................................... ..................
Structures comme arguments de fonction .............................................. ........
Pointeurs vers des structures ............................................... ............................
C Syndicats ................................................ ..............................
Définition d'une union ............................................... .......................................

iii

Accès aux membres du syndicat ............................................... .........................

Champs de bits ................................................ ..............................

Déclaration de champ de bits ............................................... ..................................

Typedef ................................................. ...............................

typedef vs #define .............................................. ......................................

Entrée sortie ............................................... .......................

Les fichiers standard ............................................... .....................................

Les fonctions getchar () et putchar () ......................................... ..................

Les fonctions gets () et put () ......................................... ............................

Les fonctions scanf () et printf () ......................................... ......................

E / S de fichier .............................................. ...................................

Ouverture de fichiers ................................................ ...........................................

Fermeture d'un fichier ............................................... .............................................

Ecrire un fichier ............................................... ............................................

Lire un fichier ............................................... ............................................

Fonctions d'E / S binaires ............................................. ....................................

Préprocesseurs ................................................. .....................

Exemples de préprocesseurs ................................................ ............................

Macros prédéfinies ................................................ ...................................

Opérateurs de préprocesseur ................................................ ............................

Suite macro (\) ............................................. .............................

Stringize (#) .............................................. .............................................

Collage de jetons (##) ............................................ ....................................

L'opérateur defined () ............................................. ............................

Macros paramétrées ................................................ ..............................

Fichiers d'en-tête ................................................ .........................

Inclure la syntaxe ................................................ ..........................................

Inclure l'opération ................................................ ....................................

En- têtes uniques .............................................. ....................................

Calculé Comprend ................................................ ...................................


Type Casting ................................................ ........................

Promotion d'entiers ................................................ ....................................

Conversion arithmétique habituelle ............................................... ......................

La gestion des erreurs ................................................ ......................

Les errno, perror () et strerror () ........................................ .......................

Diviser par zéro erreur .............................................. ..................................

État de sortie du programme ............................................... ...................................

Récursivité ................................................. ............................

Factorielle numérique ................................................ .....................................

iii

Série Fibonacci ................................................ ....................................... 130


Arguments de variable ................................................ .............. 131
Gestion de la mémoire ................................................ .......... 133
Allocation dynamique de la mémoire ............................................... .................. 133
Redimensionnement et libération de la mémoire .............................................. ................... 134
Arguments de ligne de commande ............................................... .... 136
iii

1
CHAPITRE

Présentation du langage C
Ce chapitre décrit les détails de base sur le langage de
programmation C, comment il est apparu, quelles sont les forces
de C et pourquoi nous devrions utiliser C.

T langage de programmation C , il est un usage général, de haut niveau de langue qui était

développé à l'origine par Dennis M. Ritchie pour développer le système d'exploitation UNIX chez Bell Labs. C
a été initialement implémenté sur l' ordinateur DEC PDP-11 en 1972.

En 1978, Brian Kernighan et Dennis Ritchie ont produit la première description publique de C, maintenant
connue sous le nom de norme K&R.

Le système d'exploitation UNIX, le compilateur C et pratiquement tous les programmes d'application UNIX
ont été écrits en C. Le C est maintenant devenu un langage professionnel largement utilisé pour diverses
raisons.

∙ Facile à apprendre

∙ Langage structuré

∙ Il produit des programmes efficaces.

∙ Il peut gérer des activités de bas niveau .

∙ Il peut être compilé sur une variété de plates-formes informatiques.

Faits sur C
∙ C a été inventé pour écrire un système d'exploitation appelé UNIX.

∙ C est un successeur du langage B, qui a été introduit vers 1970.

∙ Le langage a été officialisé en 1988 par l'American National Standard Institute. (ANSI).

∙ Le système d'exploitation UNIX a été entièrement écrit en C en 1973.


POINT DE TUTORIEL
Apprentissage simple et simple Page 1

∙ Aujourd'hui, C est le langage de programmation système le plus utilisé et le plus populaire.

∙ La plupart des logiciels de pointe ont été implémentés avec C.

∙ Les systèmes d'exploitation Linux et RBDMS MySQL les plus populaires d'aujourd'hui ont été écrits en
C.

Pourquoi utiliser C?
C a été initialement utilisé pour le travail de développement de système, en particulier les programmes qui
composent le système d'exploitation. C a été adopté comme langage de développement système car il
produit du code qui s'exécute presque aussi vite que le code écrit en langage assembleur. Quelques
exemples d'utilisation de C pourraient être:

∙ Systèmes d'exploitation

∙ Compilateurs de langues

∙ Assembleurs

∙ Éditeurs de texte

∙ Spouleurs d'impression

∙ Pilotes réseau

∙ Programmes modernes

∙ Bases de données

∙ Interprètes linguistiques

∙ Utilitaires

Programmes C
Le programme AC peut varier de 3 lignes à des millions de lignes et il doit être écrit dans un ou plusieurs
fichiers texte avec l'extension ".c"; par exemple, bonjour.c. Vous pouvez utiliser "vi", "vim" ou tout autre
éditeur de texte pour écrire votre programme C dans un fichier.

Ce didacticiel suppose que vous savez comment modifier un fichier texte et comment écrire du code source
à l'aide de n'importe quel langage de programmation.

POINT DE TUTORIEL
Apprentissage simple et simple Page 2
2
CHAPITRE

Configuration de l'environnement
C
Cette section décrit comment configurer votre environnement
système avant de commencer à programmer en utilisant le
langage C.
Avant de commencer à programmer en utilisant le langage de programmation C, vous avez besoin des deux
logiciels suivants disponibles sur votre ordinateur, (a) Text Editor et (b) The C Compiler.

Éditeur de texte
Cela sera utilisé pour taper votre programme. Quelques exemples d'éditeurs incluent le Bloc-notes Windows,
la commande d'édition du système d'exploitation, Brief, Epsilon, EMACS et vim ou vi.

Le nom et la version de l'éditeur de texte peuvent varier selon les systèmes d'exploitation. Par exemple, le
Bloc-notes sera utilisé sous Windows, et vim ou vi peut être utilisé sur Windows ainsi que Linux ou UNIX.

Les fichiers que vous créez avec votre éditeur sont appelés fichiers source et contiennent le code source du
programme. Les fichiers source des programmes C sont généralement nommés avec l'extension «.c».

Avant de commencer votre programmation, assurez-vous d'avoir un éditeur de texte en place et que vous
avez suffisamment d'expérience pour écrire un programme informatique, l'enregistrer dans un fichier, le
compiler et enfin l'exécuter.

Le compilateur C
Le code source écrit dans le fichier source est la source lisible par l'homme pour votre programme. Il doit être
"compilé", pour se transformer en langage machine afin que votre CPU puisse réellement exécuter le
programme selon les instructions données.

Ce compilateur de langage de programmation C sera utilisé pour compiler votre code source en programme
exécutable final. Je suppose que vous avez des connaissances de base sur un compilateur de langage de
programmation.

Le compilateur disponible le plus fréquemment utilisé et le plus gratuit est le compilateur GNU C / C ++, sinon
vous pouvez avoir des compilateurs de HP ou de Solaris si vous avez des systèmes d'exploitation respectifs.

La section suivante vous explique comment installer le compilateur GNU C / C ++ sur différents OS. Je
mentionne ensemble C / C ++ car le compilateur GNU gcc fonctionne pour les langages de programmation C
et C ++.

POINT DE TUTORIEL
Apprentissage simple et simple
Page 3

Installation sous UNIX / Linux


Si vous utilisez Linux ou UNIX, vérifiez si GCC est installé sur votre système en entrant la commande
suivante à partir de la ligne de commande:

$ gcc - v

Si vous avez un compilateur GNU installé sur votre machine, il devrait afficher un message comme suit:

Utilisation intégrée - dans les spécifications .


Cible : i386 - redhat - linux
Configuré avec : ../ configure - prefix = / usr .......
Modèle de fil : posix
gcc version 4.1 . 2 20080704 ( Red Hat 4.1 . 2 - 46 )

Si GCC n'est pas installé, vous devrez l'installer vous-même en utilisant les instructions détaillées
disponibles sur http://gcc.gnu.org/install/

Ce tutoriel a été écrit sur la base de Linux et tous les exemples donnés ont été compilés sur la version Cent
OS du système Linux.

Installation sous Mac OS


Si vous utilisez Mac OS X, le moyen le plus simple d'obtenir GCC est de télécharger l'environnement de
développement Xcode à partir du site Web d'Apple et de suivre les instructions d'installation simples. Une
fois que vous avez configuré Xcode, vous pourrez utiliser le compilateur GNU pour C / C ++.

Xcode est actuellement disponible sur developer.apple.com/technologies/tools/.

Installation sous Windows


Pour installer GCC sous Windows, vous devez installer MinGW. Pour installer MinGW, allez sur la page
d'accueil de MinGW, www.mingw.org, et suivez le lien vers la page de téléchargement de MinGW.
Téléchargez la dernière version du programme d'installation MinGW, qui doit être nommée MinGW-
<version> .exe.

Lors de l'installation de MinWG, au minimum, vous devez installer gcc-core, gcc-g ++, binutils et le runtime
MinGW, mais vous souhaiterez peut-être en installer d'autres.

Ajoutez le sous-répertoire bin de votre installation MinGW à votre variable d'environnement PATH, afin de
pouvoir spécifier ces outils sur la ligne de commande par leurs noms simples.

Une fois l'installation terminée, vous pourrez exécuter gcc, g ++, ar, ranlib, dlltool et plusieurs autres outils
GNU à partir de la ligne de commande Windows.

POINT DE TUTORIEL
Apprentissage simple et simple Page 4
3
CHAPITRE

Structure du programme C
Examinons l'exemple de Hello World en utilisant le langage de
programmation C.

B vant nous étudions les blocs de construction de base de la langue de programmation C, examinons une

structure de programme C strict minimum afin que nous puissions la prendre comme référence dans les
prochains chapitres.

Exemple C Hello World


Le programme AC se compose essentiellement des parties suivantes:

∙ Commandes du préprocesseur

∙ Fonctions

∙ Variables

∙ Déclarations et expressions

∙ Commentaires

Regardons un code simple qui afficherait les mots " Hello World ":

#include <stdio.h>
int main ()
{
/ * mon premier programme
en C * / printf ( "Hello,
World! \ n" );
return 0 ;
}

Regardons différentes parties du programme ci-dessus:

POINT DE TUTORIEL
Apprentissage simple et simple Page 5
1. La première ligne du programme #include <stdio.h> est une commande de
préprocesseur, qui indique à un compilateur C d'inclure le fichier stdio.h avant de passer
à la compilation proprement dite.

2. La ligne suivante int main () est la fonction principale où commence l'exécution du programme.

3. La ligne suivante /*...*/ sera ignorée par le compilateur et elle a été placée pour ajouter
des commentaires supplémentaires dans le programme. Donc, ces lignes sont appelées
commentaires dans le programme.

4. La ligne suivante printf (...) est une autre fonction disponible en C qui provoque le
message "Hello, World!" à afficher à l'écran.

5. La ligne suivante renvoie 0; termine la fonction main () et renvoie la valeur 0.

Compiler et exécuter le programme C


Voyons comment enregistrer le code source dans un fichier, et comment le compiler et l'exécuter. Voici les
étapes simples:

1. Ouvrez un éditeur de texte et ajoutez le code mentionné ci-dessus .

2. Enregistrez le fichier sous hello.c

3. Ouvrez une invite de commande et accédez au répertoire dans lequel vous avez enregistré le fichier.

4. Tapez gcc hello.c et appuyez sur Entrée pour compiler votre code.

5. S'il n'y a aucune erreur dans votre code, l'invite de commande vous amène à la ligne
suivante et générerait a.out fichier exécutable.

6. Maintenant, tapez a.out pour exécuter votre programme.

7. Vous pourrez voir "Hello World" imprimé à l'écran

$ gcc bonjour.c
$ ./a.out
Bonjour le monde!

Assurez-vous que le compilateur gcc est dans votre chemin et que vous l'exécutez dans le répertoire
contenant le fichier source hello.c.

POINT DE TUTORIEL
Apprentissage simple et simple Page 6
4
CHAPITRE

Syntaxe de base C
Ce chapitre donnera des détails sur toute la syntaxe de base du
langage de programmation C, y compris les jetons, les mots-clés,
les identifiants, etc.

Vous
autres
avez vu une structure de base du programme C, il sera donc facile de comprendre les

blocs de construction de base du langage de programmation C.

Jetons en C
Le programme AC se compose de divers jetons et un jeton est soit un mot-clé, un identificateur, une
constante, une chaîne littérale ou un symbole. Par exemple, l'instruction C suivante se compose de cinq
jetons:

printf ( "Bonjour le monde! \ n" );

Les jetons individuels sont:

printf
(
"Bonjour le monde! \ N"
)
;

Les points-virgules;
Dans le programme C, le point-virgule est un terminateur d'instruction. Autrement dit, chaque instruction
individuelle doit se terminer par un point-virgule. Il indique la fin d'une entité logique.

Par exemple, voici deux déclarations différentes:

printf ( "Bonjour le
monde! \ n" ); return 0 ;

POINT DE TUTORIEL
Apprentissage simple et simple Page 7
commentaires
Les commentaires sont comme du texte d'aide dans votre programme C et ils sont ignorés par le
compilateur. Ils commencent par / * et se terminent par les caractères * / comme indiqué ci-dessous:

/ * mon premier programme en C * /

Vous ne pouvez pas avoir de commentaires dans les commentaires et ils n'apparaissent pas dans une
chaîne ou des caractères littéraux.

Identifiants
L'identifiant AC est un nom utilisé pour identifier une variable, une fonction ou tout autre élément défini par l'
utilisateur . Un identificateur commence par une lettre A à Z ou a à z ou un trait de soulignement _ suivi de
zéro ou plusieurs lettres, traits de soulignement et chiffres (0 à 9).

C n'autorise pas les caractères de ponctuation tels que @, $ et% dans les identificateurs. C est un langage
de programmation sensible à la casse. Ainsi, Manpower et manpower sont deux identifiants différents en C.
Voici quelques exemples d'identifiants acceptables:

mohd zara abc nom_move a_123


myname50 _temp j a23b9 retVal
         

Mots clés
La liste suivante montre les mots réservés en C. Ces mots réservés ne peuvent pas être utilisés comme
constante ou variable ou tout autre nom d'identifiant.

                   
auto autre Longue commutateur
                               
               
Pause énumération S'inscrire typedef
                               
                   
  Cas     externe     revenir     syndicat  
                   
               
  carboniser     flotte     court     non signé  
                   
                   
const
            
pour        
signé        
néant   
                   
continuer
            
aller à        
taille de        
volatil   
               

 
défaut     
si     
statique     
tandis que   
           
                       
  faire     int     struct     _emballé  
                   
                                
  double                 
                   

POINT DE TUTORIEL
Apprentissage simple et simple Page 8

Espace blanc en C
Une ligne ne contenant que des espaces, éventuellement avec un commentaire, est appelée ligne vide, et un
compilateur C l'ignore totalement.

L'espace blanc est le terme utilisé en C pour décrire les espaces, les tabulations, les caractères de nouvelle
ligne et les commentaires. L'espace blanc sépare une partie d'une instruction d'une autre et permet au
compilateur d'identifier où un élément dans une instruction, comme int, se termine et où commence
l'élément suivant. Par conséquent, dans la déclaration suivante:
âge int ;

Il doit y avoir au moins un caractère espace (généralement un espace) entre int et age pour que le
compilateur puisse les distinguer. D'autre part, dans la déclaration suivante:

fruit = pommes + oranges ; // obtenir le fruit total


   

Aucun espace blanc n'est nécessaire entre les fruits et =, ou entre = et les pommes, bien que vous soyez
libre d'en inclure si vous le souhaitez à des fins de lisibilité.

POINT DE TUTORIEL
Apprentissage simple et simple Page 9

5
CHAPITRE

Types de données C
Dans
étendu utilisé pour
le langage de programmation C, les types de données font référence à un système

déclarer des variables ou des fonctions de types différents. Le type d'une variable détermine l'espace qu'elle
occupe dans le stockage et la manière dont le modèle de bits stocké est interprété.

Les types en C peuvent être classés comme suit:

    
 SN    Types et description
       
     
      Types de base:
1 Ce sont des types arithmétiques et se composent des deux types: (a) types entiers et (b) flottants-
    
      types de points.
       
     
      Types énumérés:
 2    Ce sont encore des types arithmétiques et ils sont utilisés pour définir des variables qui ne peuvent être
      attribué certaines valeurs entières discrètes dans tout le programme.
       
       
     Le type void:
 3   
      Le spécificateur de type void indique qu'aucune valeur n'est disponible.
       
     
      Types dérivés:
 4    Ils comprennent (a) les types de pointeurs, (b) les types de tableaux, (c) les types de structure, (d) les types d
      (e) Types de fonction.
       

Les types de tableau et les types de structure sont appelés collectivement les types d'agrégat. Le type d'une
fonction spécifie le type de la valeur de retour de la fonction. Nous verrons les types de base dans la section
suivante, tandis que d'autres types seront traités dans les prochains chapitres.

Types entiers
Le tableau suivant vous donne des détails sur les types d'entiers standard avec ses tailles de stockage et
ses plages de valeurs:

                 
  Type     Taille de stockage     Plage de valeurs  
              
                 
  Carboniser     1 octet     -128 à 127 ou 0 à 255  
            
                
  caractère non signé     1 octet     0 à 255  
              

POINT DE TUTORIEL
Apprentissage simple et simple Page 10

              
char signé
       
1 octet
            
-128 à 127   
                       
  Int    2 ou 4 octets     -32768 à 32767 ou -2147483648 à 2147483647  
            
                       
  entier non signé    2 ou 4 octets     0 à 65535 ou 0 à 4 294 967 295  
            
                       
  Court    2 octets     -32 768 à 32 767  
            
                       
  court non signé    2 octets     0 à 65 535  
            
                       
  Longue    4 octets     -2 147 483 648 à 2 147 483 647  
            
                       
  non signé longtemps   4 octets     0 à 4 294 967 295  
              

Pour obtenir la taille exacte d'un type ou d'une variable sur une plate-forme particulière, vous pouvez utiliser
l' opérateur sizeof . L'expression sizeof (type) donne la taille de stockage de l'objet ou du type en octets.
Voici un exemple pour obtenir la taille du type int sur n'importe quelle machine:

#include <stdio.h>
#include
<limits.h>
int main ()
{
printf ( "Taille de stockage pour int:% d \ n" , sizeof ( int ));

return 0 ;
}

Lorsque vous compilez et exécutez le programme ci-dessus, il produit le résultat suivant sous Linux:

Taille de stockage pour int: 4

Types à virgule flottante


Le tableau suivant vous donne des détails sur les types à virgule flottante standard avec les tailles de
stockage et les plages de valeurs et leur précision:

                   
Type Taille de stockage Plage de valeurs Précision
                               
                   

 
flotte 4 octets 1,2E-38 à 3,4E + 38 6 décimales
         
        
        
    
                   

 
double 8 octets 2,3E-308 à 1,7E + 308 15 décimales
       
       
       
    
               
  long double     10 octets     3.4E-4932 à 1.1E + 4932     19 décimales  
                   

Le fichier d'en-tête float.h définit des macros qui vous permettent d'utiliser ces valeurs et d'autres détails
sur la représentation binaire des nombres réels dans vos programmes. L'exemple suivant affichera l'espace
de stockage occupé par un type float et ses valeurs de plage:

#include
<stdio.h>
#include
<float.h>

int main ()

POINT DE TUTORIEL
Apprentissage simple et simple Page 11

{
printf ( "Taille de stockage pour float:% d \ n" , sizeof ( float ));
printf ( "Valeur positive minimale du flottant:% E \ n" , FLT_MIN );
printf ( "Valeur positive maximale du flottant:% E \ n" , FLT_MAX );
printf ( "Valeur de précision:% d \ n" , FLT_DIG );

return 0 ;
}

Lorsque vous compilez et exécutez le programme ci-dessus, il produit le résultat suivant sous Linux:

Taille de stockage pour flotteur: 4


Valeur positive minimale du flotteur: 1.175494E-38
Valeur positive maximale du flotteur: 3.402823E + 38
Valeur de précision: 6

Le type de vide
Le type void spécifie qu'aucune valeur n'est disponible. Il est utilisé dans trois types de situations:

SNTypes et description

La fonction revient comme nulle


 
Il existe différentes fonctions dans C qui ne retournent pas de valeur ou vous pouvez dire qu'elles retournent void.
1
   Une fonction sans valeur de retour a le type de retour comme void. Par exemple, void exit (int
statut);
   
  Arguments de fonction comme void
2 Il existe différentes fonctions en C qui n'acceptent aucun paramètre. Une fonction sans
paramètre peut accepter comme un vide. Par exemple, int rand (void);
    
   
Pointeurs pour annuler
Un pointeur de type void * représente l'adresse d'un objet, mais pas son type. Par exemple,
3 une fonction d'allocation de mémoire void * malloc (size_t size); renvoie un pointeur
vers void qui peut être converti en n'importe quel type de données.

Le type vide peut ne pas vous être compris à ce stade, alors allons-y et nous couvrirons ces concepts dans
les chapitres à venir.

POINT DE TUTORIEL
Apprentissage simple et simple Page 12

6
CHAPITRE

Variables C

Une
peuvent
variable n'est rien d'autre qu'un nom donné à une zone de stockage que nos programmes

manipuler. Chaque variable en C a un type spécifique, qui détermine la taille et la disposition de la mémoire
de la variable; la plage de valeurs pouvant être stockées dans cette mémoire; et l'ensemble des opérations
qui peuvent être appliquées à la variable.

Le nom d'une variable peut être composé de lettres, de chiffres et du caractère de soulignement. Il doit
commencer par une lettre ou un trait de soulignement. Les lettres majuscules et minuscules sont distinctes
car C est sensible à la casse. Sur la base des types de base expliqués dans le chapitre précédent, il y aura
les types de variables de base suivants:

           
  Type     La description  
         
           
  Carboniser     Généralement un seul octet (un octet). Il s'agit d'un type entier.  
         
               
  Int     La taille entière la plus naturelle de la machine.  
         
           
  Flotte     Une valeur à virgule flottante simple précision .  
         
               
  Double     Une valeur à virgule flottante double précision .  
         
               
  Néant     Représente l'absence de type.  
         

Le langage de programmation C permet également de définir divers autres types de variables, que nous
aborderons dans les chapitres suivants comme Enumeration, Pointer, Array, Structure, Union, etc. Pour ce
chapitre, étudions uniquement les types de variables de base.

Définition de variable en C:
Une définition de variable signifie indiquer au compilateur où et combien créer le stockage pour la
variable. Une définition de variable spécifie un type de données et contient une liste d'une ou
plusieurs variables de ce type comme suit:

type liste_variable ;

Ici, type doit être un type de données C valide comprenant char, w_char, int, float, double, bool ou
tout autre objet défini par l'utilisateur, etc., et variable_list peut se composer d'un ou plusieurs
noms d'identificateurs séparés par des virgules. Certaines déclarations valides sont présentées
ici:

POINT DE TUTORIEL
Apprentissage simple et simple Page 13

int i , j , k ;
carboniserc ,ch ;
flotte f ,salaire ;
double d ;

La ligne int i, j, k; à la fois déclare et définit les variables i, j et k; qui demande au compilateur de
créer des variables nommées i, j et k de type int.

Les variables peuvent être initialisées (affectées d'une valeur initiale) dans leur déclaration.
L'initialiseur se compose d'un signe égal suivi d'une expression constante comme suit:

type nom_variable = valeur ;

Certains exemples sont:

externe int d = 3 , f = 5 ; // déclaration de d et f.


int d = 3 , f = 5 ; // définition et initialisation de d et f.
octet z = 22 ;   // définition et initialise z.
carboniserX = «x» ;   // la variable x a la valeur «x».
               

Pour une définition sans initialiseur: les variables avec une durée de stockage statique sont
implicitement initialisées avec NULL (tous les octets ont la valeur 0); la valeur initiale de toutes les
autres variables n'est pas définie.

Déclaration de variable en C:
Une déclaration de variable fournit l'assurance au compilateur qu'il existe une variable avec le type
et le nom donnés afin que le compilateur procède à une compilation ultérieure sans avoir besoin
de détails complets sur la variable. Une déclaration de variable a sa signification au moment de la
compilation uniquement, le compilateur a besoin d'une déclaration de variable réelle au moment
de la liaison du programme.

Une déclaration de variable est utile lorsque vous utilisez plusieurs fichiers et que vous définissez
votre variable dans l'un des fichiers, qui sera disponible au moment de la liaison du programme.
Vous serez
utilisez le mot-clé extern pour déclarer une variable à n'importe quel endroit. Bien que vous puissiez déclarer
une variable plusieurs fois dans votre programme C, elle ne peut être définie qu'une seule fois dans un
fichier, une fonction ou un bloc de code.

Exemple
Essayez l'exemple suivant, où les variables ont été déclarées en haut, mais elles ont été définies
et initialisées dans la fonction principale:

#include <stdio.h>
// Définition de
variable: extern int a
, b ; extern int c ;
float externe f ;

int main ()
{
// Définition de
variable: int a , b ;
int c ;
float f
;

// initialisation
réelle a = 10 ;

POINT DE TUTORIEL
Apprentissage simple et simple Page 14

b = 20 ;
c = a + b ;

printf ( "valeur de c:% d \ n" , c );

f = 70,0 / 3,0 ;
printf ( "valeur de f:% f \ n" , f );

return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

valeur de c: 30

valeur de f: 23,333334

Le même concept s'applique à la déclaration de fonction où vous fournissez un nom de fonction


au moment de sa déclaration et sa définition réelle peut être donnée n'importe où ailleurs. Par
exemple:

// déclaration de
fonction int func ();
int main ()
{
// appel de
fonction int i
= func ();
}
// définition de la
fonction int func ()
{
return 0 ;
}

Lvalues et Rvalues en C
Il existe deux types d'expressions en C:

1. lvalue: une expression qui est une lvalue peut apparaître comme le côté gauche ou droit
d'une affectation.

2. rvalue: une expression qui est une rvalue peut apparaître à droite mais pas à gauche
d'une affectation.

Les variables sont des valeurs l et peuvent donc apparaître sur le côté gauche d'une affectation. Les
littéraux numériques sont des valeurs r et ne peuvent donc pas être affectés et ne peuvent pas apparaître
sur le côté gauche. Voici une déclaration valide:

int g = 20 ;

Mais ce qui suit n'est pas une instruction valide et générerait une erreur de compilation :

POINT DE TUTORIEL  
Apprentissage simple et simple Page 15

10 = 20 ;
POINT DE TUTORIEL
Apprentissage simple et simple Page 16

7
CHAPITRE

Constantes C et littéraux

Les constantes se réfèrent à des valeurs fixes que le programme ne peut pas modifier pendant sa

exécution. Ces valeurs fixes sont également appelées littérales .

Les constantes peuvent être de l'un des types de données de base comme une constante entière , une
constante flottante, une constante de caractère ou une chaîne littérale. Il existe également des constantes
d'énumération.

Les constantes sont traitées comme des variables régulières sauf que leurs valeurs ne peuvent pas être
modifiées après leur définition.

Entiers littéraux
Un littéral entier peut être une constante décimale, octale ou hexadécimale. Un préfixe spécifie la base ou la
base: 0x ou 0X pour hexadécimal, 0 pour octal et rien pour décimal.

Un littéral entier peut également avoir un suffixe qui est une combinaison de U et L, pour unsigned et long,
respectivement. Le suffixe peut être en majuscules ou en minuscules et peut être dans n'importe quel ordre.

Voici quelques exemples de littéraux entiers:

212 /* Légal */
 
215u /* Légal * /
 
0xFeeL /* Légal * /  
078 / * Illégal: 8 n'est pas un chiffre octal * /
032UU / * Illégal: impossible de répéter un suffixe * /
         

Voici d'autres exemples de différents types de littéraux entiers:

85 / * décimal * /
0213 / * octal * /
0x4b / * hexadécimal * /
30 / * entier * /
30u / * int non signé * /
30l / * long * /
30ul / * non signé long * /
POINT DE TUTORIEL
Apprentissage simple et simple Page 17

Virgule flottante littéraux


Un littéral à virgule flottante a une partie entière, une virgule décimale, une partie fractionnaire et une partie
exposant. Vous pouvez représenter des littéraux à virgule flottante sous forme décimale ou exponentielle.

Lors de la représentation sous forme décimale, vous devez inclure la virgule décimale, l'exposant ou les
deux et, lors de la représentation sous forme exponentielle, vous devez inclure la partie entière, la partie
fractionnaire ou les deux. L'exposant signé est introduit par e ou E.

Voici quelques exemples de littéraux à virgule flottante :

3,14159 /* Légal */
   
314159E-5L /* Légal */
510E / * Illégal: exposant incomplet * /
210f / * Illégal: pas de décimal ni d'exposant * /
. e55 / * Illégal: entier ou fraction manquant * /
     

Constantes de caractère
Les caractères littéraux sont placés entre guillemets simples, par exemple «x» et peuvent être stockés dans
une simple variable de type char .

Un littéral de caractère peut être un caractère simple (par exemple, «x»), une séquence d'échappement (par
exemple, «\ t») ou un caractère universel (par exemple, «\ u02C0»).

Il y a certains caractères en C quand ils sont précédés d'une barre oblique inverse, ils auront une
signification spéciale et ils sont utilisés pour représenter comme nouvelle ligne (\ n) ou tabulation (\ t). Ici,
vous avez une liste de certains de ces codes de séquence d'échappement:

         
  Échapper      
      Sens  
  séquence       
         
           
  \\     \ personnage  
      
           
 \ '     ' personnage  
      
           
 \ "     " personnage  
      
           
  \?     ? personnage  
       
           
  \une     Alerte ou cloche  
       
               
 \ b     Retour arrière  
       
           
  \F     Saut de formulaire  
       
           
 \ n     Nouvelle ligne  
       
           
 \ r     Retour chariot  
       
           
 \ t     Onglet horizontal  
       
           
 \ v     Onglet vertical  
       
           
  \ ooo     Numéro octal de un à trois chiffres  
         

POINT DE TUTORIEL
Apprentissage simple et simple Page 18

   
\ xhh. . . Nombre hexadécimal d'un ou plusieurs chiffres
   

Voici l'exemple pour afficher quelques caractères de séquence d'échappement:

#include <stdio.h>

int main ()
{
printf ( "Bonjour \ tMonde \ n \ n" );

return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Bonjour le monde

Littéraux de chaîne
Les chaînes littérales ou les constantes sont placées entre guillemets doubles "". Une chaîne contient des
caractères similaires aux littéraux de caractères: caractères simples, séquences d'échappement et
caractères universels.

Vous pouvez diviser une longue ligne en plusieurs lignes en utilisant des chaînes littérales et en les séparant
à l'aide d'espaces blancs.

Voici quelques exemples de littéraux de chaîne. Les trois formes sont des chaînes identiques.

"Bonjour mon cher"

"salut, \

cher"

"Bonjour mon cher"

Définition des constantes


Il existe deux façons simples en C de définir des constantes:

1. Utilisation du préprocesseur #define .


2. Utilisation du mot-clé const .

Le préprocesseur #define
Voici le formulaire pour utiliser le préprocesseur #define pour définir une constante:

POINT DE TUTORIEL
Apprentissage simple et simple Page 19

#define la valeur de l'identifiant

L'exemple suivant l'explique en détail:

#include <stdio.h>

#define LENGTH 10
#define WIDTH 5
#define NEWLINE '\
n'

int main ()
{

zone int ;

aire = LONGUEUR * LARGEUR ;


printf ( "valeur de la zone:% d" ,
zone ); printf ( "% c" , NEWLINE
);

return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

valeur de la surface: 50

Le mot-clé const
Vous pouvez utiliser le préfixe const pour déclarer des constantes avec un type spécifique comme suit:

variable de type const = valeur ;

L'exemple suivant l'explique en détail:

#include <stdio.h>

int main ()
{
const int LENGTH = 10 ;
const int WIDTH = 5 ;
const char NEWLINE = '\
n' ;
zone int ;

aire = LONGUEUR * LARGEUR ;


printf ( "valeur de la zone:% d" ,
zone ); printf ( "% c" , NEWLINE
);

return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

POINT DE TUTORIEL
Apprentissage simple et simple Page 20

valeur de la surface: 50

Notez que c'est une bonne pratique de programmation de définir des constantes dans CAPITALS.
POINT DE TUTORIEL
Apprentissage simple et simple Page 21

8
CHAPITRE

Classes de stockage C

Une
des fonctions
classe de stockage définit la portée (visibilité) et la durée de vie des variables et / ou

dans un programme C. Ces spécificateurs précèdent le type qu'ils modifient. Il existe les classes
de stockage suivantes, qui peuvent être utilisées dans un programme C

∙ auto

∙ s'inscrire

∙ statique

∙ externe

La classe de stockage automatique


La classe de stockage automatique est la classe de stockage par défaut pour toutes les variables locales.

{
int mount ;
mois int
automatique ;
}

L'exemple ci-dessus définit deux variables avec la même classe de stockage, auto ne peut être utilisé que
dans des fonctions, c'est-à-dire des variables locales.

La classe de stockage de registre


La classe de stockage de registre est utilisée pour définir des variables locales qui doivent être stockées
dans un registre au lieu de la RAM. Cela signifie que la variable a une taille maximale égale à la taille du
registre (généralement un mot) et ne peut pas avoir l'opérateur unaire '&' appliqué (car elle n'a pas
d'emplacement mémoire).

{
enregistrer des miles int ;
}
POINT DE TUTORIEL
Apprentissage simple et simple Page 22

Le registre ne doit être utilisé que pour les variables qui nécessitent un accès rapide comme les compteurs.
Il convient également de noter que la définition de «registre» ne signifie pas que la variable sera stockée
dans un registre. Cela signifie qu'il PEUT être stocké dans un registre en fonction des restrictions
matérielles et d'implémentation.

La classe de stockage statique


La classe de stockage statique indique au compilateur de conserver une variable locale pendant la
durée de vie du programme au lieu de la créer et de la détruire chaque fois qu'elle entre et sort de la portée.
Par conséquent, rendre les variables locales statiques leur permet de conserver leurs valeurs entre les
appels de fonction.

Le modificateur statique peut également être appliqué aux variables globales. Lorsque cela est fait, la
portée de cette variable est restreinte au fichier dans lequel elle est déclarée.

En programmation C, lorsque statique est utilisé sur un membre de données de classe, une seule copie de
ce membre est partagée par tous les objets de sa classe.

#include <stdio.h>

/ * déclaration de
fonction * / void func (
void );

nombre int statique = 5 ; / * variable globale * /

principal ()
{
tandis que ( compter -)
{
func ();
}
return 0 ;
}
/ * définition de
fonction * / void func (
void )
{
statique int i = 5 ; / * variable statique
locale * / i ++;
printf ( "i est% d et compte est% d \ n" , i , compte );
}

Vous ne comprenez peut-être pas cet exemple pour le moment car j'ai utilisé des variables de fonction et
globales, ce que je n'ai pas expliqué jusqu'à présent. Alors pour l'instant, procédons même si vous ne le
comprenez pas complètement. Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat
suivant:

i est 6 et compte est


4 i est 7 et compte
est 3 i est 8 et
compte est 2 i est 9
et compte est 1 i est
10 et compte est 0

POINT DE TUTORIEL
Apprentissage simple et simple Page 23
La classe de stockage externe
La classe de stockage externe est utilisée pour donner une référence à une variable globale visible par
TOUS les fichiers programme. Lorsque vous utilisez «extern», la variable ne peut pas être initialisée car elle
ne fait que pointer le nom de la variable vers un emplacement de stockage précédemment défini.

Lorsque vous avez plusieurs fichiers et que vous définissez une variable globale ou une fonction, qui sera
également utilisée dans d'autres fichiers, alors extern sera utilisé dans un autre fichier pour donner la
référence à la variable ou à la fonction définie. Juste pour comprendre, extern est utilisé pour déclarer une
variable globale ou une fonction dans un autre fichier.

Le modificateur extern est le plus couramment utilisé lorsqu'il y a deux fichiers ou plus partageant les
mêmes variables globales ou fonctions comme expliqué ci-dessous.

Premier fichier: main.c


#include <stdio.h>
nombre int ;
extern void write_extern ();

principal ()
{
write_extern ();
}

Deuxième fichier: write.c


#include <stdio.h>

compte int externe ;

void write_extern ( void )


{
compte = 5 ;
printf ( "compte est% d \ n" , compte );
}

Ici, le mot-clé extern est utilisé pour déclarer count dans le deuxième fichier alors qu'il a sa définition dans le
premier fichier, main.c. Maintenant, compilez ces deux fichiers comme suit:

$ gcc main . c écrire . c

Cela produira a.out programme exécutable, lorsque ce programme est exécuté, il produit le résultat suivant:

POINT DE TUTORIEL
Apprentissage simple et simple Page 24

9
CHAPITRE
Opérateurs C

Un opérateur n est un symbole qui indique au compilateur d'effectuer des opérations

mathématiques ou logiques spécifiques


manipulations. Le langage C est riche en opérateurs intégrés et fournit les types d'opérateurs
suivants:

∙ Opérateurs arithmétiques

∙ Opérateurs relationnels

∙ Opérateurs logiques

∙ Opérateurs au niveau du bit

∙ Opérateurs d'affectation

∙ Opérateurs divers

Ce tutoriel expliquera les opérateurs arithmétique, relationnel, logique, bit à bit, d'affectation et autres un par
un.

Opérateurs arithmétiques
Le tableau suivant montre tous les opérateurs arithmétiques pris en charge par le langage C. Supposons
que la variable A vaut 10 et la variable B 20, alors:

                 
  Opérateur    La description     Exemple  
             
                 
 +     Ajoute deux opérandes     A + B donnera 30  
              
                 
 -     Soustrait le deuxième opérande du premier     A - B donnera -10  
              
                 
 *     Multiplie les deux opérandes     A * B donnera 200  
              
                 
 /     Divise le numérateur par le dénumérateur     B / A donnera 2  
              
                 
 %     Opérateur de module et reste après une division entière     B% A donnera 0  
              

POINT DE TUTORIEL
Apprentissage simple et simple Page 25

              
 
++     
 
L'opérateur Increments augmente la valeur entière de un     
 
A ++ donnera 11  
        
 
   
     
     
 
 -    Décrémente l'opérateur diminue la valeur entière de un    A-- donnera 9  
              

Essayez l'exemple suivant pour comprendre tous les opérateurs arithmétiques disponibles dans le langage
de programmation C:

#include <stdio.h>

principal ()
{
int a = 21
; int b =
10 ; int c
;
c = a + b ;
printf ( "Ligne 1 - La valeur de c est% d
\ n" , c ); c = a - b ;
printf ( "Ligne 2 - La valeur de c est% d
\ n" , c ); c = a * b ;
printf ( "Ligne 3 - La valeur de c est% d
\ n" , c ); c = a / b ;
printf ( "Ligne 4 - La valeur de c est% d
\ n" , c ); c = a % b ;
printf ( "Ligne 5 - La valeur de c est% d
\ n" , c ); c = a ++;
printf ( "Ligne 6 - La valeur de c est% d \ n" , c );
c = un -;
printf ( "Ligne 7 - La valeur de c est% d \ n" , c );

Lorsque vous compilez et exécutez le programme ci-dessus, il produit le résultat suivant:

Ligne 1 - La valeur de c est 31


Ligne 2 - La valeur de c est 11
Ligne 3 - La valeur de c est 210
Ligne 4 - La valeur de c est 2
Ligne 5 - La valeur de c est 1
Ligne 6 - La valeur de c est 21
Ligne 7 - La valeur de c est 22

Opérateurs relationnels
Le tableau suivant montre tous les opérateurs relationnels pris en charge par le langage C. Supposons que
la variable A vaut 10 et la variable B 20, alors:

 
    
      
     
 
 Opérateur   La description    Exemple  
              

POINT DE TUTORIEL
Apprentissage simple et simple Piste 26

             
         
    Vérifie si les valeurs de deux opérandes sont égales ou non, si     
  ==        (A == B) n'est pas vrai.  
       oui alors la condition devient vraie.       
             
             
         
      Vérifie si les valeurs de deux opérandes sont égales ou non, si     
 ! =        (A! = B) est vrai.  
       les valeurs ne sont pas égales alors la condition devient vraie.       
             
             
       Vérifie si la valeur de l'opérande gauche est supérieure à       
 >     valeur de l'opérande droit, si oui alors la condition devient     (A> B) n'est pas vrai.  
       vrai.       
             
         
      Vérifie si la valeur de l'opérande gauche est inférieure à la valeur     
         
 <        (A <B) est vrai.  
       de l'opérande droit, si oui, la condition devient vraie.       
             
             
       Vérifie si la valeur de l'opérande gauche est supérieure ou       
 > =     égal à la valeur de l'opérande droit, si oui alors condition     (A> = B) n'est pas vrai.  
       devient vrai.       
             
            
       Vérifie si la valeurde l'opérande gauche est inférieure ou égale        
 <=   à la valeur de l'opérande droit, si oui alors condition     (A <= B) est vrai.  
       devient vrai.       
             

Essayez l'exemple suivant pour comprendre tous les opérateurs relationnels disponibles dans le langage de
programmation C:

#include <stdio.h>
principal ()
{
int a = 21
; int b =
10 ; int c
;

si ( a == b )
{
printf ( "Ligne 1 - a est égal à b \ n" );
}
autre
{
printf ( "Ligne 1 - a n'est pas égal à b \ n" );
}
si ( a < b )
{
printf ( "Ligne 2 - a est inférieur à b \ n" );
}
autre
{
printf ( "Ligne 2 - a n'est pas inférieur à b \ n" );
}
si ( a > b )
{
printf ( "Ligne 3 - a est supérieur à b \ n" );
}
autre
{
printf ( "Ligne 3 - a n'est pas supérieur à b \ n" );
}
/ * Permet de changer la valeur
de a et b * / a = 5 ;
b = 20 ;
si ( a <= b )

POINT DE TUTORIEL
Apprentissage simple et simple Page 27

{
printf ( "Ligne 4 - a est soit inférieur soit égal à b \ n" );
}
si ( b > = a )
{
printf ( "La ligne 5 - b est supérieure ou égale à b \ n" );
}
}

Lorsque vous compilez et exécutez le programme ci-dessus, il produit le résultat suivant:

Ligne 1 - a n'est pas égal à b  

Ligne 2 - a n'est pas inférieur à b  


     
Ligne 3 - a est supérieur à b  

Ligne 4 - a est soit inférieur ou égal à b


Ligne 5 - b est soit Meilleur que ou égal à b
           

Opérateurs logiques
Le tableau suivant montre tous les opérateurs logiques pris en charge par le langage C. Supposons que la
variable A vaut 1 et la variable B vaut 0, alors:

 
   
     
     
 
 Opérateur   La description    Exemple  
              
         
         
   Opérateur logique ET appelé. Si les deux opérandes sont différents de zéro,
         
  &&    (A && B) est faux.
      
    
      alors la condition devient vraie.       
              
              
         
     Opérateur OU logique appelé. Si l'un des deux opérandes n'est pas     
 ||       (A || B) est vrai.  
            
zéro, alors la condition devient vraie.
              
              
      Opérateur PAS logique appelé. Utilisez pour inverser l'état logique       
 !    de son opérande. Si une condition est vraie, alors l'opérateur logique NOT   ! (A && B) est vrai.  
      rendra faux.       
              

Essayez l'exemple suivant pour comprendre tous les opérateurs logiques disponibles dans le langage de
programmation C:

#include <stdio.h>

principal ()
{
int a = 5
; int b =
20 ; int c
;

si ( a && b )
{
printf ( "Ligne 1 - La condition est vraie \ n" );
}
si ( a || b )
{

POINT DE TUTORIEL
Apprentissage simple et simple Page 28

printf ( "Ligne 2 - La condition est vraie \ n" );


}
/ * permet de changer la valeur de a
et b * / a = 0 ;
b = 10 ;
si ( a && b )
{
printf ( "Ligne 3 - La condition est vraie \ n" );
}
autre
{
printf ( "Ligne 3 - La condition n'est pas vraie \ n" );
}
si (! ( a && b ))
{
printf ( "Ligne 4 - La condition est vraie \ n" );
}
}

Lorsque vous compilez et exécutez le programme ci-dessus, il produit le résultat suivant:

Ligne 1 - La condition est vraie


Ligne 2 - La condition est vraie
Ligne 3 - La condition n'est pas vraie
Ligne 4 - La condition est vraie

Opérateurs au niveau du bit


L'opérateur au niveau du bit fonctionne sur les bits et effectue des opérations bit par bit . Les tables de vérité
pour &, | et ^ sont les suivantes:

 
    
      
      
      
     
 
 P    q    p &q    p |q    p ^q  
                     
 
    
      
      
      
     
 
 0    0    0    0    0  
               
 
    
      
      
      
     
 
 0    1    0    1    1  
                        
 
    
      
      
      
     
 
 1    1    1    1    0  
               
 
    
      
      
      
     
 
 1    0    0    1    1  
                        

Supposons que A = 60; et B = 13; maintenant au format binaire, ils seront comme suit:       

A = 0011 1100                      

B = 0000 1101                      

-----------------                      

A&B = 0000 1100                      

A | B = 0011 1101                      

POINT DE TUTORIEL  
Apprentissage simple et simple Page 29

A ^ B = 0011 0001

~ A = 1100 0011

Les opérateurs Bitwise pris en charge par le langage C sont répertoriés dans le tableau suivant. Supposons
que la variable A vaut 60 et la variable B vaut 13, alors:

              
 Opérateur   La description    Exemple  
              
              
         
 
&    L'opérateur binaire AND copie un peu   
(A & B) donnera 12, soit 0000 1100  
         
      résultat s'il existe dans les deux opérandes.       
              
         
         
     L'opérateur OR binaire copie un peu s'il     
  |       (A | B) donnera 61, soit 0011 1101  
      existe dans l'un ou l'autre des opérandes.       
              
            
            
     L'opérateur XOR binaire copie le bit s'il     
 ^       (A ^ B) donnera 49, soit 0011 0001  
      est défini dans un opérande mais pas dans les deux.       
              
         
     L'opérateur de complément des binaires est     
         
  ~       (~ A) donnera -60, soit 1100 0011  
      unaire et a pour effet de «retourner» les bits.       
              
            
      Opérateur de décalage binaire gauche. La gauche       
         
     la valeur des opérandes est déplacée vers la gauche     
  <<       Un << 2 donnera 240, soit 1111 0000  
      nombre de bits spécifié par la droite       
      opérande.       
              
            
      Opérateur de décalage binaire vers la droite. La gauche       
         
  >>    la valeur des opérandes est déplacée vers la droite    Un >> 2 donnera 15, soit 0000 1111  
         
      nombre de bits spécifié par la droite       
      opérande.       
              

Essayez l'exemple suivant pour comprendre tous les opérateurs binaires disponibles dans le langage de
programmation C:

#comprendre <stdio.h>
   

principal ()
       
{        

unsigned int a = 60 ; / * 60 = 0011 1100 * /


unsigned int b = 13 ; / * 13 = 0000 1101 * /
int c = 0 ;    

c = une & b ; / * 12 = 0000 1100 * /


printf ( "Ligne 1 - Valeur de c est% d \ n " , c );

c = une | b ; / * 61 = 0011 1101 * /


printf ( "Ligne 2 - Valeur de c est% d \ n " , c );

c = une ^ b ; / * 49 = 0011 0001 * /


printf ( "Ligne 3 - Valeur de c est% d \ n " , c );

c = ~ a ; / * - 61 = 1100 0011 * /
printf ( "Ligne 4 - Valeur de c est% d \ n " , c );
c = une << 2 ; / * 240 = 1111 0000 * /
printf ( "Ligne 5 - Valeur de c est% d \ n " , c );

c = une >> 2 ; / * 15 = 0000 1111 * /


         

POINT DE TUTORIEL
Apprentissage simple et simple Piste 30

printf ( "Ligne 6 - La valeur de c est% d \ n" , c );


}

Lorsque vous compilez et exécutez le programme ci-dessus, il produit le résultat suivant:

Ligne 1 - La valeur de c est 12


Ligne 2 - La valeur de c est 61
Ligne 3 - La valeur de c est 49
Ligne 4 - La valeur de c est -61
Ligne 5 - La valeur de c est 240
Ligne 6 - La valeur de c est 15

Opérateurs d'affectation
Les opérateurs d'affectation suivants sont pris en charge par le langage C:

         
 Opérateur   La description    Exemple  
              
              
     Opérateur d'affectation simple, attribue des valeurs    C = A + B attribuera la valeur de A + 
  =        
      des opérandes du côté droit à l'opérande du côté gauche    B en C  
              
            
      Ajouter l'opérateur d'affectation AND, il ajoute à droite       
 + =    opérande à l'opérande de gauche et attribuer le résultat    C + = A équivaut à C = C + A  
      à l'opérande gauche       
              
            
      Soustraire l'opérateur d'affectation ET, il soustrait       
 - =    opérande de droite à partir de l'opérande de gauche et attribuer    C - = A équivaut à C = C - A  
      le résultat à l'opérande gauche       
              
              
      Multiplier ET opérateur d'affectation, il multiplie       
 * =    opérande de droite avec l'opérande de gauche et attribuer    C * = A équivaut à C = C * A  
      le résultat à l'opérande gauche       
              
            
      Opérateur d'affectation de division ET, il divise à gauche       
 / =    opérande avec l'opérande droit et attribuer le    C / = A équivaut à C = C / A  
      résultat à l'opérande gauche       
              
              
      Opérateur d'assignation module AND, il faut       
 % =    module en utilisant deux opérandes et attribuer le    C% = A équivaut à C = C% A  
      résultat à l'opérande gauche       
              
                    
 << =    Opérateur de décalage ET d'affectation à gauche    C << = 2 est identique à C = C << 2  
           
                 
 >> =    Opérateur de décalage ET d'affectation à droite    C >> = 2 est identique à C = C >> 2  
           
                 
 & =    Opérateur d'affectation AND au niveau du bit    C & = 2 est identique à C = C & 2  
           
                 
 ^ =    Opérateur OU exclusif et d'affectation au niveau du bit    C ^ = 2 est identique à C = C ^ 2  
           
                 
 | =    OR inclusif au niveau du bit et opérateur d'affectation    C | = 2 est identique à C = C | 2  
              

Essayez l'exemple suivant pour comprendre tous les opérateurs d'affectation disponibles dans le langage
de programmation C:

POINT DE TUTORIEL
Apprentissage simple et simple Piste 31
#include <stdio.h>
principal ()
{
int a = 21
; int c ;
c = a ;
printf ( "Ligne 1 - = Exemple d'opérateur, valeur de c =% d \ n" , c );

c + = a ;
printf ( "Ligne 2 - + = Exemple d'opérateur, valeur de c =% d \ n" , c );

c - = a ;
printf ( "Ligne 3 - - = Exemple d'opérateur, valeur de c =% d \ n" , c );

c * = a ;
printf ( "Ligne 4 - * = Exemple d'opérateur, Valeur de c =% d \ n" , c );
c / = a ;
printf ( "Ligne 5 - / = Exemple d'opérateur, valeur de c =% d \ n" , c );

c = 200 ;
c % = a ;
printf ( "Ligne 6 -% = Exemple d'opérateur, Valeur de c =% d \ n" , c );

c << = 2 ;
printf ( "Ligne 7 - << = Exemple d'opérateur, valeur de c =% d \ n" , c );
c >> = 2 ;
printf ( "Ligne 8 - >> = Exemple d'opérateur, valeur de c =% d \ n" , c );

c & = 2 ;
printf ( "Ligne 9 - & = Exemple d'opérateur, Valeur de c =% d \ n" , c );

c ^ = 2 ;
printf ( "Ligne 10 - ^ = Exemple d'opérateur, Valeur de c =% d \ n" , c );

c | = 2 ;
printf ( "Ligne 11 - | = Exemple d'opérateur, Valeur de c =% d \ n" , c );

Lorsque vous compilez et exécutez le programme ci-dessus, il produit le résultat suivant:

Ligne 1 - = Exemple d'opérateur, valeur de c = 21


Ligne 2 - + = Exemple d'opérateur, valeur de c = 42
Ligne 3 - - = Exemple d'opérateur, valeur de c = 21
Ligne 4 - * = Exemple d'opérateur, valeur de c = 441
Ligne 5 - / = Exemple d'opérateur, valeur de c = 21
Ligne 6 -% = Exemple d'opérateur, valeur de c = 11
Ligne 7 - << = Exemple d'opérateur, valeur de c = 44
Ligne 8 - >> = Exemple d'opérateur, valeur de c = 11

POINT DE TUTORIEL
Apprentissage simple et simple Piste 32

Ligne 9 - & = Exemple d'opérateur, valeur de c = 2


Ligne 10 - ^ = Exemple d'opérateur, valeur de c = 0
Ligne 11 - | = Exemple d'opérateur, valeur de c = 2

Opérateurs divers ↦ sizeof & ternaire


Il existe peu d'autres opérateurs importants, y compris sizeof et ? : pris en charge par le langage C.
              
  Opérateur    La description     Exemple  
              
              
           
  taille de()     Renvoie la taille d'une variable.     sizeof (a), où a est un entier,  
           
            retournera 4.  
              
           
           
          &une; donnera l'adresse réelle de  
 &     Renvoie l'adresse d'une variable.      
            la variable.  
              
                 
 *     Pointeur vers une variable.     *une; pointera vers une variable.  
              
           
           
 ? :     Expression conditionnelle     Si la condition est vraie? ensuite 
           
            valeur X: sinon valeur Y  
              

Priorité des opérateurs en C


La priorité des opérateurs détermine le regroupement des termes dans une expression. Cela affecte la
manière dont une expression est évaluée. Certains opérateurs ont une priorité plus élevée que d'autres; par
exemple, l'opérateur de multiplication a une priorité plus élevée que l'opérateur d'addition.

Par exemple, x = 7 + 3 * 2; ici, x est attribué à 13, et non à 20 car l'opérateur * a une priorité plus élevée que
+, il est donc d'abord multiplié par 3 * 2, puis ajouté en 7.

Ici, les opérateurs ayant la priorité la plus élevée apparaissent en haut du tableau, ceux avec la priorité la
plus faible apparaissent en bas. Dans une expression, les opérateurs de priorité supérieure seront évalués
en premier.

              
Catégorie Opérateur Associativité
                     
              
 
Postfix     
() [] ->. ++ - -     
De gauche à droite   
        
              
  Unaire     + -! ~ ++ - - (type) * & sizeof     De droite à gauche  
              
           
  Multiplicatif     * /%     De gauche à droite  
              
              

    
Additif +-
       
De gauche à droite
          
              

    
Décalage << >>
       
De gauche à droite
          
           
Relationnel <<=>> = De gauche à droite
                       
           
  Égalité     ==! =     De gauche à droite  
              
           
  ET au niveau du bit    &     De gauche à droite  
              
           
XOR au niveau du bit ^ De gauche à droite
                       
           
OU au niveau du bit | De gauche à droite
                       

POINT DE TUTORIEL
Apprentissage simple et simple Piste 33

              
 
ET logique     
 
&&     
 
De gauche à droite  
        
  
   
    
   
    
   
 
 OU logique    ||    De gauche à droite  
              
  
    
       
      
 
 Conditionnel    ?:    De droite à gauche  
              
  
    
       
      
 
 Affectation    = + = - = * = / =% = >> = << = & = ^ = | =    De droite à gauche  
              
  
    
       
      
 
 Virgule    ,    De gauche à droite  
              

Essayez l'exemple suivant pour comprendre la priorité des opérateurs disponible dans le langage de
programmation C:

#include <stdio.h>
     
         
principal ()        
{        
int a = 20 ;      
int b = 10 ;      
int c = 15 ;      
int d = 5 ;      
int e ;      
 
e = ( a + b ) * c / d ; // (30 * 15) / 5
printf ( "La valeur de (a + b) * c / d est:% d \ n" , e );

e = (( a + b ) * c ) / d ; // (30 * 15) / 5  
printf ( "La valeur de ((a + b) * c) / d est :% d \ n " , e );

e = ( a + b ) * ( c / d ); // (30) * (15/5)  
printf ( "La valeur de (a + b) * (c / d) est :% d \ n " , e );

e = a + ( b * c ) / d ; // 20 + (150/5)  
printf ( "La valeur de a + (b * c) / d est :% d \ n " , e );

return 0 ;      
}        
         

Lorsque vous compilez et exécutez le programme ci-dessus, il produit le résultat suivant:

La valeur de (a + b) * c / d est: 90
La valeur de ((a + b) * c) / d est: 90
La valeur de (a + b) * (c / d) est: 90
La valeur de a + (b * c) / d est: 50

POINT DE TUTORIEL
Apprentissage simple et simple Piste 34

CHAPITRE

dix
Prise de décision en C

Les structures de prise de décision exigent que le programmeur spécifie un ou plusieurs

les conditions à évaluer ou à tester par le programme, ainsi qu'une ou plusieurs instructions à exécuter si la
condition est jugée vraie, et éventuellement d'autres instructions à exécuter si la condition est déterminée
comme étant fausse.

Voici la forme générale d'une structure de prise de décision typique trouvée dans la plupart des langages de
programmation:
Le langage de programmation C suppose que toutes les valeurs non nulles et non nulles sont vraies, et si
elles sont nulles ou nulles, elles sont supposées comme fausses valeurs. Le langage de programmation C
fournit les types suivants d'énoncés de prise de décision.

POINT DE TUTORIEL
Apprentissage simple et simple Piste 35

if déclaration
Une instruction if consiste en une expression booléenne suivie d'une ou plusieurs instructions.

Syntaxe
La syntaxe d'une instruction if en langage de programmation C est:

if ( expression_booléenne )
{
/ * instruction (s) s'exécutera si l'expression booléenne est vraie * /
}

Si l' expression booléenne prend la valeur true, alors le bloc de code à l'intérieur du if
l'instruction sera exécutée. Si l' expression booléenne est évaluée à false, alors le premier ensemble de
code après la fin de l' instruction if (après l'accolade fermante) sera exécuté.

Le langage de programmation C suppose que toutes les valeurs non nulles et non nulles sont vraies et si
elles sont nulles ou nulles, elles sont supposées comme fausses valeurs.

Représentation schématique

Exemple
#include <stdio.h>

int main ()
{
/ * définition de variable
locale * / int a = 10 ;

POINT DE TUTORIEL
Apprentissage simple et simple
Piste 36

/ * vérifier la condition booléenne en utilisant


l'instruction if * / if ( a < 20 )
{
/ * si la condition est vraie, alors afficher le *
/ printf suivant ( "a est inférieur à 20 \ n" );
}
printf ( "la valeur de a est:% d \ n" , a );

return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

a est inférieur à 20;


la valeur de a est: 10

if ... instruction else


Une instruction if peut être suivie d'une instruction else facultative , qui s'exécute lorsque l'expression
booléenne est fausse .

Syntaxe
La syntaxe d'une instruction if ... else dans le langage de programmation C est:

if ( expression_booléenne )
{
/ * instruction (s) s'exécutera si l'expression booléenne est vraie * /
}
autre
{
/ * instruction (s) s'exécutera si l'expression booléenne est fausse * /
}

Si l' expression booléenne est évaluée à vrai, alors le bloc de code if sera exécuté, sinon le bloc de code
else sera exécuté.

Le langage de programmation C suppose que toutes les valeurs non nulles et non nulles sont vraies et si
elles sont nulles ou nulles, elles sont supposées comme fausses valeurs.

POINT DE TUTORIEL
Apprentissage simple et simple Piste 37
Représentation schématique

Exemple
#include <stdio.h>
int main ()
{
/ * définition de variable
locale * / int a = 100 ;
/ * vérifier la condition
booléenne * / if ( a < 20 )
{
/ * si la condition est vraie, alors afficher le *
/ printf suivant ( "a est inférieur à 20 \ n" );
}
autre
{
/ * si la condition est fausse, alors afficher le *
/ printf suivant ( "a n'est pas inférieur à 20 \ n"
);
}
printf ( "la valeur de a est:% d \ n" , a );

return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

a n'est pas inférieur à 20;


la valeur de a est: 100

POINT DE TUTORIEL
Apprentissage simple et simple Piste 38

Instruction if ... else if ... else


Une instruction if peut être suivie d'une instruction else if ... else facultative , ce qui est très utile pour tester
diverses conditions en utilisant une instruction if ... else if unique .

Lors de l'utilisation des instructions if, else if, else , il y a quelques points à garder à l'esprit:
∙ Un if peut avoir zéro ou un autre et il doit venir après tout autre if .

∙ Un if peut avoir zéro à beaucoup d' autres if et ils doivent venir avant l' autre .

∙ Une fois qu'un else if réussit, aucun des autres if ou else restants ne sera testé.

Syntaxe
La syntaxe d'une instruction if ... else if ... else en langage de programmation C est:

if ( expression_booléenne 1 )
{
/ * S'exécute lorsque l'expression booléenne 1 est vraie * /
}
else if ( expression_booléenne 2 )
{
/ * S'exécute lorsque l'expression booléenne 2 est vraie * /
}
else if ( expression_booléenne 3 )
{
/ * S'exécute lorsque l'expression booléenne 3 est vraie * /
}
autre
{
/ * s'exécute lorsque aucune des conditions ci-dessus est vraie * /
}

Exemple
#include <stdio.h>

int main ()
{
/ * définition de variable
locale * / int a = 100 ;
/ * vérifier la condition
booléenne * / if ( a == 10 )
{
/ * si la condition est vraie, alors afficher le *
/ printf suivant ( "La valeur de a est 10 \ n" );
}
sinon si ( a == 20 )
{
/ * if else si la condition est
vraie * / printf ( "La valeur de
a est 20 \ n" );

POINT DE TUTORIEL
Apprentissage simple et simple Piste 39

}
sinon si ( a == 30 )
{
/ * if else si la condition est
vraie * / printf ( "La valeur de a
est 30 \ n" );
}
autre
{
/ * si aucune des conditions n'est vraie *
/ printf ( "Aucune des valeurs ne
correspond \ n" );
}
printf ( "La valeur exacte de a est:% d \ n" , a );

return 0 ;
}
Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Aucune des valeurs ne correspond

La valeur exacte de a est: 100

Instructions if imbriquées
Il est toujours légal dans la programmation C d' imbriquer des instructions if-else , ce qui signifie que vous
pouvez utiliser une instruction if ou else if dans une ou plusieurs instructions if ou else if .

Syntaxe
La syntaxe d'une instruction if imbriquée est la suivante:

if ( expression_booléenne 1 )
{
/ * S'exécute lorsque l'expression booléenne 1 est
vraie * / if ( expression_booléenne 2 )
{
/ * S'exécute lorsque l'expression booléenne 2 est vraie * /
}
}

Vous pouvez imbriquer else if ... else de la même manière que vous avez imbriqué l' instruction if .

Exemple
#include <stdio.h>

int main ()
{
/ * définition de variable
locale * / int a = 100 ;
int b = 200 ;

/ * vérifier la condition booléenne * /

POINT DE TUTORIEL
Apprentissage simple et simple Piste 40

si ( a == 100 )
{
/ * si la condition est vraie alors vérifiez ce
qui suit * / if ( b == 200 )
{
/ * si la condition est vraie, alors imprimez ce qui suit * /
printf ( "La valeur de a est 100 et b est 200 \ n" );
}
}
printf ( "La valeur exacte de a est:% d \ n" , a );
printf ( "La valeur exacte de b est:% d \ n" , b );

return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

La valeur de a est 100 et b est 200

La valeur exacte de a est: 100


La valeur exacte de b est: 200

instruction switch
Une instruction switch permet de tester l'égalité d'une variable par rapport à une liste de valeurs. Chaque
valeur est appelée un cas, et la variable activée est vérifiée pour chaque cas de commutation.

Syntaxe
La syntaxe d'une instruction switch dans le langage de programmation C est la suivante:

commutateur ( expression ) {
case
constante - expression :
déclaration ( s );
pause ; /* optionnel */
case
constante - expression :
déclaration ( s );
pause ; /* optionnel */
/ * vous pouvez avoir n'importe quel nombre
d'instructions case * / default : / *
Facultatif * /
déclaration ( s );
}

Les règles suivantes s'appliquent à une instruction switch :

∙ L' expression utilisée dans une instruction switch doit avoir un type intégral ou énuméré,
ou être d'un type de classe dans lequel la classe a une seule fonction de conversion en
un type intégral ou énuméré.

POINT DE TUTORIEL
Apprentissage simple et simple Piste 41

∙ Vous pouvez avoir n'importe quel nombre d'instructions case dans un commutateur.
Chaque cas est suivi de la valeur à comparer et d'un signe deux-points.

∙ L' expression constante d'un cas doit être du même type de données que la variable
dans le commutateur et doit être une constante ou un littéral.
∙ Lorsque la variable activée est égale à un cas, les instructions qui suivent ce cas
s'exécutent jusqu'à ce qu'une instruction break soit atteinte.
∙ Lorsqu'une instruction break est atteinte, le commutateur se termine et le flux de
contrôle passe à la ligne suivante après l'instruction switch.
∙ Tous les cas n'ont pas besoin de contenir une pause . Si aucune coupure
apparaît, le flux de contrôle va tomber dans les cas suivants jusqu'à ce qu'une pause soit
atteinte.
∙ Une instruction switch peut avoir un cas par défaut facultatif , qui doit apparaître à la fin
du switch. Le cas par défaut peut être utilisé pour exécuter une tâche lorsqu'aucun des
cas n'est vrai. Aucune pause n'est nécessaire dans le cas par défaut.

Représentation schématique
Exemple
#include <stdio.h>

int main ()
{
/ * définition de variable
locale * / char grade = 'B' ;
interrupteur ( grade )
{
cas 'A' :

POINT DE TUTORIEL
Apprentissage simple et simple Piste 42

printf ( "Excellent! \
n" ); pause ;
cas 'B' :
cas 'C' :
printf ( "Bien joué \
n" ); pause ;
cas 'D' :
printf ( "Vous avez
réussi \ n" ); pause ;
cas 'F' :
printf ( "Mieux vaut
réessayer \ n" ); pause ;
par défaut :
printf ( "Note invalide \ n" );
}
printf ( "Votre note est% c \ n" , note );

return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Bien joué

Votre note est B

Instructions de commutateur imbriquées


Il est possible d'avoir un commutateur dans le cadre de la séquence d'instructions d'un commutateur
externe . Même si les constantes de cas du commutateur interne et externe contiennent des valeurs
communes, aucun conflit ne surviendra.

Syntaxe
La syntaxe d'une instruction de commutateur imbriquée est la suivante:

commutateur
( ch1 ) {
cas 'A' :
printf ( "Ce A fait partie du commutateur
externe" ); commutateur ( ch2 ) {
cas 'A' :
printf ( "Ce A fait partie du commutateur
interne" ); pause ;
case 'B' : / * code case * /
}
pause ;
case 'B' : / * code case * /
}

Exemple
#include <stdio.h>
int main ()
{

POINT DE TUTORIEL
Apprentissage simple et simple Piste 43

/ * définition de variable
locale * / int a = 100 ;
int b = 200 ;

commutateur
( a ) {
cas 100
:
printf ( "Cela fait partie du commutateur
externe \ n" , a ); interrupteur ( b ) {
cas 200 :
printf ( "Cela fait partie du commutateur interne \ n" , a );
}
}
printf ( "La valeur exacte de a est:% d \ n" , a );
printf ( "La valeur exacte de b est:% d \ n" , b );

return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Cela fait partie du commutateur externe


Cela fait partie de l'interrupteur intérieur
La valeur exacte de a est: 100

La valeur exacte de b est: 200

Le ? : Opérateur
Nous avons couvert l'opérateur conditionnel ? : dans le chapitre précédent qui peut être utilisé pour
remplacer les instructions if ... else . Il a la forme générale suivante:

Exp1 ? Exp2 : Exp3 ;

Où Exp1, Exp2 et Exp3 sont des expressions. Notez l'utilisation et le placement des deux points.

La valeur d'un? expression est déterminée comme ceci: Exp1 est évalué. Si c'est vrai , alors Exp2 est évalué
et devient la valeur de l'ensemble ? expression. Si Exp1 est faux , Exp3 est évalué et sa valeur devient la
valeur de l'expression.

POINT DE TUTORIEL
Apprentissage simple et simple Piste 44
CHAPITRE

11
Boucles C

T ici peut être une situation, lorsque vous devez exécuter un bloc de code plusieurs nombres

des fois. En général, les instructions sont exécutées séquentiellement: la première instruction d'une
fonction est exécutée en premier, suivie de la seconde , et ainsi de suite .

Les langages de programmation fournissent diverses structures de contrôle qui permettent des chemins
d'exécution plus compliqués.

Une instruction de boucle nous permet d'exécuter une instruction ou un groupe d'instructions plusieurs fois
et voici la forme générale d'une instruction de boucle dans la plupart des langages de programmation

Le langage de programmation C fournit les types de boucles suivants pour gérer les exigences de bouclage.

POINT DE TUTORIEL
Apprentissage simple et simple Piste 45

while boucle en C
A tout énoncé de boucle dans le langage de programmation C exécute de manière répétée une instruction
cible tant qu'une condition donnée est vraie .
Syntaxe
La syntaxe d'une en boucle dans le langage de programmation C est:

tandis que ( condition )


{
déclaration ( s );
}

Ici, la ou les instructions peuvent être une seule instruction ou un bloc d'instructions. La condition peut être
n'importe quelle expression et true est n'importe quelle valeur différente de zéro . La boucle se répète tant
que la condition est vraie .

Lorsque la condition devient fausse , le contrôle du programme passe à la ligne qui suit immédiatement la
boucle.

Représentation schématique

POINT DE TUTORIEL
Apprentissage simple et simple Piste 46

Ici, le point clé de la boucle while est que la boucle peut ne jamais s'exécuter. Lorsque la condition est
testée et que le résultat est faux , le corps de la boucle sera ignoré et la première instruction après la boucle
while sera exécutée.

Exemple
#include <stdio.h>

int main ()
{
/ * définition de variable
locale * / int a = 10 ;
/ * pendant l'exécution
de la boucle * / while (
a < 20 )
{
printf ( "valeur de a:% d \
n" , a ); a ++;
}

return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

valeur de a: 10

valeur de a: 11
valeur de a: 12

valeur de a: 13
valeur de a: 14
valeur de a: 15

valeur de a: 16
valeur de a: 17
valeur de a: 18
valeur de a: 19

boucle for en C
Une boucle for est une structure de contrôle de répétition qui vous permet d'écrire efficacement une boucle
qui doit s'exécuter un certain nombre de fois.

Syntaxe
La syntaxe d'une boucle for en langage de programmation C est:

pour ( init ; condition ; incrément )


{

POINT DE TUTORIEL
Apprentissage simple et simple Piste 47

déclaration ( s );
}

Voici le flux de contrôle dans une boucle for:

1. L' étape d' initialisation est exécutée en premier, et une seule fois. Cette étape vous
permet de déclarer et d'initialiser toutes les variables de contrôle de boucle. Vous n'êtes
pas obligé de mettre une instruction ici, tant qu'un point-virgule apparaît.

2. Ensuite, la condition est évaluée. Si c'est vrai, le corps de la boucle est exécuté. S'il est
faux, le corps de la boucle ne s'exécute pas et le flux de contrôle passe à l'instruction
suivante juste après la boucle for.
3. Après le corps du pour boucle exécute, le flux de contrôle revie
l' incrément déclaration.Ce déclarationvous permet de mettre à jour n'importe quel contrôle de bo
 
variables. Cette instruction peut être laissée vide, tant qu'un point-virgule apparaît après
la condition.

4. La condition est à nouveau évaluée. Si c'est vrai, la boucle s'exécute et le processus se


répète (corps de la boucle, puis incrémentation, puis à nouveau condition). Une fois que
la condition devient fausse, la boucle for se termine.

Représentation schématique
Exemple
#include <stdio.h>

int main ()

POINT DE TUTORIEL
Apprentissage simple et simple Piste 48

{
/ * pour l'exécution en boucle * /
pour ( int a = 10 ; a < 20 ; a = a + 1 )
{
printf ( "valeur de a:% d \ n" , a );
}

return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

valeur de a: 10
valeur de a: 11
valeur de a: 12
valeur de a: 13
valeur de a: 14

valeur de a: 15
valeur de a: 16
valeur de a: 17
valeur de a: 18

valeur de a: 19

faire ... boucle while en C


Contrairement aux boucles for et while, qui testent la condition de la boucle en haut de la boucle, la boucle
do ... while en langage de programmation C vérifie sa condition en bas de la boucle.

Une boucle do ... while est similaire à une boucle while, sauf qu'une boucle do ... while est garantie de
s'exécuter au moins une fois.

Syntaxe
La syntaxe d'une boucle do ... while en langage de programmation C est:

faire
{
déclaration ( s );

} while ( condition );

Notez que l'expression conditionnelle apparaît à la fin de la boucle, donc la ou les instructions de la boucle
s'exécutent une fois avant que la condition ne soit testée.

POINT DE TUTORIEL
Piste 49
Apprentissage simple et simple

Si la condition est vraie , le flux de contrôle revient en arrière pour faire et les instructions de la boucle
s'exécutent à nouveau. Ce processus se répète jusqu'à ce que la condition donnée devienne fausse .

Représentation schématique

Exemple
#include <stdio.h>
int main ()
{
/ * définition de variable
locale * / int a = 10 ;
/ * exécuter une
boucle * / faire
{
printf ( "valeur de a:% d \ n" , a );
a = a + 1 ;
} tandis que ( a < 20 );

return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

valeur de a: 10
valeur de a: 11

valeur de a: 12
valeur de a: 13

valeur de a: 14

POINT DE TUTORIEL
Apprentissage simple et simple Piste 50
valeur de a: 15
valeur de a: 16
valeur de a: 17
valeur de a: 18

valeur de a: 19

boucles imbriquées en C
Le langage de programmation C permet d'utiliser une boucle dans une autre boucle. La section suivante
montre quelques exemples pour illustrer le concept.

Syntaxe
La syntaxe d'une instruction de boucle imbriquée en C est la suivante:

pour ( init ; condition ; incrément )


{
pour ( init ; condition ; incrément )
{
déclaration ( s );
}
déclaration ( s );
}

La syntaxe d'une instruction de boucle while imbriquée dans le langage de programmation C est la suivante:

tandis que ( condition )


{
tandis que ( condition )
{
déclaration ( s );
}
déclaration ( s );
}

La syntaxe d'une instruction de boucle imbriquée do ... while dans le langage de programmation C est la
suivante:

faire
{
déclaration
( s ); faire
{
déclaration ( s
); } while (
condition );

} while ( condition );

POINT DE TUTORIEL
Apprentissage simple et simple Piste 51

Une dernière remarque sur l'imbrication de boucles est que vous pouvez placer n'importe quel type de
boucle à l'intérieur de n'importe quel autre type de boucle. Par exemple, une boucle for peut être à l'intérieur
d'une boucle while ou vice versa.

Exemple
Le programme suivant utilise une boucle for imbriquée pour trouver les nombres premiers de 2 à 100:
#include <stdio.h>

int main ()
{
/ * définition de variable
locale * / int i , j ;

pour ( i = 2 ; i < 100 ; i


++) { pour ( j = 2 ; j
<= ( i / j ); j ++)
si (! ( i % j )) pause ; // si facteur trouvé,
pas premier si ( j > ( i / j )) printf ( "% d
est premier \ n" , i );
}

return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

2 est premier

3 est premier
5 est premier
7 est le premier
11 est le premier

13 est premier
17 est le premier
19 est le premier
23 est premier
29 est le premier

31 est le premier
37 est le premier
41 est le premier
43 est premier
47 est le premier

53 est premier
59 est le premier
61 est le premier

POINT DE TUTORIEL
Apprentissage simple et simple Piste 52

67 est le premier
71 est le premier

73 est le premier
79 est le premier

83 est premier
89 est le premier
97 est le premier

instruction break en C
L' instruction break dans le langage de programmation C a les deux utilisations suivantes:
1. Lorsque l' instruction break est rencontrée dans une boucle, la boucle est
immédiatement terminée et le contrôle du programme reprend à l'instruction suivante
suivant la boucle.

2. Il peut être utilisé pour terminer un cas dans l' instruction switch (traité dans le chapitre suivant).

Si vous utilisez des boucles imbriquées (c'est-à-dire une boucle dans une autre boucle), l' instruction break
arrêtera l'exécution de la boucle la plus interne et commencera à exécuter la ligne de code suivante après le
bloc.

Syntaxe
La syntaxe d'une instruction break en C est la suivante:

pause ;

Représentation schématique

POINT DE TUTORIEL
Apprentissage simple et simple Piste 53

Exemple
#include <stdio.h>
int main ()
{
/ * définition de variable
locale * / int a = 10 ;
/ * pendant l'exécution
de la boucle * / while (
a < 20 )
{
printf ( "valeur de a:% d \
n" , a ); a ++;
si ( a > 15 )
{
/ * terminer la boucle en utilisant
l'instruction break * / break ;
}
}

return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:


valeur de a: 10
valeur de a: 11

valeur de a: 12
valeur de a: 13
valeur de a: 14
valeur de a: 15

instruction continue en C
La déclaration continue dans Langage de programmation C travaux quelque peu comme
l'instruction break. Au lieu de forcer la résiliation, cependant, continuer force le prochain
itération de la boucle à avoir lieu, en sautant tout code entre les deux.

Pour la boucle for , l' instruction continue entraîne l'exécution des parties test conditionnel et incrémentation
de la boucle. Pour les boucles while et do ... while , l' instruction continue fait passer le contrôle du
programme aux tests conditionnels.

Syntaxe
La syntaxe d'une instruction continue en C est la suivante:

continuer ;

POINT DE TUTORIEL
Apprentissage simple et simple Piste 54

Représentation schématique

Exemple
#include <stdio.h>

int main ()
{
/ * définition de variable
locale * / int a = 10 ;
/ * exécuter une
boucle * / faire
{
si ( a == 15 )
{
/ * sauter l'itération * /
a = a + 1
;
continuer
;
}
printf ( "valeur de a:% d \
n" , a ); a ++;

} tandis que ( a < 20 );

return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

valeur de a: 10
valeur de a: 11

POINT DE TUTORIEL
Apprentissage simple et simple Piste 55

valeur de a: 12
valeur de a: 13

valeur de a: 14
valeur de a: 16
valeur de a: 17
valeur de a: 18

valeur de a: 19

instruction goto en C
Une instruction goto dans le langage de programmation C fournit un saut inconditionnel de goto à une
instruction étiquetée dans la même fonction.

REMARQUE: l' utilisation de l' instruction goto est fortement déconseillée dans tout langage de
programmation car elle rend difficile le suivi du flux de contrôle d'un programme, ce qui rend le programme
difficile à comprendre et difficile à modifier. Tout programme qui utilise un goto peut être réécrit afin qu'il
n'ait pas besoin du goto .

Syntaxe
La syntaxe d'une instruction goto en C est la suivante:

goto label ;
..
.
label : déclaration ;

Ici, l' étiquette peut être n'importe quel texte brut à l'exception du mot-clé C et elle peut être définie n'importe
où dans le programme C au-dessus ou en dessous de l' instruction goto .

Représentation schématique
POINT DE TUTORIEL
Apprentissage simple et simple Piste 56

Exemple
#include <stdio.h>
int main ()
{
/ * définition de variable
locale * / int a = 10 ;
/ * exécuter une
boucle * / LOOP :
faire
{
si ( a == 15 )
{
/ * sauter l'itération * /
a = a + 1
; goto
LOOP ;
}
printf ( "valeur de a:% d \
n" , a ); a ++;

} tandis que ( a < 20 );

return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

valeur de a: 10
valeur de a: 11

valeur de a: 12
valeur de a: 13
valeur de a: 14

valeur de a: 16
valeur de a: 17

valeur de a: 18
valeur de a: 19

La boucle infinie
Une boucle devient une boucle infinie si une condition ne devient jamais fausse . La boucle for est
traditionnellement utilisée à cette fin. Étant donné qu'aucune des trois expressions qui forment la boucle for
n'est requise, vous pouvez créer une boucle sans fin en laissant l'expression conditionnelle vide.

#include <stdio.h>

int main ()
{

POINT DE TUTORIEL
Apprentissage simple et simple Psaumes 57
pour (;;)
{
printf ( "Cette boucle fonctionnera pour toujours. \ n" );
}

return 0 ;
}

Lorsque l'expression conditionnelle est absente, elle est supposée vraie. Vous pouvez avoir une expression
d'initialisation et d'incrémentation, mais les programmeurs C utilisent plus couramment la construction for
(;;) pour signifier une boucle infinie.

REMARQUE : Vous pouvez mettre fin à une boucle infinie en appuyant sur Ctrl + C touches.

POINT DE TUTORIEL
Apprentissage simple et simple Psaumes 58

CHAPITRE

12
Fonctions C

La fonction
exécutent ensemble une tâche. Chaque programme C a au moins
est un groupe d'instructions qui

une fonction, qui est main (), et tous les programmes les plus triviaux peuvent définir des fonctions
supplémentaires.

Vous pouvez diviser votre code en fonctions distinctes. La façon dont vous divisez votre code entre
différentes fonctions dépend de vous, mais logiquement, la division est généralement de sorte que chaque
fonction effectue une tâche spécifique.

Une déclaration de fonction informe le compilateur du nom, du type de retour et des paramètres d'une
fonction. Une définition de fonction fournit le corps réel de la fonction.

La bibliothèque standard C fournit de nombreux haut- fonctions que votre programme peut appeler. Par
exemple, function strcat () pour concaténer deux chaînes, function memcpy () pour copier un emplacement
mémoire vers un autre emplacement et bien d'autres fonctions.

Une fonction est connue sous différents noms comme une méthode ou une sous-routine ou une procédure, etc.

Définition d'une fonction


La forme générale d'une définition de fonction dans le langage de programmation C est la suivante:

return_type nom_fonction ( liste de paramètres )


{
corps de la fonction
}

Une définition de fonction en langage de programmation C se compose d'un en-tête de fonction et d'un
corps de fonction. Voici toutes les parties d'une fonction:

∙ Type de retour : une fonction peut renvoyer une valeur. Le return_type est le type de
données de la valeur renvoyée par la fonction. Certaines fonctions exécutent les
opérations souhaitées sans renvoyer de valeur. Dans ce cas, le return_type est le mot-clé
void .
∙ Nom de la fonction: il s'agit du nom réel de la fonction. Le nom de la fonction et la liste
des paramètres constituent ensemble la signature de la fonction.
∙ Paramètres: un paramètre est comme un espace réservé. Lorsqu'une fonction est
appelée, vous transmettez une valeur au paramètre. Cette valeur est appelée paramètre
ou argument réel. le

POINT DE TUTORIEL
Apprentissage simple et simple Piste 59

La liste de paramètres fait référence au type, à l'ordre et au nombre de paramètres d'une


fonction. Les paramètres sont facultatifs; autrement dit, une fonction peut ne contenir
aucun paramètre.
∙ Corps de la fonction: le corps de la fonction contient une collection d'instructions qui
définissent ce que fait la fonction.

Exemple
Voici le code source d'une fonction appelée max (). Cette fonction prend deux paramètres num1 et num2 et
renvoie le maximum entre les deux:

/ * fonction renvoyant le max entre deux nombres *


/ int max ( int num1 , int num2 )
{
/ * déclaration de variable
locale * / int result ;
if ( num1 > num2
) result =
num1 ;
autre
résultat = num2 ;

résultat de retour ;
}

Déclarations de fonction
Une déclaration de fonction indique au compilateur un nom de fonction et comment appeler la fonction. Le
corps réel de la fonction peut être défini séparément.

Une déclaration de fonction comprend les parties suivantes:

return_type nom_fonction ( liste de paramètres );

Pour la fonction max () définie ci-dessus, voici la déclaration de fonction:

int max ( int num1 , int num2 );

Les noms de paramètres ne sont pas importants dans la déclaration de fonction, seul leur type est requis,
ce qui suit est également une déclaration valide:

int max ( int , int );

La déclaration de fonction est requise lorsque vous définissez une fonction dans un fichier source et que
vous appelez cette fonction dans un autre fichier. Dans ce cas, vous devez déclarer la fonction en haut du
fichier appelant la fonction.

Appeler une fonction


Lors de la création d'une fonction C, vous donnez une définition de ce que la fonction doit faire. Pour utiliser
une fonction, vous devrez appeler cette fonction pour exécuter la tâche définie.

POINT DE TUTORIEL
Apprentissage simple et simple Piste 60

Lorsqu'un programme appelle une fonction, le contrôle du programme est transféré à la fonction appelée.
Une fonction appelée exécute une tâche définie et lorsque son instruction return est exécutée ou lorsque
son accolade fermante de fin de fonction est atteinte, elle renvoie le contrôle du programme au programme
principal.

Pour appeler une fonction, vous devez simplement transmettre les paramètres requis avec le nom de la
fonction, et si la fonction renvoie une valeur, vous pouvez stocker la valeur renvoyée. Par exemple:

#include <stdio.h>

/ * déclaration de fonction
* / int max ( int num1 ,
int num2 );
int main ()
{
/ * définition de variable
locale * / int a = 100 ;
int b = 200
; int ret ;
/ * appel d'une fonction pour obtenir la
valeur max * / ret = max ( a , b );

printf ( "La valeur maximale est:% d \ n" , ret );

return 0 ;
}
/ * fonction renvoyant le max entre deux nombres *
/ int max ( int num1 , int num2 )
{
/ * déclaration de variable
locale * / int result ;
if ( num1 > num2
) result =
num1 ;
autre
résultat = num2 ;

résultat de retour ;
}

J'ai conservé la fonction max () avec la fonction main () et compilé le code source. Lors de l'exécution de
l'exécutable final, cela produirait le résultat suivant:

La valeur maximale est: 200

Arguments de fonction
Si une fonction doit utiliser des arguments, elle doit déclarer des variables qui acceptent les valeurs des
arguments. Ces variables sont appelées les paramètres formels de la fonction.

Les paramètres formels se comportent comme les autres variables locales à l'intérieur de la fonction et
sont créés à l'entrée dans la fonction et détruits à la sortie.

POINT DE TUTORIEL
Apprentissage simple et simple Piste 61

Lors de l'appel d'une fonction, les arguments peuvent être passés à une fonction de deux manières :

Appel de fonction par valeur


La méthode d' appel par valeur consistant à passer des arguments à une fonction copie la valeur réelle d'un
argument dans le paramètre formel de la fonction. Dans ce cas, les modifications apportées au paramètre à
l'intérieur de la fonction n'ont aucun effet sur l'argument.

Par défaut, le langage de programmation C utilise la méthode d'appel par valeur pour passer des arguments.
En général, cela signifie que le code dans une fonction ne peut pas modifier les arguments utilisés pour
appeler la fonction. Considérez la définition de la fonction swap () comme suit.

/ * définition de fonction pour permuter


les valeurs * / void swap ( int x , int y )
{
int temp ;

temp = x ; / * enregistre la valeur de x * /


x = y ; / * mettre y dans x
* / y = temp ; / * mettre x
dans y * /

retour ;
}

Maintenant, appelons la fonction swap () en passant des valeurs réelles comme dans l'exemple suivant:
#include <stdio.h>

/ * déclaration de
fonction * / void swap (
int x , int y );
int main ()
{
/ * définition de variable
locale * / int a = 100 ;
int b = 200 ;

printf ( "Avant l'échange, valeur de a:% d \ n" , a );


printf ( "Avant l'échange, valeur de b:% d \ n" , b );

/ * appel d'une fonction pour permuter les


valeurs * / swap ( a , b );

printf ( "Après échange, valeur de a:% d \ n" , a );


printf ( "Après échange, valeur de b:% d \ n" , b );

return 0 ;
}

Mettons le code ci-dessus dans un seul fichier C, compilons-le et exécutons-le, cela produira le résultat
suivant:

Avant échange, valeur de a: 100


Avant swap, valeur de b: 200

POINT DE TUTORIEL
Apprentissage simple et simple Piste 62

Après échange, valeur de a: 100


Après échange, valeur de b: 200

Ce qui montre qu'il n'y a pas de changement dans les valeurs bien qu'elles aient été modifiées à l'intérieur de
la fonction.

Appel de fonction par référence


La méthode d' appel par référence pour passer des arguments à une fonction copie l'adresse d'un argument
dans le paramètre formel. À l'intérieur de la fonction, l'adresse est utilisée pour accéder à l'argument réel
utilisé dans l'appel. Cela signifie que les modifications apportées au paramètre affectent l'argument passé.

Pour passer la valeur par référence , les pointeurs d'argument sont passés aux fonctions comme toute
autre valeur. Donc, en conséquence, vous devez déclarer les paramètres de fonction comme des types de
pointeurs comme dans la fonction suivante swap (), qui échange les valeurs des deux variables entières
pointées par ses arguments.

/ * définition de fonction pour permuter


les valeurs * / void swap ( int * x , int *
y )
{
 
int temp ;  
temp = * x ; / * enregistrer la valeur à l'adresse x * /
* x = * y ; / * mettre y dans x * /
* y = température ;/ * mettre x dans y * /

retour ;
 
}
 

Appelons la fonction swap () en passant des valeurs par référence comme dans l'exemple suivant:

#include <stdio.h>
/ * déclaration de
fonction * / void swap (
int * x , int * y );
int main ()
{
/ * définition de variable
locale * / int a = 100 ;
int b = 200 ;

printf ( "Avant l'échange, valeur de a:% d \ n" , a );


printf ( "Avant l'échange, valeur de b:% d \ n" , b );

/ * appelant une fonction pour permuter les valeurs.


* & a indique un pointeur vers un ie. adresse de la variable a et
* & b indique le pointeur vers b ie. adresse de la variable b.
* /
swap (& un , & b );

printf ( "Après échange, valeur de a:% d \ n" , a );


printf ( "Après échange, valeur de b:% d \ n" , b );

POINT DE TUTORIEL
Apprentissage simple et simple Piste 63

return 0 ;
}

Mettons le code ci-dessus dans un seul fichier C, compilons-le et exécutons-le, cela produira le résultat
suivant:

Avant échange, valeur de a: 100


Avant swap, valeur de b: 200
Après échange, valeur de a: 200

Après échange, valeur de b: 100

Ce qui montre qu'il n'y a pas de changement dans les valeurs bien qu'elles aient été modifiées à l'intérieur de
la fonction.
POINT DE TUTORIEL
Apprentissage simple et simple Piste 64

CHAPITRE

13
Règles de portée C

Une
peut avoir
portée dans toute programmation est une région du programme où une variable définie

son existence et au-delà de cette variable ne sont pas accessibles. Il y a trois endroits où les
variables peuvent être déclarées en langage de programmation C:

∙ À l'intérieur d'une fonction ou d'un bloc appelé variables locales ,


∙ En dehors de toutes les fonctions appelées variables globales .
∙ Dans la définition des paramètres de fonction que l'on appelle paramètres formels .

Expliquons ce que sont les variables locales et globales et les paramètres formels .

Variables locales
Les variables déclarées à l'intérieur d'une fonction ou d'un bloc sont appelées variables locales . Ils ne
peuvent être utilisés que par des instructions qui se trouvent à l'intérieur de cette fonction ou de ce bloc de
code. Les variables locales ne sont pas connues pour fonctionner en dehors des leurs. Voici l'exemple
utilisant des variables locales . Ici, toutes les variables a, b et c sont locales à la fonction main () .

#include <stdio.h>
int main ()
{
/ * déclaration de variable
locale * / int a , b ;
int c ;

/ * initialisation réelle * /
a = 10 ;
b = 20 ;
c = a + b ;

printf ( "valeur de a =% d, b =% d et c =% d \ n" , a , b , c );

return 0 ;
}

POINT DE TUTORIEL
Apprentissage simple et simple Piste 65
Variables globales
Les variables globales sont définies en dehors d'une fonction, généralement au-dessus du programme. Les
variables globales conserveront leur valeur pendant toute la durée de vie de votre programme et elles
peuvent être accédées à l'intérieur de n'importe laquelle des fonctions définies pour le programme.

Une variable globale est accessible par n'importe quelle fonction. Autrement dit, une variable globale est
disponible pour une utilisation dans tout votre programme après sa déclaration. Voici l'exemple utilisant des
variables globales et locales:

#include <stdio.h>

/ * déclaration de variable
globale * / int g ;
int main ()
{
/ * déclaration de variable
locale * / int a , b ;
/ * initialisation réelle * /
a = 10 ;
b = 20 ;
g = a + b ;

printf ( "valeur de a =% d, b =% d et g =% d \ n" , a , b , g );

return 0 ;
}

Un programme peut avoir le même nom pour les variables locales et globales mais la valeur de la variable
locale à l'intérieur d'une fonction aura la préférence. Voici un exemple:

#include <stdio.h>

/ * déclaration de variable
globale * / int g = 20 ;
int main ()
{
/ * déclaration de variable
locale * / int g = 10 ;

printf ( "valeur de g =% d \ n" , g );

return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

valeur de g = 10

POINT DE TUTORIEL
Apprentissage simple et simple Piste 66

Paramètres formels
Les paramètres de fonction, appelés paramètres formels , sont traités comme des variables locales au sein
de cette fonction et auront la préférence sur les variables globales. Voici un exemple:

#include <stdio.h>
/ * déclaration de variable
globale * / int a = 20 ;

int main ()
{
/ * déclaration de variable locale dans la
fonction principale * / int a = 10 ;
int b = 20
; int c = 0
;

printf ( "valeur de a dans main () =% d \ n" , a );


c = somme ( a , b );
printf ( "valeur de c dans main () =% d \ n" , c );

return 0 ;
}

/ * fonction pour ajouter deux


entiers * / int sum ( int a , int
b )
{
printf ( "valeur de a dans somme () =% d
\ n" , a ); printf ( "valeur de b dans
somme () =% d \ n" , b );
retourne a + b ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

valeur de a dans main ()


= 10 valeur de a dans
somme () = 10 valeur de
b dans somme () = 20
valeur de c dans main ()
= 30

Initialisation des variables locales et globales


Lorsqu'une variable locale est définie, elle n'est pas initialisée par le système, vous devez l'initialiser vous-
même. Les variables globales sont initialisées automatiquement par le système lorsque vous les définissez
comme suit:

 
    
     
 
 Type de données    Valeur par défaut initiale  
       
 
    
     
 
 int    0  
         

POINT DE TUTORIEL
Apprentissage simple et simple Piste 67

         
carboniser
       
«\ 0»
       
               
  flotte    0  
        
               
  double    0  
         
               
  aiguille     NUL  
         

C'est une bonne pratique de programmation d'initialiser correctement les variables, sinon votre programme
peut produire des résultats inattendus car les variables non initialisées prendront une certaine valeur de
garbage déjà disponible à son emplacement mémoire.
POINT DE TUTORIEL
Apprentissage simple et simple Piste 68

CHAPITRE

14
Tableaux C

Le langage de programmation

C fournit une structure de données appelée tableau , qui peut stocker

une collection séquentielle à taille fixe d'éléments du même type. Un tableau est utilisé pour stocker une
collection de données, mais il est souvent plus utile de considérer un tableau comme une collection de
variables du même type.

Au lieu de déclarer des variables individuelles, telles que nombre0, nombre1, ... et nombre99, vous déclarez
une variable de tableau telle que des nombres et utilisez les nombres [0], les nombres [1] et ..., les nombres
[99] pour représenter variables individuelles. Un élément spécifique d'un tableau est accessible par un index
.

Tous les tableaux sont constitués d'emplacements de mémoire contigus. L'adresse la plus basse
correspond au premier élément et l'adresse la plus élevée au dernier élément.

Déclaration de tableaux
Pour déclarer un tableau en C, un programmeur spécifie le type des éléments et le nombre d'éléments
requis par un tableau comme suit:

type arrayName [ arraySize ];

C'est ce qu'on appelle un tableau unidimensionnel . Le arraySize doit être une constante entière supérieure à
zéro et le type peut être n'importe quel type de données C valide. Par exemple, pour déclarer un tableau de
10 éléments appelé balance de type double, utilisez cette instruction:

double balance [ 10 ];

Maintenant, l'équilibre est un tableau de variables qui est suffisant pour contenir jusqu'à 10 nombres doubles.

POINT DE TUTORIEL  
Apprentissage simple et simple Piste 69
Initialisation des tableaux
Vous pouvez initialiser le tableau en C un par un ou en utilisant une seule instruction comme suit:

double solde [ 5 ] = { 1000,0 , 2,0 , 3,4 , 17,0 , 50,0 };

Le nombre de valeurs entre accolades {} ne peut pas être supérieur au nombre d'éléments que nous
déclarons pour le tableau entre crochets []. Voici un exemple pour affecter un seul élément du tableau:

Si vous omettez la taille du tableau, un tableau juste assez grand pour contenir l'initialisation est créé. Par
conséquent, si vous écrivez:

double solde [] = { 1000,0 , 2,0 , 3,4 , 17,0 , 50,0 };

Vous allez créer exactement le même tableau que vous l'avez fait dans l'exemple précédent.

solde [ 4 ] = 50,0 ;

L'instruction ci-dessus attribue au numéro d'élément 5e du tableau une valeur de 50,0. Le tableau avec le
4ème index sera le 5ème c'est-à-dire le dernier élément car tous les tableaux ont 0 comme index de leur
premier élément qui est également appelé index de base. Voici la représentation picturale du même tableau
que nous avons discuté ci-dessus:

Accès aux éléments de la baie


Un élément est accessible en indexant le nom du tableau. Cela se fait en plaçant l'index de l'élément entre
crochets après le nom du tableau. Par exemple:

double salaire = solde [ 9 ];

L'instruction ci-dessus prendra le 10e élément du tableau et attribuera la valeur à la variable de salaire. Voici
un exemple qui utilisera tous les trois concepts mentionnés ci-dessus à savoir. déclaration, affectation et
accès aux tableaux:

#include <stdio.h>

int main ()
{
int n [ 10 ]; / * n est un tableau de 10
entiers * / int i , j ;

/ * initialise les éléments du tableau n


à 0 * / for ( i = 0 ; i < 10 ; i ++)

POINT DE TUTORIEL
Apprentissage simple et simple Piste 70

{
n [ i ] = i + 100 ; / * définir l'élément à l'emplacement i sur i + 100 * /
}
/ * affiche la valeur de chaque
élément du tableau * / for ( j = 0 ; j
< 10 ; j ++)
{
printf ( "Élément [% d] =% d \ n" , j , n [ j ]);
}
return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Élément [0] = 100

Élément [1] = 101


Élément [2] = 102
Élément [3] = 103
Élément [4] = 104
Élément [5] = 105
Élément [6] = 106

Élément [7] = 107


Élément [8] = 108
Élément [9] = 109

Tableaux multidimensionnels
Le langage de programmation C autorise les tableaux multidimensionnels . Voici la forme générale d'une
déclaration de tableau multidimensionnel:

nom du type [ taille1 ] [ taille2 ] ... [ tailleN ];

Par exemple, la déclaration suivante crée un 5 en trois dimensions. dix . Tableau 4 entiers:

int threedim [ 5 ] [ 10 ] [ 4 ];

Deux dimensions Tableaux


La forme la plus simple du tableau multidimensionnel est le tableau à deux dimensions . Un tableau à deux
dimensions est, par essence, une liste de tableaux à une dimension . Pour déclarer un tableau d'entiers à
deux dimensions de taille x, y, vous écririez quelque chose comme suit:

type arrayName [ x ] [ y ];

POINT DE TUTORIEL
Apprentissage simple et simple Piste 71

Où type peut être n'importe quel type de données C valide et arrayName sera un identificateur C valide. Un
tableau à deux dimensions peut être considéré comme un tableau qui aura x nombre de lignes et y nombre
de colonnes. Un tableau à 2 dimensions a , qui contient trois lignes et quatre colonnes peut être affiché
comme ci-dessous:

Ainsi, chaque élément du tableau a est identifié par un nom d'élément de la forme a [i] [j], où a est le nom du
tableau, et i et j sont les indices qui identifient de manière unique chaque élément de a.
Initialisation deux dimensions Tableaux
Les tableaux multidimensionnels peuvent être initialisés en spécifiant des valeurs entre crochets pour
chaque ligne. Voici un tableau avec 3 lignes et chaque ligne a 4 colonnes.

int a [ 3 ] [ 4 ] = {
         
{ 0 , 1 , 2 , 3 }, / * initialiseurs pour la ligne indexée par 0 * /
{ 4 , 5 , 6 , 7 }, / * initialiseurs pour les lignes indexéespar1 * /
{ 8 , 9 , 10 , 11 } / * initialiseurs pour les lignes indexéespar2 * /
};          
           

Les accolades imbriquées, qui indiquent la ligne voulue, sont facultatives. L'initialisation suivante est
équivalente à l'exemple précédent:

int a [ 3 ] [ 4 ] = { 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 , 11 };

Accès à deux dimensions éléments Array


Un élément d' un tableau à 2 dimensions est accessible en utilisant les indices, c'est-à-dire l'index de ligne et
l'index de colonne du tableau. Par exemple:

int val = a [ 2 ] [ 3 ];

L'instruction ci-dessus prendra le 4ème élément de la 3ème ligne du tableau. Vous pouvez le vérifier dans le
diagramme ci-dessus. Vérifions ci-dessous le programme où nous avons utilisé une boucle imbriquée pour
gérer un tableau à deux dimensions:

#include <stdio.h>

int main ()
{
/ * un tableau avec 5 lignes et 2 colonnes * /

POINT DE TUTORIEL
Apprentissage simple et simple Psaumes 72

int a [ 5 ] [ 2 ] = {{ 0 , 0 }, { 1 , 2 }, { 2 ,
4 }, { 3 , 6 }, { 4 , 8 }}; int i , j ;
/ * affiche la valeur de chaque
élément du tableau * / for ( i = 0 ; i
< 5 ; i ++)
{
pour ( j = 0 ; j < 2 ; j ++)
{
printf ( "a [% d] [% d] =% d \ n" , i , j , a [ i ] [ j ]);
}
}
return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

a [0] [0]: 0
a [0] [1]: 0
a [1] [0]: 1
a [1] [1]: 2
a [2] [0]: 2
a [2] [1]: 4

a [3] [0]: 3
a [3] [1]: 6
a [4] [0]: 4

a [4] [1]: 8

Comme expliqué ci-dessus, vous pouvez avoir des tableaux avec n'importe quel nombre de dimensions,
bien qu'il soit probable que la plupart des tableaux que vous créez soient d'une ou deux dimensions.

Passer des tableaux en tant qu'arguments de


fonction
Si vous souhaitez passer un tableau à une seule dimension en tant qu'argument dans une fonction, vous
devrez déclarer le paramètre formel de la fonction de l'une des trois manières suivantes et les trois
méthodes de déclaration produisent des résultats similaires car chacune indique au compilateur qu'un
pointeur entier va être reçu. De la même manière, vous pouvez passer un tableau multidimensionnel en tant
que paramètres formels.

Voie-1
Paramètres formels comme pointeur comme suit. Vous étudierez ce qu'est le pointeur dans le prochain chapitre.

void myFunction ( int * param )


{
.
.
.

POINT DE TUTORIEL
Apprentissage simple et simple Piste 73

Voie-2
Paramètres formels sous forme de tableau dimensionné comme suit:

vide myFunction ( int param [ 10 ])


{
.
.
.
}

Voie - 3
Paramètres formels sous forme de tableau non dimensionné comme suit:

void myFunction ( int param [])


{
.
.
.
}

Exemple
Maintenant, considérons la fonction suivante, qui prendra un tableau comme argument avec un autre
argument et en fonction des arguments passés, elle retournera la moyenne des nombres passés à travers le
tableau comme suit:

double getAverage ( int arr [], int size )


{
int i ;
double moy
; double
somme ;

pour ( i = 0 ; i < taille ; ++ i )


{
somme + = arr [ i ];
}

avg = somme / taille ;

return avg ;
}

Maintenant, appelons la fonction ci-dessus comme suit:

#include <stdio.h>

/ * déclaration de fonction * /
double getAverage ( int arr [], int
size ); int main ()

POINT DE TUTORIEL
Apprentissage simple et simple Piste 74

{
/ * un tableau int avec 5 éléments * /
solde int [ 5 ] = { 1000 , 2 , 3 , 17
, 50 }; double moy ;

/ * passe le pointeur vers le tableau comme


argument * / avg = getAverage ( balance , 5
);

/ * affiche la valeur renvoyée * /


printf ( "La valeur moyenne est:% f" , avg );

return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

La valeur moyenne est: 214.400000

Comme vous pouvez le voir, la longueur du tableau n'a pas d'importance en ce qui concerne la fonction car
C n'effectue aucune vérification de limites pour les paramètres formels.

Retourne le tableau de la fonction


Le langage de programmation C ne permet pas de renvoyer un tableau entier en argument d'une fonction.
Cependant, vous pouvez renvoyer un pointeur vers un tableau en spécifiant le nom du tableau sans index.
Vous étudierez le pointeur dans le chapitre suivant afin de pouvoir sauter ce chapitre jusqu'à ce que vous
compreniez le concept des pointeurs en C.

Si vous souhaitez renvoyer un tableau à une seule dimension à partir d'une fonction, vous devez déclarer
une fonction renvoyant un pointeur comme dans l'exemple suivant:

int * maFonction ()
{
.
.
.
}
Le deuxième point à retenir est que C ne préconise pas de renvoyer l'adresse d'une variable locale à
l'extérieur de la fonction, vous devrez donc définir la variable locale comme variable statique .

Maintenant, considérez la fonction suivante qui générera 10 nombres aléatoires et les renverra à l'aide d'un
tableau et appelez cette fonction comme suit:

#include <stdio.h>
/ * fonction pour générer et renvoyer des nombres
aléatoires * / int * getRandom ()
{
statique int r [
10 ]; int i ;

POINT DE TUTORIEL
Apprentissage simple et simple Piste 75

/ * définir la graine * /
srand (( non signé ) temps (
NULL )); pour ( i = 0 ; i < 10
; ++ i )
{
r [ i ] = rand ();
printf ( "r [% d] =% d \ n" , i , r [ i ]);

}
return r ;
}
/ * fonction principale à appeler la fonction
définie ci-dessus * / int main ()
{
/ * un pointeur vers un
int * / int * p ;
int i ;
p = getRandom ();
pour ( i = 0 ; i < 10 ; i ++)
{
printf ( "* (p +% d):% d \ n" , i , * ( p + i ));
}

return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit un résultat comme suit:

r [ 0 ] = 313959809
r [ 1 ] = 1759055877
r [ 2 ] = 1113101911
r [ 3 ] = 2133832223
r [ 4 ] = 2073354073
r [ 5 ] = 167288147
r [ 6 ] = 1827471542
r [ 7 ] = 834791014
r [ 8 ] = 1901409888
r [ 9 ] = 1990469526
* ( p + 0 ): 313959809
* ( p + 1 ): 1759055877
* ( p + 2 ): 1113101911
* ( p + 3 ): 2133832223
* ( p + 4 ): 2073354073
* ( p + 5 ): 167288147
* ( p + 6 ): 1827471542
* ( p + 7 ): 834791014
* ( p + 8 ): 1901409888
* ( p + 9 ): 1990469526
POINT DE TUTORIEL
Apprentissage simple et simple Psaumes 76

Pointeur vers un tableau


Il est fort probable que vous ne comprendrez pas ce chapitre avant d'avoir parcouru le chapitre relatif aux
pointeurs en C.

Donc, en supposant que vous compreniez un peu les pointeurs en langage de programmation C,
commençons: Un nom de tableau est un pointeur constant vers le premier élément du tableau. Par
conséquent, dans la déclaration:

double balance [ 50 ];

balance est un pointeur vers & balance [0], qui est l'adresse du premier élément de la balance du tableau.
Ainsi, le fragment de programme suivant attribue à p l'adresse du premier élément de balance:

double * p ;
double balance [ 10 ];

p = équilibre ;

Il est légal d'utiliser des noms de tableaux comme pointeurs constants, et vice versa. Par conséquent, * (solde +
4) est un moyen légitime d'accéder aux données à l'équilibre [4].

Une fois que vous avez stocké l'adresse du premier élément dans p, vous pouvez accéder aux éléments du
tableau en utilisant * p, * (p + 1), * (p + 2) et ainsi de suite. Voici l'exemple pour montrer tous les concepts
discutés ci-dessus:

#include <stdio.h>

int main ()
{
/ * un tableau avec 5 éléments * /
double solde [ 5 ] = { 1000,0 , 2,0 , 3,4 , 17,0 ,
50,0 }; double * p ;
int i ;

p = équilibre ;
/ * affiche la valeur de chaque élément
du tableau * / printf ( "Array values
using pointer \ n" ); pour ( i = 0 ; i
< 5 ; i ++)
{
printf ( "* (p +% d):% f \ n" , i , * ( p + i ));
}
printf ( "Valeurs du tableau utilisant la balance
comme adresse \ n" ); pour ( i = 0 ; i < 5 ; i ++)
{
printf ( "* (solde +% d):% f \ n" , i , * ( solde + i ));
}

return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

POINT DE TUTORIEL  
Apprentissage simple et simple Piste 77
Valeurs de tableau
utilisant le pointeur *
(p + 0): 1000,000000 * (p
+ 1): 2.000000

* (p + 2): 3 400 000


* (p + 3): 17,000000
* (p + 4): 50,000000

Valeurs du tableau utilisant le

solde comme adresse * (solde + 0):


1000,000000 * (solde + 1): 2,000000

* (solde + 2): 3,400000 * (solde +


3): 17,000000 * (solde + 4):

50,000000

Dans l'exemple ci-dessus, p est un pointeur vers double, ce qui signifie qu'il peut stocker l'adresse d'une
variable de type double. Une fois que nous avons l'adresse dans p , alors * p nous donnera la valeur
disponible à l'adresse stockée dans p, comme nous l'avons montré dans l'exemple ci-dessus.

POINT DE TUTORIEL
Apprentissage simple et simple Piste 78

CHAPITRE

15
Pointeurs C

Les
effectuées
pointeurs en C sont faciles et amusants à apprendre. Certaines tâches de programmation C sont

plus facilement avec des pointeurs, et d'autres tâches, telles que l'allocation de mémoire dynamique, ne
peuvent pas être effectuées sans l'utilisation de pointeurs. Il devient donc nécessaire d'apprendre les
pointeurs pour devenir un programmeur C parfait. Commençons à les apprendre par étapes simples et
faciles.

Comme vous le savez, chaque variable est une emplacement et chaque emplacement mémoire a
adresse mémoire définie qui peut être accédée en son opérateur esperluette (&) , qui désigne un
utilisant l'adresse en mémoire.

Prenons l'exemple suivant, qui affichera l'adresse des variables définies:

#include <stdio.h>

int main ()
{
int var1 ;
char var2 [
10 ];
printf ( "Adresse de la variable var1:% x \ n" , & var1 );
printf ( "Adresse de la variable var2:% x \ n" , & var2 );

return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit un résultat comme suit:

Adresse de la variable var1: bff5a400

Adresse de la variable var2: bff5a3f6

Vous avez donc compris ce qu'est l'adresse mémoire et comment y accéder, donc la base du concept est
terminée. Voyons maintenant ce qu'est un pointeur.

POINT DE TUTORIEL
Apprentissage simple et simple Piste 79

Que sont les pointeurs?


Un pointeur est une variable dont la valeur est l'adresse d'une autre variable, c'est-à-dire l'adresse directe de
l'emplacement mémoire. Comme toute variable ou constante, vous devez déclarer un pointeur avant de
pouvoir l'utiliser pour stocker une adresse de variable. La forme générale d'une déclaration de variable de
pointeur est:

type * var - nom ;

Ici, type est le type de base du pointeur; il doit s'agir d'un type de données C valide et var-name est le nom de
la variable de pointeur. L'astérisque * que vous avez utilisé pour déclarer un pointeur est le même astérisque
que vous utilisez pour la multiplication. Cependant, dans cette instruction, l'astérisque est utilisé pour
désigner une variable comme pointeur. Voici la déclaration de pointeur valide:

int * ip ; / * pointeur vers un entier * /


double * dp ; / * pointeur vers un double * /
flotte * fp ; / * pointeurà un flotteur * /
carboniser* ch / * pointeurà un personnage */
         

Le type de données réel de la valeur de tous les pointeurs, qu'il soit entier, flottant, caractère ou autre, est le
même, un long nombre hexadécimal qui représente une adresse mémoire. La seule différence entre les
pointeurs de différents types de données est le type de données de la variable ou de la constante vers
laquelle pointe le pointeur.

Comment utiliser les pointeurs?


Il y a peu d'opérations importantes, que nous ferons très fréquemment à l'aide de pointeurs. (a) nous
définissons une variable pointeur (b) affectons l'adresse d'une variable à un pointeur et (c) accédons enfin à
la valeur à l'adresse disponible dans la variable pointeur. Cela se fait en utilisant l'opérateur unaire * qui
renvoie la valeur de la variable située à l'adresse spécifiée par son opérande. L'exemple suivant utilise ces
opérations:

#include <stdio.h>

int main ()
{
intvar = 20 ;/ * déclaration de variable réelle * /
int* ip ; / * déclaration de variable de pointeur * /

ip = & var ; / * stocker l'adresse de var dans la variable pointeur * /

printf ( "Adresse de la variable var:% x \ n" , & var );

/ * adresse stockée dans la variable pointeur * /


printf ( "Adresse stockée dans la variable ip:% x \ n" , ip );

/ * accéder à la valeur en utilisant le


pointeur * / printf ( "Valeur de * variable
ip:% d \ n" , * ip );
return 0 ;
}

POINT DE TUTORIEL
Apprentissage simple et simple Piste 80

Lorsque le code ci-dessus est compilé et exécuté, il produit un résultat comme suit:

Adresse de la variable var: bffd8b3c


Adresse stockée dans la variable ip: bffd8b3c
Valeur de * variable ip: 20

Pointeurs NULL en C
Il est toujours recommandé d'attribuer une valeur NULL à une variable de pointeur au cas où vous n'auriez
pas d'adresse exacte à attribuer. Cela se fait au moment de la déclaration des variables. Un pointeur qui est
affecté NULL est appelé un pointeur null .

Le pointeur NULL est une constante avec une valeur de zéro définie dans plusieurs bibliothèques standard.
Considérez le programme suivant:

#include <stdio.h>

int main ()
{
int * ptr = NULL ;

printf ( "La valeur de ptr est:% x \ n" , & ptr );

return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

La valeur de ptr est 0

Sur la plupart des systèmes d'exploitation, les programmes ne sont pas autorisés à accéder à la mémoire à
l'adresse 0 car cette mémoire est réservée par le système d'exploitation. Cependant, l'adresse mémoire 0 a
une signification particulière; il signale que le pointeur n'est pas destiné à pointer vers un emplacement
mémoire accessible. Mais par convention, si un pointeur contient la valeur nulle (zéro), il est supposé ne
pointer vers rien.

Pour rechercher un pointeur nul, vous pouvez utiliser une instruction if comme suit:

si ( ptr ) / * réussit si p estnon nul * /


si (! ptr ) / * réussit si p estnul */
             

Arithmétique du pointeur
Comme expliqué dans le chapitre principal, le pointeur C est une adresse, qui est une valeur numérique. Par
conséquent, vous pouvez effectuer des opérations arithmétiques sur un pointeur de la même manière
qu'une valeur numérique. Il existe quatre opérateurs arithmétiques qui peuvent être utilisés sur les
pointeurs: ++, -, + et -

Pour comprendre l'arithmétique du pointeur, considérons que ptr est un pointeur entier qui pointe vers
l'adresse 1000. En supposant des entiers 32 bits , effectuons l'opération arithmétique suivante sur le
pointeur:

POINT DE TUTORIEL
Apprentissage simple et simple Piste 81

ptr ++

Maintenant, après l'opération ci-dessus, le ptr pointera vers l'emplacement 1004 car chaque fois que ptr est
incrémenté, il pointera vers l'emplacement entier suivant qui est de 4 octets à côté de l'emplacement actuel.
Cette opération déplacera le pointeur vers l'emplacement de mémoire suivant sans affecter la valeur réelle à
l'emplacement de mémoire. Si ptr pointe sur un caractère dont l'adresse est 1000, l'opération ci-dessus
pointera vers l'emplacement 1001 car le caractère suivant sera disponible à 1001.

Incrémenter un pointeur
Nous préférons utiliser un pointeur dans notre programme au lieu d'un tableau car le pointeur de variable
peut être incrémenté, contrairement au nom du tableau qui ne peut pas être incrémenté car il s'agit d'un
pointeur constant. Le programme suivant incrémente le pointeur de variable pour accéder à chaque élément
suivant du tableau:

#include <stdio.h>

const int MAX = 3 ;

int main ()
{
int var [] = { 10 , 100 ,
200 }; int i , * ptr ;
/ * nous avons l'adresse du tableau dans
le pointeur * / ptr = var ;
pour ( i = 0 ; i < MAX ; i ++)
{
printf ( "Adresse de var [% d] =% x \ n" , i
, ptr ); printf ( "Valeur de var [% d] =% d
\ n" , i , * ptr );
/ * passer à l'emplacement
suivant * / ptr ++;
}
return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit un résultat comme suit:

Adresse de var [0] = bf882b30


Valeur de var [0] = 10

Adresse de var [1] = bf882b34


Valeur de var [1] = 100

Adresse de var [2] = bf882b38


Valeur de var [2] = 200

POINT DE TUTORIEL
Apprentissage simple et simple Psaumes 82

Décrémenter un pointeur
Les mêmes considérations s'appliquent à la décrémentation d'un pointeur, qui diminue sa valeur du nombre
d'octets de son type de données comme indiqué ci-dessous:

#include <stdio.h>

const int MAX = 3 ;

int main ()
{
int var [] = { 10 , 100 ,
200 }; int i , * ptr ;
/ * nous avons l'adresse du tableau dans
le pointeur * / ptr = & var [ MAX - 1 ];
pour ( i = MAX ; i > 0 ; i -)
{

printf ( "Adresse de var [% d] =% x \ n" , i


, ptr ); printf ( "Valeur de var [% d] =% d
\ n" , i , * ptr );
/ * déplacer vers l'emplacement
précédent * / ptr -;
}
return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit un résultat comme suit:

Adresse de var [3] = bfedbcd8

Valeur de var [3] = 200


Adresse de var [2] = bfedbcd4
Valeur de var [2] = 100

Adresse de var [1] = bfedbcd0


Valeur de var [1] = 10

Comparaisons de pointeurs
Les pointeurs peuvent être comparés à l'aide d'opérateurs relationnels, tels que ==, <et>. Si p1 et p2 pointent
vers des variables qui sont liées les unes aux autres, telles que des éléments du même tableau, alors p1 et
p2 peuvent être comparés de manière significative.

Le programme suivant modifie l'exemple précédent en incrémentant le pointeur de variable tant que
l'adresse vers laquelle il pointe est inférieure ou égale à l'adresse du dernier élément du tableau, qui est &
var [MAX - 1]:

#include <stdio.h>

POINT DE TUTORIEL
Apprentissage simple et simple Piste 83

const int MAX = 3 ;

int main ()
{
int var [] = { 10 , 100 ,
200 }; int i , * ptr ;
/ * nous avons l'adresse du premier élément du pointeur
* / ptr = var ;
i = 0 ;
while ( ptr <= & var [ MAX - 1 ])
{

printf ( "Adresse de var [% d] =% x \ n" , i


, ptr ); printf ( "Valeur de var [% d] =% d
\ n" , i , * ptr );
/ * pointe vers l'emplacement
précédent * / ptr ++;
i ++;
}
return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit un résultat comme suit:

Adresse de var [ 0 ] = bfdbcb20


Valeur de var [ 0 ] = 10
Adresse de var [ 1 ] = bfdbcb24
Valeur de var [ 1 ] = 100
Adresse de var [ 2 ] = bfdbcb28
Valeur de var [ 2 ] = 200

Tableau de pointeurs
Avant de comprendre le concept de tableaux de pointeurs , considérons l'exemple suivant, qui utilise un
tableau de 3 entiers:

#include <stdio.h>

const int MAX = 3 ;

int main ()
{
int var [] = { 10 , 100 ,
200 }; int i ;

pour ( i = 0 ; i < MAX ; i ++)


{
printf ( "Valeur de var [% d] =% d \ n" , i , var [ i ]);
}
return 0 ;
}

POINT DE TUTORIEL
Apprentissage simple et simple Psaumes 84

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Valeur de var [0] = 10

Valeur de var [1] = 100


Valeur de var [2] = 200

Il peut y avoir une situation où nous voulons maintenir un tableau, qui peut stocker des pointeurs vers un int
ou un char ou tout autre type de données disponible. Voici la déclaration d'un tableau de pointeurs vers un
entier:

int * ptr [ MAX ];

Cela déclare ptr comme un tableau de pointeurs entiers MAX. Ainsi, chaque élément de ptr contient
désormais un pointeur vers une valeur int. L'exemple suivant utilise trois entiers, qui seront stockés dans un
tableau de pointeurs comme suit:

#include <stdio.h>

const int MAX = 3 ;

int main ()
{
int var [] = { 10 , 100 ,
200 }; int i , * ptr [ MAX
];
pour ( i = 0 ; i < MAX ; i ++)
{
ptr [ i ] = & var [ i ]; / * attribue l'adresse d'un entier. * /
}
pour ( i = 0 ; i < MAX ; i ++)
{
printf ( "Valeur de var [% d] =% d \ n" , i , * ptr [ i ]);
}
return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Valeur de var [0] = 10

Valeur de var [1] = 100


Valeur de var [2] = 200

Vous pouvez également utiliser un tableau de pointeurs vers un caractère pour stocker une liste de chaînes comme suit:

#include <stdio.h>

const int MAX = 4 ;

int main ()
{
char * names [] = {

POINT DE TUTORIEL
Apprentissage simple et simple Piste 85

"Zara Ali" ,
«Hina Ali» ,
«Nuha Ali» ,
«Sara Ali» ,
};
int i = 0 ;

pour ( i = 0 ; i < MAX ; i ++)


{
printf ( "Valeur des noms [% d] =% s \ n" , i , noms [ i ]);
}
return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Valeur des noms [0] = Zara Ali

Valeur des noms [1] = Hina Ali


Valeur des noms [2] = Nuha Ali

Valeur des noms [3] = Sara Ali

Pointeur à pointeur
Un pointeur vers un pointeur est une forme d' indirection multiple ou une chaîne de pointeurs.
Normalement, un pointeur contient l'adresse d'une variable. Lorsque nous définissons un pointeur vers un
pointeur, le premier pointeur contient l'adresse du deuxième pointeur, qui pointe vers l'emplacement qui
contient la valeur réelle comme indiqué ci-dessous.

Une variable qui est un pointeur vers un pointeur doit être déclarée comme telle. Cela se fait en plaçant un
astérisque supplémentaire devant son nom. Par exemple, voici la déclaration pour déclarer un pointeur vers
un pointeur de type int:

int ** var ;

Lorsqu'une valeur cible est indirectement pointée par un pointeur vers un pointeur, l'accès à cette valeur
nécessite que l'opérateur astérisque soit appliqué deux fois, comme indiqué ci-dessous dans l'exemple:

#include <stdio.h>

int main ()
{
int var ;
int * ptr ;
int ** pptr
;

var = 3000 ;

POINT DE TUTORIEL
Apprentissage simple et simple Psaumes 86
/ * prend l'adresse de var *
/ ptr = & var ;

/ * prend l'adresse de ptr en utilisant l'adresse de


l'opérateur & * / pptr = & ptr ;
/ * prend la valeur en utilisant pptr * / printf (
"Valeur de var =% d \ n" , var ); printf ( "Valeur
disponible à * ptr =% d \ n" , * ptr ); printf (
"Valeur disponible à ** pptr =% d \ n" , ** pptr
);

return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Valeur de var = 3000


Valeur disponible à * ptr = 3000
Valeur disponible à ** pptr = 3000

Passer des pointeurs vers des fonctions


Le langage de programmation C vous permet de passer un pointeur vers une fonction. Pour ce faire,
déclarez simplement le paramètre de fonction en tant que type de pointeur.

À la suite d'un exemple simple où nous passons un pointeur long non signé à une fonction et modifions la
valeur à l'intérieur de la fonction qui se reflète dans la fonction appelante:

#include
<stdio.h>
#include <time.h>

void getSeconds ( unsigned long * par );

int main ()
{
non signé longue sec ;

getSeconds (& sec );


/ * affiche la valeur réelle * /
printf ( "Nombre de secondes:% ld \ n" , sec );

return 0 ;
}

void getSeconds ( unsigned long * par )


{
/ * obtenir le nombre actuel de
secondes * / * par = time ( NULL );
retour ;
}

POINT DE TUTORIEL
Apprentissage simple et simple Psaumes 87

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Nombre de secondes: 1294450468

La fonction, qui peut accepter un pointeur, peut également accepter un tableau comme indiqué dans
l'exemple suivant:
#include <stdio.h>

/ * déclaration de fonction * /
double getAverage ( int * arr , taille int );

int main ()
{
/ * un tableau int avec 5 éléments * /
solde int [ 5 ] = { 1000 , 2 , 3 , 17
, 50 }; double moy ;

/ * passe le pointeur vers le tableau comme


argument * / avg = getAverage ( balance , 5
);
/ * affiche la valeur renvoyée * /
printf ( "La valeur moyenne est:% f \ n" , avg );

return 0 ;
}

double getAverage ( int * arr , taille int )


{
int i , somme = 0 ;
doubleavg ;

pour ( i = 0 ; i < taille ; ++ i )


{
somme + = arr [ i ];
}

avg = ( double ) somme / taille ;

return avg ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

La valeur moyenne est: 214,40000

Renvoyer le pointeur des fonctions


Comme nous l'avons vu dans le dernier chapitre comment le langage de programmation C permet de
renvoyer un tableau à partir d'une fonction, de la même manière C vous permet de renvoyer un pointeur à
partir d'une fonction. Pour ce faire, vous devrez déclarer une fonction renvoyant un pointeur comme dans
l'exemple suivant:

int * maFonction ()
{

POINT DE TUTORIEL
Apprentissage simple et simple Psaumes 88

.
.
.
}

Le deuxième point à retenir est que ce n'est pas une bonne idée de renvoyer l'adresse d'une variable locale à
l'extérieur de la fonction, vous devrez donc définir la variable locale comme variable statique.

Maintenant, considérons la fonction suivante, qui générera 10 nombres aléatoires et les retournera en
utilisant un nom de tableau qui représente un pointeur, c'est-à-dire l'adresse du premier élément du tableau.

#include
<stdio.h>
#include <time.h>
/ * fonction pour générer et retrun des nombres
aléatoires. * / int * getRandom ()
{
statique int r [
10 ]; int i ;
/ * définir la graine * /
srand (( non signé ) temps (
NULL )); pour ( i = 0 ; i < 10
; ++ i )
{
r [ i ] = rand ();
printf ( "% d \ n" , r [ i ]);
}

return r ;
}
/ * fonction principale à appeler la fonction
définie ci-dessus * / int main ()
{
/ * un pointeur vers un
int * / int * p ;
int i ;

p = getRandom ();
pour ( i = 0 ; i < 10 ; i ++)
{
printf ( "* (p + [% d]):% d \ n" , i , * ( p + i ));
}

return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit un résultat comme suit:

1523198053
1187214107

1108300978
430494959

POINT DE TUTORIEL
Apprentissage simple et simple Psaumes 89

1421301276
930971084
123250484
106932140
1604461820
149169022

* (p + [0]): 1523198053
* (p + [1]): 1187214107
* (p + [2]): 1108300978
* (p + [3]): 430494959
* (p + [4]): 1421301276

* (p + [5]): 930971084
* (p + [6]): 123250484
* (p + [7]): 106932140
* (p + [8]): 1604461820
* (p + [9]): 149169022
POINT DE TUTORIEL
Apprentissage simple et simple Piste 90

CHAPITRE

16
Cordes C

La chaîne dans le langage de programmation C est en fait un tableau unidimensionnel de

caractères qui se terminent par un caractère nul '\ 0'. Ainsi, une chaîne terminée par un null contient les
caractères qui composent la chaîne suivis d'un null.

La déclaration et l'initialisation suivantes créent une chaîne composée du mot "Hello" . Pour contenir le
caractère nul à la fin du tableau, la taille du tableau de caractères contenant la chaîne est un de plus que le
nombre de caractères dans le mot «Bonjour» .

char salutation [ 6 ] = { 'H' , 'e' , 'l' , 'l' , 'o' , '\ 0' };

Si vous suivez la règle d'initialisation du tableau, vous pouvez écrire l'instruction ci-dessus comme suit:

char salutation [] = "Bonjour" ;

Voici la présentation de la mémoire de la chaîne définie ci-dessus en C / C ++:

En fait, vous ne placez pas le caractère nul à la fin d'une constante de chaîne. Le compilateur C place
automatiquement le '\ 0' à la fin de la chaîne lorsqu'il initialise le tableau. Essayons d'imprimer la chaîne
mentionnée ci-dessus:

#include <stdio.h>

int main ()
{
char salutation [ 6 ] = { 'H' , 'e' , 'l' , 'l' ,
'o' , '\ 0' }; printf ( "Message d'accueil:% s \
n" , message d' accueil );

return 0 ;
}

POINT DE TUTORIEL
Apprentissage simple et simple Piste 91
Lorsque le code ci-dessus est compilé et exécuté, il produit un résultat comme suit:

Message de bienvenue: Bonjour

C prend en charge un large éventail de fonctions qui manipulent des chaînes terminées par NULL :

SN Fonction et objectif

strcpy (s1, s2);


1
  Copie la chaîne s2 dans la chaîne s1.
strcat (s1, s2);
2
  Concatène la chaîne s2 à la fin de la chaîne s1.
strlen (s1);
3
  Renvoie la longueur de la chaîne s1.
strcmp (s1, s2);
4
  Renvoie 0 si s1 et s2 sont identiques; inférieur à 0 si s1 <s2; supérieur à 0 si s1> s2.

strchr (s1, ch);


5
  Renvoie un pointeur sur la première occurrence du caractère ch dans la chaîne s1.
strstr (s1, s2);
6
  Renvoie un pointeur vers la première occurrence de la chaîne s2 dans la chaîne s1.

L'exemple suivant utilise quelques-unes des fonctions mentionnées ci-dessus :

#include <stdio.h>
#include
<string.h>
int main ()
{
char str1 [ 12 ] =
"Bonjour" ; char str2 [
12 ] = "Monde" ; char
str3 [ 12 ];
int len ;
/ * copie str1 dans str3
* / strcpy ( str3 , str1
);
printf ( "strcpy (str3, str1):% s \ n" , str3 );
/ * concatène str1 et str2 * /
strcat ( str1 , str2 );
printf ( "strcat (str1, str2):% s \ n" , str1 );
/ * longueur totale de str1 après
concaténation * / len = strlen ( str1 );
printf ( "strlen (str1):% d \ n" , len );

return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit un résultat comme suit:

strcpy (str3, str1): Bonjour

POINT DE TUTORIEL
Apprentissage simple et simple Psaumes 92

strcat (str1, str2): HelloWorld


strlen (str1): 10

Vous pouvez trouver une liste complète des fonctions liées aux chaînes C dans la bibliothèque standard C.
POINT DE TUTORIEL
Apprentissage simple et simple Piste 93

CHAPITRE

17
Structures C

Les C tableaux

plusieurs éléments de données du même


vous permettent de définir le type de variables pouvant contenir

kind mais structure est un autre type de données défini par l'utilisateur disponible en programmation C, qui
vous permet de combiner des éléments de données de différents types.

Les structures sont utilisées pour représenter un enregistrement, supposons que vous souhaitiez garder
une trace de vos livres dans une bibliothèque. Vous souhaiterez peut-être suivre les attributs suivants pour
chaque livre:

∙ Titre

∙ Auteur

∙ Sujet

∙ ID du livre

Définition d'une structure


Pour définir une structure, vous devez utiliser l' instruction struct . L' instruction struct définit un nouveau
type de données, avec plus d'un membre pour votre programme. Le format de l' instruction struct est le
suivant:

struct [ balise de structure ]


{
définition du
membre ;
définition du
membre ;
...
définition du membre ;
} [ une ou plusieurs variables de structure ];

La balise de structure est facultative et chaque définition de membre est une définition de variable normale,
telle que int i; ou float f; ou toute autre définition de variable valide. A la fin de la définition de la structure,
avant le point-virgule final, vous pouvez spécifier une ou plusieurs variables de structure mais c'est
facultatif. Voici la façon dont vous déclareriez la structure Book:

livres struct
{

POINT DE TUTORIEL
Apprentissage simple et simple Épisode 94
omble titre [ 50
]; auteur char [
50 ]; sujet char [
100 ]; int book_id
;
} livre ;

Accès aux membres de la structure


Pour accéder à n'importe quel membre d'une structure, nous utilisons l'opérateur d'accès aux membres (.).
L'opérateur d'accès au membre est codé comme un point entre le nom de la variable de structure et le
membre de la structure auquel nous souhaitons accéder. Vous utiliseriez le mot - clé struct pour définir des
variables de type structure. Voici l'exemple pour expliquer l'utilisation de la structure:

#include <stdio.h>
#include <string.h>
livres struct
{
omble titre [ 50
]; auteur char [
50 ]; sujet char [
100 ]; int book_id
;
};
int main ()
{
struct Books Book1 ; / * Déclarer Book1 de type Book * /
struct Books Book2 ; / * Déclarer Book2 de type Book * /

/ * spécification du livre 1 * /
strcpy ( Book1 . title ,
"Programmation C" ); strcpy ( Book1 .
auteur , "Nuha Ali" );
strcpy ( sujet Book1 . , "Tutoriel de
programmation C" ); Livre1 . book_id = 6495407 ;

/ * spécification du livre 2 * /
strcpy ( Book2 . titre , "Telecom
facturation" ); strcpy ( Book2 . auteur
, "Zara Ali" );
strcpy ( sujet Book2 . , "Tutoriel de facturation
télécom" ); Livre2 . book_id = 6495700 ;

/ * imprimer les infos Book1 * /


printf ( "Livre 1 Titre:% s \ n" , Book1 . titre );
printf ( "Livre 1 auteur:% s \ n" , Book1 . auteur );
printf ( "Livre 1 Objet:% s \ n" , Book1 . sujet );
printf ( "Book 1 book_id:% d \ n" , Book1 . book_id );

/ * imprimer les infos Book2 * /


printf ( "Livre 2 Titre:% s \ n" , Book2 . titre );
printf ( "Livre 2 Auteur:% s \ n" , Book2 . auteur );
printf ( "Livre 2 Objet:% s \ n" , Book2 . sujet );
printf ( "Book 2 book_id:% d \ n" , Book2 . book_id );

return 0 ;
}

POINT DE TUTORIEL
Apprentissage simple et simple Psaumes 95

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Titre du livre 1: Programmation C


Auteur du livre 1: Nuha Ali
Sujet du livre 1: Tutoriel de programmation C
Livre 1 book_id: 6495407
Titre du livre 2: Facturation des télécommunications

Auteur du livre 2: Zara Ali


Sujet du livre 2: Tutoriel sur la facturation télécom
Livre 2 book_id: 6495700

Structures comme arguments de fonction


Vous pouvez transmettre une structure en tant qu'argument de fonction de manière très similaire à celle de
toute autre variable ou pointeur. Vous accéderiez aux variables de structure de la même manière que vous
avez accédé dans l'exemple ci-dessus:

#include <stdio.h>
#include <string.h>
livres struct
{
omble titre [ 50
]; auteur char [
50 ]; sujet char [
100 ]; int book_id
;
};

/ * déclaration de fonction * /
void printBook ( livre struct Books
); int main ()
{
struct Books Book1 ; / * Déclarer Book1 de type Book * /
struct Books Book2 ; / * Déclarer Book2 de type Book * /

/ * spécification du livre 1 * /
strcpy ( Book1 . title ,
"Programmation C" ); strcpy ( Book1 .
auteur , "Nuha Ali" );
strcpy ( sujet Book1 . , "Tutoriel de
programmation C" ); Livre1 . book_id = 6495407 ;

/ * spécification du livre 2 * /
strcpy ( Book2 . titre , "Telecom
facturation" ); strcpy ( Book2 . auteur
, "Zara Ali" );
strcpy ( sujet Book2 . , "Tutoriel de facturation
télécom" ); Livre2 . book_id = 6495700 ;
/ * imprimer les infos Book1 * /
printBook ( Book1 );

/ * Imprimer les infos Book2 * /

POINT DE TUTORIEL
Apprentissage simple et simple Psaumes 96

printBook ( Book2 );
return 0 ;
}
void printBook ( livre struct Books )
{
printf ( "Titre de l' ouvrage:% s \ n" , livre . titre );
printf ( "Auteur du livre:% s \ n" , livre . auteur );
printf ( "sujet du livre:% s \ n" , livre . sujet );
printf ( "Book book_id:% d \ n" , book . book_id );
}
Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Titre du livre: Programmation C


Auteur du livre: Nuha Ali

Sujet du livre: Tutoriel de programmation C


Réserver book_id: 6495407
Titre du livre: Telecom Billing
Auteur du livre: Zara Ali
Sujet du livre: Tutoriel sur la facturation télécom

Réserver book_id: 6495700

Pointeurs vers des structures


Vous pouvez définir des pointeurs vers des structures de la même manière que vous définissez le pointeur
vers toute autre variable comme suit:

struct Books * struct_pointer ;

Vous pouvez maintenant stocker l'adresse d'une variable de structure dans la variable de pointeur définie ci-
dessus. Pour trouver l'adresse d'une variable de structure, placez l'opérateur & avant le nom de la structure
comme suit:

struct_pointer = & Book1 ;

Pour accéder aux membres d'une structure à l'aide d'un pointeur vers cette structure , vous devez utiliser l'
opérateur -> comme suit:

struct_pointer -> titre ;

Réécrivons l' exemple ci - dessus en utilisant un pointeur de structure, espérons que cela vous sera facile de
comprendre le concept:

#include <stdio.h>

POINT DE TUTORIEL
Apprentissage simple et simple Épisode 97

#include <string.h>
livres struct
{
omble titre [ 50
]; auteur char [
50 ]; sujet char [
100 ]; int book_id
;
};

/ * déclaration de fonction * /
void printBook ( struct Books *
livre ); int main ()
{
struct Books Book1 ; / * Déclarer Book1 de type Book * /
struct Books Book2 ; / * Déclarer Book2 de type Book * /

/ * spécification du livre 1 * /
strcpy ( Book1 . title ,
"Programmation C" ); strcpy ( Book1 .
auteur , "Nuha Ali" );
strcpy ( sujet Book1 . , "Tutoriel de
programmation C" ); Livre1 . book_id = 6495407 ;

/ * spécification du livre 2 * /
strcpy ( Book2 . titre , "Telecom
facturation" ); strcpy ( Book2 . auteur
, "Zara Ali" );
strcpy ( sujet Book2 . , "Tutoriel de facturation
télécom" ); Livre2 . book_id = 6495700 ;

/ * imprimer les informations de Book1 en passant l'adresse de Book1 * /


printBook (& Book1 );

/ * imprimer les informations de Book2 en passant l'adresse de Book2 * /


printBook (& Book2 );

return 0 ;
}
void printBook ( struct Books * livre )
{
printf ( "Titre du livre:% s \ n" , livre -> titre );
printf ( "Auteur du livre:% s \ n" , livre -> auteur );
printf ( "Sujet du livre:% s \ n" , livre -> sujet );
printf ( "Book book_id:% d \ n" , book -> book_id );
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Titre du livre: Programmation C


Auteur du livre: Nuha Ali
Sujet du livre: Tutoriel de programmation C
Réserver book_id: 6495407
Titre du livre: Telecom Billing
Auteur du livre: Zara Ali

POINT DE TUTORIEL
Apprentissage simple et simple Psaumes 98

Sujet du livre: Tutoriel sur la facturation télécom


Réserver book_id: 6495700
POINT DE TUTORIEL
Apprentissage simple et simple Psaumes 99

CHAPITRE

18
Syndicats C

Une
données
union est un type de données spécial disponible en C qui vous permet de stocker différentes

types dans le même emplacement de mémoire. Vous pouvez définir une union avec plusieurs membres,
mais un seul membre peut contenir une valeur à un moment donné. Les unions fournissent un moyen
efficace d'utiliser le même emplacement de mémoire à des fins multiples.

Définir une union


Pour définir une union , vous devez utiliser l'instruction union de la même manière que vous l'avez fait lors
de la définition de la structure. L' instruction union définit un nouveau type de données, avec plus d'un
membre pour votre programme. Le format de la déclaration d'union est le suivant:

union [ balise union ]


{
définition du
membre ;
définition du
membre ;
...
définition du membre ;
} [ une ou plusieurs variables d' union ];

La balise union est facultative et chaque définition de membre est une définition de variable normale, telle
que int i; ou float f; ou toute autre définition de variable valide. À la fin de la définition de l'union, avant le
point - virgule final , vous pouvez spécifier une ou plusieurs variables d'union, mais c'est facultatif. Voici la
façon dont vous définiriez un type d'union nommé Data qui a les trois membres i, f et str:

Données syndicales
{
int i ; float
f ; char str
[ 20 ];
} données ;

Désormais, une variable de type Data peut stocker un entier, un nombre à virgule flottante ou une chaîne de
caractères. Cela signifie qu'une seule variable, c'est-à-dire le même emplacement mémoire, peut être
utilisée pour stocker plusieurs types de données. Vous pouvez utiliser n'importe quel type de données
intégré ou défini par l'utilisateur dans une union en fonction de vos besoins.

POINT DE TUTORIEL
Apprentissage simple et simple Piste 100
La mémoire occupée par un syndicat sera suffisamment grande pour contenir le plus grand membre du
syndicat. Par exemple, dans l'exemple ci-dessus, le type de données occupera 20 octets d'espace mémoire
car il s'agit de l'espace maximum pouvant être occupé par une chaîne de caractères. Voici l'exemple qui
affichera la taille totale de la mémoire occupée par l'union ci-dessus:

#include <stdio.h>
#include <string.h>
Données syndicales
{
int i ; float
f ; char str
[ 20 ];
};

int main ()
{
union de données de données ;

printf ( "Taille de la mémoire occupée par les données:% d \ n" , sizeof (


données ));

return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Taille de la mémoire occupée par les données: 20

Accès aux membres du syndicat


Pour accéder à n'importe quel membre d'un syndicat, nous utilisons l'opérateur d'accès aux membres (.) .
L'opérateur d'accès aux membres est codé comme un point entre le nom de la variable union et le membre
syndical auquel nous souhaitons accéder. Vous utiliseriez le mot-clé union pour définir des variables de type
union. Voici l'exemple pour expliquer l'utilisation de l'union:

#include <stdio.h>
#include <string.h>
Données syndicales
{
int i ; float
f ; char str
[ 20 ];
};

int main ()
{
union de données de données ;
données . i =
10 ; données .
f = 220,5 ;
strcpy ( data . str , "Programmation C" );

printf ( "data.i:% d \ n" , data . i );


printf ( "données.f:% f \ n" , données . f );

POINT DE TUTORIEL
Apprentissage simple et simple Épisode 101

printf ( "data.str:% s \ n" , data . str );

return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:


data.i: 1917853763
données.f: 4122360580327794860452759994368.000000
data.str: Programmation C

Ici, nous pouvons voir que les valeurs des membres i et f de l'union ont été corrompues car la valeur finale
affectée à la variable a occupé l'emplacement mémoire et c'est la raison pour laquelle la valeur si le membre
str est très bien affichée. Regardons maintenant à nouveau le même exemple où nous utiliserons une
variable à la fois, ce qui est le but principal d'avoir l'union:

#include <stdio.h>
#include <string.h>
Données syndicales
{
int i ; float
f ; char str
[ 20 ];
};

int main ()
{
union de données de données ;

données . i = 10 ;
printf ( "data.i:% d \ n" , data . i );

données . f = 220,5 ;
printf ( "données.f:% f \ n" , données . f );

strcpy ( data . str , "Programmation


C" ); printf ( "data.str:% s \ n" ,
data . str );

return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

données.i: 10
données.f: 220.500000
data.str: Programmation C

Ici, tous les membres sont très bien imprimés car un membre est utilisé à la fois.

POINT DE TUTORIEL
Apprentissage simple et simple Épisode 102

CHAPITRE

19
Champs de bits

S u ppose votre programme C contient un certain nombre de variables VRAI / FAUX regroupées dans un
structure appelée statut, comme suit:

struct
{
unsigned int widthValidated
; unsigned int
heightValidated ;
} statut ;

Cette structure nécessite 8 octets d'espace mémoire mais en réalité, nous allons stocker 0 ou 1 dans
chacune des variables. Le langage de programmation C offre une meilleure façon d'utiliser l'espace
mémoire dans une telle situation. Si vous utilisez de telles variables dans une structure, vous pouvez définir
la largeur d'une variable qui indique au compilateur C que vous n'utiliserez que ce nombre d'octets. Par
exemple, la structure ci-dessus peut être réécrite comme suit:

struct
{
unsigned int widthValidated : 1 ;
unsigned int heightValidated : 1 ;
} statut ;

Désormais, la structure ci-dessus nécessitera 4 octets d'espace mémoire pour la variable d'état, mais seuls
2 bits seront utilisés pour stocker les valeurs. Si vous utilisez jusqu'à 32 variables chacune avec une largeur
de 1 bit, alors la structure d'état utilisera également 4 octets, mais dès que vous aurez 33 variables, alors
elle allouera le prochain emplacement de la mémoire et elle commencera à utiliser 64 octets. Vérifions
l'exemple suivant pour comprendre le concept:

#include <stdio.h>
#include
<string.h>
/ * définir une structure
simple * / struct
{
unsigned int widthValidated
; unsigned int
heightValidated ;
} status1 ;

/ * définir une structure avec des champs de bits * /

POINT DE TUTORIEL
Apprentissage simple et simple Épisode 103

struct
{
unsigned int widthValidated : 1 ;
unsigned int heightValidated : 1 ;
} status2 ;

int main ()
{
printf ( "Taille de la mémoire occupée par status1:% d \ n" , sizeof ( status1
));
printf ( "Taille de la mémoire occupée par status2:% d \ n" , sizeof ( status2
));

return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Taille de la mémoire occupée par status1: 8


Taille de la mémoire occupée par status2: 4

Déclaration de champ de bits


La déclaration d'un champ de bits a la forme à l'intérieur d'une structure:

struct
{
type [ nom_membre ]: largeur ;
};

Ci-dessous la description des éléments variables d'un champ de bits:

         
 Éléments    La description  
         
         
     Un type entier qui détermine la façon dont la valeur du champ de bits est interprétée. Le type peut  
 type     
      
      être un int, un int signé, un int non signé.  
         
             
 nom de membre    Le nom du champ de bits.  
         
      
     Le nombre de bits dans le champ de bits. La largeur doit être inférieure ou égale au bit  
 largeur     
      largeur du type spécifié.  
         

Les variables définies avec une largeur prédéfinie sont appelées champs de bits. Un champ de bits peut
contenir plus d'un bit, par exemple si vous avez besoin d'une variable pour stocker une valeur de 0 à 7
uniquement, vous pouvez définir un champ de bits d'une largeur de 3 bits comme suit:

struct
{
âge int non signé : 3 ;
} Âge ;

La définition de structure ci-dessus indique au compilateur C que la variable age n'utilisera que 3 bits pour
stocker la valeur, si vous essayez d'utiliser plus de 3 bits, cela ne vous permettra pas de le faire. Essayons
l'exemple suivant:

POINT DE TUTORIEL
Apprentissage simple et simple Épisode 104

#include <stdio.h>
#include
<string.h>
struct
{
âge int non signé : 3 ;
} Âge ;

int main ()
{
L'âge . âge = 4 ;
printf ( "Sizeof (Age):% d \ n" , sizeof ( Age ));
printf ( "Age.age:% d \ n" , Age . age );

L'âge . âge = 7 ;
printf ( "Age.age:% d \ n" , Age . age );

L'âge . âge = 8 ;
printf ( "Age.age:% d \ n" , Age . age );

return 0 ;
}

Lorsque le code ci-dessus est compilé, il sera compilé avec un avertissement et lorsqu'il est exécuté, il
produit le résultat suivant:

Taille de (Âge): 4
Âge: 4 ans
Âge: 7 ans
Âge: 0
POINT DE TUTORIEL
Apprentissage simple et simple Épisode 105

CHAPITRE

20
Typedef

Le langage de programmation C fournit un mot-clé appelé typedef, que vous pouvez utiliser

pour donner un nouveau nom à un type. Voici un exemple pour définir un terme BYTE pour les nombres à
un octet :
typedef unsigned char BYTE ;

Après ces définitions de type, l'identifiant BYTE peut être utilisé comme abréviation pour le type unsigned
char, par exemple:

BYTE b1 , b2 ;

Par convention, des lettres majuscules sont utilisées pour ces définitions pour rappeler à l'utilisateur que le
nom du type est en réalité une abréviation symbolique, mais vous pouvez utiliser des minuscules, comme
suit:

typedef unsigned char byte ;

Vous pouvez également utiliser typedef pour donner un nom au type de données défini par l'utilisateur. Par
exemple, vous pouvez utiliser typedef avec structure pour définir un nouveau type de données, puis utiliser
ce type de données pour définir directement les variables de structure comme suit:

#include <stdio.h>
#include
<string.h>
typedef struct Livres
{
omble titre [ 50 ];
auteur char [ 50
]; sujet char [
100 ]; int book_id
;
} Livre ;
int main ()
{
Livre livre ;
strcpy ( livre . titre ,
"Programmation C" ); strcpy ( livre
. auteur , "Nuha Ali" );
strcpy ( livre . sujet , "C Programmation Tutorial" );

POINT DE TUTORIEL
Apprentissage simple et simple Épisode 106
livre . book_id = 6495407 ;

printf ( "Titre de l' ouvrage:% s \ n" , livre . titre );


printf ( "Auteur du livre:% s \ n" , livre . auteur );
printf ( "sujet du livre:% s \ n" , livre . sujet );
printf ( "Book book_id:% d \ n" , book . book_id );

return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Titre du livre: Programmation C


Auteur du livre: Nuha Ali
Sujet du livre: Tutoriel de programmation C

Réserver book_id: 6495407

typedef vs #define
La #define est une directive C qui est également utilisée pour définir les alias pour divers types de données
similaires à typedef mais avec trois différences:

∙ Le typedef est limité à donner des noms symboliques aux types uniquement où as
#define peut également être utilisé pour définir un alias pour les valeurs, comme vous
pouvez définir 1 comme ONE etc.

∙ L' interprétation typedef est effectuée par le compilateur alors que les instructions
#define sont traitées par le pré-processeur.

Voici une utilisation la plus simple de #define:

#include <stdio.h>

#define TRUE 1
#define FALSE
0
int main ()
{
printf ( "Valeur de TRUE:% d \ n" , TRUE );
printf ( "Valeur de FALSE:% d \ n" , FALSE );

return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Valeur de TRUE: 1
Valeur de FALSE: 0

POINT DE TUTORIEL
Apprentissage simple et simple Épisode 107

CHAPITRE

21
Entrée sortie

W poule nous disent que l' entrée des moyens pour alimenter des données dans le programme. Cela peut

être donné sous forme de fichier ou à partir de la ligne de commande. Langage de programmation C fournit
un ensemble de haut- fonctions de lecture d' entrée donné et alimenter au programme selon les besoins.

Lorsque nous disons Sortie, cela signifie afficher des données à l'écran, à l'imprimante ou dans n'importe
quel fichier. Langage de programmation C fournit un ensemble de intégré des fonctions de sortie des
données sur l'écran d'ordinateur et que vous pouvez enregistrer ces données dans des fichiers texte ou
binaires.

Les fichiers standard


Le langage de programmation C traite tous les appareils comme des fichiers. Ainsi, les périphériques tels
que l'affichage sont adressés de la même manière que les fichiers et les trois fichiers suivants sont
automatiquement ouverts lorsqu'un programme s'exécute pour donner accès au clavier et à l'écran.

     
Fichier standard Pointeur de fichier Dispositif
     
     
Entrée standard stdin Clavier
     
     
Sortie standard stdout Écran
     
     
Erreur standard stderr Votre écran
     

Les points de fichier sont les moyens d'accéder au fichier à des fins de lecture et d'écriture. Cette section
vous explique comment lire les valeurs à l'écran et comment imprimer le résultat à l'écran.

Les fonctions getchar () et putchar ()


La fonction int getchar (void) lit le prochain caractère disponible à l'écran et le renvoie sous forme d'entier.
Cette fonction ne lit qu'un seul caractère à la fois. Vous pouvez utiliser cette méthode dans la boucle au cas
où vous voudriez lire plus d'un caractère de l'écran.

La fonction int putchar (int c) place le caractère passé à l'écran et renvoie le même caractère. Cette fonction
ne met qu'un seul caractère à la fois. Vous pouvez utiliser cette méthode

POINT DE TUTORIEL
Apprentissage simple et simple Épisode 108

dans la boucle au cas où vous souhaiteriez afficher plus d'un caractère à l'écran. Vérifiez l'exemple suivant:

#include
<stdio.h> int
main ()
{
int c ;

printf ( "Entrez une valeur:" );


c = getchar ();

printf ( "\ nVous avez


entré:" ); putchar ( c );

return 0 ;
}
Lorsque le code ci-dessus est compilé et exécuté, il attend que vous saisissiez du texte lorsque vous entrez
un texte et appuyez sur Entrée, puis le programme se poursuit et ne lit qu'un seul caractère et l'affiche
comme suit:

$. / a.out
Entrez une valeur: c'est un test
Vous avez entré: t

Les fonctions gets () et put ()


La fonction char * gets (char * s) lit une ligne de stdin dans le tampon pointé par s jusqu'à ce qu'une
nouvelle ligne se termine ou EOF .

La fonction int met (const char * s) écrit la chaîne s et une nouvelle ligne de fin dans stdout .

#include
<stdio.h> int
main ()
{
char str [ 100 ];

printf ( "Entrez une


valeur:" ); str = obtient
( str );

printf ( "\ nVous avez


entré:" ); met ( str );

return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il attend que vous saisissiez du texte lorsque vous entrez
un texte et appuyez sur Entrée, puis le programme continue et lit la ligne complète jusqu'à la fin et l'affiche
comme suit:

$. / a.out
Entrez une valeur: c'est un test

POINT DE TUTORIEL
Apprentissage simple et simple Épisode 109

Vous avez entré: Ceci est un test

Les fonctions scanf () et printf ()


La fonction int scanf (const char * format, ...) lit l'entrée du flux d'entrée standard stdin et analyse cette
entrée selon le format fourni.

La fonction int printf (const char * format, ...) écrit la sortie dans le flux de sortie standard stdout et produit
la sortie selon un format fourni.

Le format peut être une simple chaîne constante, mais vous pouvez spécifier% s,% d,% c,% f, etc., pour
imprimer ou lire des chaînes, un entier, un caractère ou un flottant respectivement. Il existe de nombreuses
autres options de formatage disponibles qui peuvent être utilisées en fonction des besoins. Pour un détail
complet, vous pouvez vous référer à une page de manuel pour ces fonctions. Pour l'instant, procédons avec
un exemple simple qui clarifie les choses:

#include
<stdio.h> int
main ()
{
char str [
100 ]; int i
;
printf ( "Entrez une
valeur:" ); scanf ( "% s%
d" , chaîne , & i );

printf ( "\ nVous avez entré:% s,% d" , str , i );

return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il attend que vous saisissiez du texte lorsque vous entrez
un texte et appuyez sur Entrée, puis le programme continue et lit l'entrée et l'affiche comme suit:

$. / a.out
Entrez une valeur: sept 7
Vous avez entré: sept 7

Ici, il convient de noter que scanf () attend une entrée dans le même format que vous avez fourni% s et% d,
ce qui signifie que vous devez fournir une entrée valide comme "string integer", si vous fournissez "string
string" ou "integer integer "alors il sera considéré comme une mauvaise entrée. Deuxièmement, lors de la
lecture d'une chaîne, scanf () arrête la lecture dès qu'elle rencontre un espace donc "this is test" sont trois
chaînes pour scanf ().

POINT DE TUTORIEL
Apprentissage simple et simple Épisode 110

CHAPITRE

22
E / S de fichier

L ast chapitre expliqué à propos des dispositifs d'entrée et de sortie standards traités par C

langage de programmation. Dans ce chapitre, nous verrons comment les programmeurs C peuvent créer,
ouvrir, fermer des fichiers texte ou binaires pour leur stockage de données.

Un fichier représente une séquence d'octets, peu importe qu'il s'agisse d'un fichier texte ou d'un fichier
binaire. Le langage de programmation C permet d'accéder aux fonctions de haut niveau ainsi qu'aux appels
de bas niveau (niveau OS) pour gérer les fichiers sur vos périphériques de stockage. Ce chapitre vous
guidera à travers les appels importants pour la gestion des fichiers.

Ouverture de fichiers
Vous pouvez utiliser la fonction fopen () pour créer un nouveau fichier ou pour ouvrir un fichier existant, cet
appel initialisera un objet de type FILE, qui contient toutes les informations nécessaires pour contrôler le
flux. Voici le prototype de cet appel de fonction:
FILE * fopen ( const char * filename , const char * mode );

Ici, le nom de fichier est une chaîne littérale, que vous utiliserez pour nommer votre fichier et le mode
d'accès peut avoir l'une des valeurs suivantes:

   
Mode La description
   
   
r Ouvre un fichier texte existant à des fins de lecture.
   

w Ouvre un fichier texte pour l'écriture, s'il n'existe pas, un nouveau fichier est créé. Ici, votre
programme commencera à écrire du contenu depuis le début du fichier.
a Ouvre un fichier texte à écrire en mode ajout, s'il n'existe pas, un nouveau fichier est créé.
Ici, votre programme commencera à ajouter du contenu dans le contenu du fichier existant.
        
 r +  Ouvre un fichier texte pour lire et écrire les deux.  
       
     
   Ouvre un fichier texte pour lire et écrire les deux. Il tronque d'abord le fichier à une longueur nulle s'il existe  
  w +    
    sinon créez le fichier s'il n'existe pas.  
       
     
   Ouvre un fichier texte pour lire et écrire les deux. Il crée le fichier s'il n'existe pas. La lecture  
 un +    
    commencera depuis le début mais l'écriture ne peut être ajoutée.  
       

POINT DE TUTORIEL
Apprentissage simple et simple Épisode 111

Si vous comptez gérer des fichiers binaires, vous utiliserez les modes d'accès mentionnés ci-dessous au
lieu de ceux mentionnés ci-dessus:

"rb" , "wb" , "ab" , "rb +" , "r + b" , "wb +" , "w + b" , "ab +" , "a + b"

Fermer un fichier
Pour fermer un fichier, utilisez la fonction fclose (). Le prototype de cette fonction est:

int fclose ( FICHIER * fp );

La fonction fclose () renvoie zéro en cas de succès, ou EOF s'il y a une erreur lors de la fermeture du fichier.
Cette fonction vide en fait toutes les données encore en attente dans la mémoire tampon du fichier, ferme le
fichier et libère toute mémoire utilisée pour le fichier. L'EOF est une constante définie dans le fichier d'en-tête
stdio.h.

Il existe diverses fonctions fournies par la bibliothèque standard C pour lire et écrire un fichier caractère par
caractère ou sous la forme d'une chaîne de longueur fixe. Voyons quelques-uns des dans la section
suivante.

Ecrire un fichier
Voici la fonction la plus simple pour écrire des caractères individuels dans un flux:

int fputc ( int c , FICHIER * fp );

La fonction fputc () écrit la valeur de caractère de l'argument c dans le flux de sortie référencé par fp. Il
renvoie le caractère écrit écrit en cas de succès sinon EOF s'il y a une erreur. Vous pouvez utiliser les
fonctions suivantes pour écrire une chaîne terminée par null dans un flux:

int fputs ( const char * s , FILE * fp );

La fonction fputs () écrit la chaîne s dans le flux de sortie référencé par fp. Il renvoie une valeur non négative
en cas de succès, sinon EOF est renvoyé en cas d'erreur. Vous pouvez également utiliser la fonction int
fprintf (FILE * fp, const char * format, ...) pour écrire une chaîne dans un fichier. Essayez l'exemple suivant:

#include <stdio.h>
principal ()
{
FICHIER * fp ;

fp = fopen ( "/tmp/test.txt" , "w +" );


fprintf ( fp , "Ceci teste fprintf ... \ n" );
fputs ( "Ceci teste les fputs ... \ n" , fp );
fclose ( fp );
}

POINT DE TUTORIEL
Apprentissage simple et simple Épisode 112

Lorsque le code ci-dessus est compilé et exécuté, il crée un nouveau fichier test.txt dans le répertoire / tmp
et écrit deux lignes en utilisant deux fonctions différentes. Lisons ce fichier dans la section suivante.

Lire un fichier
Voici la fonction la plus simple pour lire un seul caractère à partir d'un fichier:

int fgetc ( FICHIER * fp );

La fonction fgetc () lit un caractère dans le fichier d'entrée référencé par fp. La valeur de retour est le
caractère lu, ou en cas d'erreur, elle renvoie EOF. Les fonctions suivantes vous permettent de lire une chaîne
à partir d'un flux:

char * fgets ( char * buf , int n , FILE * fp );

La fonction fgets () lit jusqu'à n - 1 caractères dans le flux d'entrée référencé par fp. Il copie la chaîne de
lecture dans le tampon buf, en ajoutant un caractère nul pour terminer la chaîne.

Si cette fonction rencontre un caractère de nouvelle ligne '\ n' ou la fin du fichier EOF avant qu'ils n'aient lu le
nombre maximum de caractères, alors elle ne renvoie que les caractères lus jusqu'à ce point, y compris le
caractère de nouvelle ligne. Vous pouvez également utiliser la fonction int fscanf (FILE * fp, const char *
format, ...) pour lire les chaînes d'un fichier, mais elle arrête la lecture après la rencontre du premier
caractère d'espace.

#include <stdio.h>
principal ()
{
FICHIER * fp ;
char buff [ 100 ];

fp = fopen ( "/tmp/test.txt" ,
"r" ); fscanf ( fp , "% s" ,
buff ); printf ( "1:% s \ n" ,
buff );

fgets ( buff , 255 , (


FICHIER *) fp ); printf (
"2:% s \ n" , buff );

fgets ( buff , 255 , (


FICHIER *) fp ); printf (
"3:% s \ n" , buff ); fclose
( fp );

Lorsque le code ci-dessus est compilé et exécuté, il lit le fichier créé dans la section précédente et produit le
résultat suivant:

1: ce
2: teste fprintf ...

POINT DE TUTORIEL
Apprentissage simple et simple Épisode 113

3: Il s'agit de tester les fputs ...

Voyons un peu plus en détail ce qui s'est passé ici. La première méthode fscanf () lit juste This parce
qu'après cela, elle a rencontré un espace, le deuxième appel est pour fgets () qui lit la ligne restante jusqu'à
ce qu'elle rencontre la fin de la ligne. Enfin, le dernier appel fgets () lit complètement la deuxième ligne.

Fonctions d'E / S binaires


Les deux fonctions suivantes peuvent être utilisées pour l'entrée et la sortie binaires:

size_t fread ( vide * ptr , size_t size_of_elements ,


size_t number_of_elements , FILE *
un_fichier );

size_t fwrite ( const vide * ptr , size_t


size_of_elements , size_t
number_of_elements , FILE * un_fichier );

Ces deux fonctions doivent être utilisées pour lire ou écrire des blocs de mémoires - généralement des
tableaux ou des structures.

POINT DE TUTORIEL
Apprentissage simple et simple Psaumes 114
CHAPITRE

23
Préprocesseurs

Le préprocesseur C ne fait pas partie du compilateur, mais constitue une étape distincte du

processus de compilation. En termes simplistes, un préprocesseur C n'est qu'un outil de substitution de


texte et il demande au compilateur d'effectuer le prétraitement requis avant la compilation réelle. Nous
appellerons le préprocesseur C le CPP.

Toutes les commandes du préprocesseur commencent par un symbole dièse (#). Ce doit être le premier
caractère non vide, et pour la lisibilité, une directive de préprocesseur doit commencer dans la première
colonne. La section suivante répertorie toutes les directives importantes du préprocesseur:

           
 Directif     La description  
         
           
 #définir     Remplace une macro de préprocesseur  
       
              
 #comprendre     Insère un en-tête particulier à partir d'un autre fichier  
       
              
 #undef     Annule la définition d'une macro de préprocesseur  
       
              
 #ifdef     Renvoie true si cette macro est définie  
       
              
 #ifndef     Renvoie true si cette macro n'est pas définie  
       
              
 #si     Teste si une condition de compilation est vraie  
       
           
 #autre     L'alternative pour #if  
       
              
 #elif     #else an #if dans une instruction  
       
              
 #fin si     Termine le préprocesseur conditionnel  
       
              
 #Erreur     Imprime un message d'erreur sur stderr  
       
              
 #pragma     Envoie des commandes spéciales au compilateur, en utilisant une méthode standardisée 
         

Exemples de préprocesseurs
Analysez les exemples suivants pour comprendre diverses directives.

#define MAX_ARRAY_LENGTH 20

POINT DE TUTORIEL
Apprentissage simple et simple Épisode 115

Cette directive indique au CPP de remplacer les instances de MAX_ARRAY_LENGTH par 20. Utilisez #define
pour les constantes afin d'augmenter la lisibilité.

#include <stdio.h>
#include
"myheader.h"

Ces directives indiquent au CPP d'obtenir stdio.h à partir des bibliothèques système et d'ajouter le texte au
fichier source actuel. La ligne suivante indique à CPP d'obtenir myheader.h à partir du répertoire local et
d'ajouter le contenu au fichier source actuel.

#undef FILE_SIZE
#define FILE_SIZE
42

Cela indique au CPP d'annuler la définition de FILE_SIZE existant et de le définir comme 42.

#ifndef MESSAGE
#define MESSAGE "Vous
souhaitez!" #fin si

Cela indique au CPP de définir MESSAGE uniquement si MESSAGE n'est pas déjà défini.

#ifdef DEBUG
/ * Vos instructions de débogage
ici * / #endif

Cela indique au CPP de faire le processus les instructions jointes si DEBUG est défini. Ceci est utile si vous
passez l' indicateur -DDEBUG au compilateur gcc au moment de la compilation. Cela définira DEBUG, vous
pouvez donc activer et désactiver le débogage à la volée pendant la compilation.

Macros prédéfinies
ANSI C définit un certain nombre de macros. Bien que chacun soit disponible pour votre utilisation en
programmation, les macros prédéfinies ne doivent pas être directement modifiées.

         
  Macro     La description  
         
       
  __DATE__     La date actuelle sous forme de littéral de caractères au format "MMM JJ AAAA"  
       
         
  __TEMPS__     L'heure actuelle sous forme de littéral de caractère au format "HH: MM: SS"  
       
         
  __FICHIER__     Celui-ci contient le nom de fichier actuel sous forme de chaîne littérale.  
       
       
  __LIGNE__     Celui-ci contient le numéro de ligne actuel sous forme de constante décimale.  
       
       
  __STDC__     Défini comme 1 lorsque le compilateur est conforme à la norme ANSI.  
         

Essayons l'exemple suivant:

#include <stdio.h>

principal ()

POINT DE TUTORIEL
Apprentissage simple et simple Épisode 116

{
printf ( "Fichier:% s \ n" ,
__FILE__ ); printf ( "Date:% s
\ n" , __DATE__ ); printf (
"Heure:% s \ n" , __TIME__ );
printf ( "Ligne:% d \ n" ,
__LINE__ ); printf ( "ANSI:% d
\ n" , __STDC__ );

Lorsque le code ci-dessus dans un fichier test.c est compilé et exécuté, il produit le résultat suivant:
Fichier: test.c
Date: 2 juin 2012
Heure: 03: 36: 24

Ligne: 8
ANSI: 1

Opérateurs de préprocesseur
Le préprocesseur C propose les opérateurs suivants pour vous aider à créer des macros:

Continuation macro (\)


Une macro doit généralement être contenue sur une seule ligne. L'opérateur de continuation de macro est
utilisé pour continuer une macro qui est trop longue pour une seule ligne. Par exemple:

#define message_for ( a , b ) \
printf ( #a "et" #b ": Nous vous aimons! \ n")

Stringize (#)
Le stringize ou numéro signe opérateur ( « # »), lorsqu'il est utilisé dans une définition de macro, convertit
un paramètre macro dans une constante de chaîne. Cet opérateur ne peut être utilisé que dans une macro
qui a un argument ou une liste de paramètres spécifié. Par exemple:

#include <stdio.h>

#define message_for ( a , b ) \
printf ( #a "et" #b ": Nous vous aimons! \ n")

int main ( void )


{
message_for ( Carole ,
Debra ); return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

POINT DE TUTORIEL  
Apprentissage simple et simple Épisode 117

Carole et Debra: Nous vous aimons!

Collage de jetons (##)


L' opérateur de collage de jetons (##) dans une définition de macro combine deux arguments. Il permet à
deux jetons distincts dans la définition de macro d'être joints en un seul jeton. Par exemple:

#include <stdio.h>

#define tokenpaster ( n ) printf ( "token" #n "=% d", token ## n)

int main ( void )


{
int token34 = 40
; tokenpaster (
34 );
return 0 ;
}
Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

jeton34 = 40

Comment cela s'est-il passé, car cet exemple entraîne la sortie réelle suivante du préprocesseur:

printf ( "token34 =% d" , token34 );

Cet exemple montre la concaténation du token ## n en token34 et ici nous avons utilisé à la fois stringize et
token- colling .

L'opérateur défini ()
L' opérateur défini par le préprocesseur est utilisé dans les expressions constantes pour déterminer si un
identificateur est défini à l'aide de #define . Si l'identificateur spécifié est défini, la valeur est true (non nulle).
Si le symbole n'est pas défini, la valeur est false (zéro). L' opérateur défini est spécifié comme suit:

#include <stdio.h>

#if! défini (MESSAGE)


#define MESSAGE "Vous
souhaitez!" #fin si

int main ( void )


{
printf ( "Voici le message:% s \ n" , MESSAGE );
return 0 ;
}

POINT DE TUTORIEL
Apprentissage simple et simple Épisode 118

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Voici le message: Vous souhaitez!

Macros paramétrées
L'une des fonctions puissantes du CPP est la possibilité de simuler des fonctions à l'aide de macros
paramétrées. Par exemple, nous pourrions avoir du code pour mettre un nombre au carré comme suit:

int carré ( int x ) {


retourne x * x ;
}

Nous pouvons réécrire le code ci-dessus en utilisant une macro comme suit:

#define square ( x ) (( x ) * ( x ))

Les macros avec des arguments doivent être définies à l'aide de la directive #define avant de pouvoir être
utilisées. La liste d'arguments est placée entre parenthèses et doit suivre immédiatement le nom de la
macro. Les espaces ne sont pas autorisés entre le nom de la macro et les parenthèses ouvertes. Par
exemple:

#include <stdio.h>

#define MAX ( x , y ) (( x )> ( y )? ( x ): ( y ))

int main ( void )


{
printf ( "Max entre 20 et 10 est% d \ n" , MAX ( 10
, 20 )); return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Max entre 20 et 10 est 20

POINT DE TUTORIEL
Apprentissage simple et simple Épisode 119

CHAPITRE

24
Fichiers d'en-tête

Un fichier d'en-tête est un fichier avec l'extension .h qui contient des déclarations de fonction C et

définitions de macro et à partager entre plusieurs fichiers source. Il existe deux types de fichiers d'en-tête:
les fichiers que le programmeur écrit et les fichiers fournis avec votre compilateur.

Vous demandez l'utilisation d'un fichier d'en-tête dans votre programme en l'incluant, avec la directive de
prétraitement C #include comme vous avez vu l'inclusion du fichier d'en-tête stdio.h . qui vient avec votre
compilateur.

Inclure un fichier d'en-tête équivaut à copier le contenu du fichier d'en-tête mais nous ne le faisons pas car il
sera très sujet aux erreurs et ce n'est pas une bonne idée de copier le contenu du fichier d'en-tête dans les
fichiers source, surtout si nous avons plusieurs fichiers source comprenant notre programme.

Une pratique simple dans les programmes C ou C ++ est que nous conservons toutes les constantes,
macros, variables globales du système et prototypes de fonctions dans des fichiers d'en-tête et incluons ce
fichier d'en-tête partout où cela est nécessaire.

Inclure la syntaxe
Les fichiers d'en-tête utilisateur et système sont inclus à l'aide de la directive de prétraitement #include. Il se
présente sous deux formes:

#include <fichier>
Ce formulaire est utilisé pour les fichiers d'en-tête système. Il recherche un fichier nommé file dans une liste
standard de répertoires système. Vous pouvez ajouter des répertoires à cette liste avec l' option -I lors de la
compilation de votre code source.

#include "fichier"

Ce formulaire est utilisé pour les fichiers d'en-tête de votre propre programme. Il recherche un fichier
nommé file dans le répertoire contenant le fichier courant. Vous pouvez ajouter des répertoires à cette liste
avec l' option -I lors de la compilation de votre code source.

POINT DE TUTORIEL
Apprentissage simple et simple Psaumes 120

Inclure l'opération
La directive #include fonctionne en demandant au préprocesseur C d'analyser le fichier spécifié en entrée
avant de continuer avec le reste du fichier source actuel. La sortie du préprocesseur contient la sortie déjà
générée, suivie de la sortie résultant du fichier inclus, suivie de la sortie issue du texte après la directive
#include . Par exemple, si vous avez un fichier d'en-tête header.h comme suit:

char * test ( void );

et un programme principal appelé program.c qui utilise le fichier d'en-tête, comme ceci:

int x ;
#include "header.h"

int main ( void )


{
met ( test ());
}

le compilateur verra le même flux de jetons que si program.c lisait

int x ;
char * test ( void );

int main ( void )


{
met ( test ());
}

En- têtes uniques


Si un fichier d'en-tête est inclus deux fois, le compilateur traitera son contenu deux fois et produira une
erreur. La manière standard d'éviter cela est de placer tout le contenu réel du fichier dans un conditionnel,
comme ceci:

#ifndef
HEADER_FILE
#define
HEADER_FILE

le fichier d'en-tête entier

#fin si

Cette construction est communément appelée wrapper #ifndef . Lorsque l'en-tête est à nouveau inclus, le
conditionnel sera faux, car HEADER_FILE est défini. Le préprocesseur ignorera tout le contenu du fichier et
le compilateur ne le verra pas deux fois.
POINT DE TUTORIEL
Apprentissage simple et simple Épisode 121

Comprend calculé
Parfois, il est nécessaire de sélectionner l'un des différents fichiers d'en-tête à inclure dans votre
programme. Ils peuvent spécifier des paramètres de configuration à utiliser sur différents types de
systèmes d'exploitation, par exemple. Vous pouvez le faire avec une série de conditions comme suit:

#if SYSTEM_1
# include
"system_1.h" #elif
SYSTEM_2
# include
"system_2.h" #elif
SYSTEM_3
...
#fin si

Mais à mesure qu'il grandit, cela devient fastidieux, au lieu de cela, le préprocesseur offre la possibilité
d'utiliser une macro pour le nom de l'en-tête. C'est ce qu'on appelle une inclusion calculée. Au lieu d'écrire un
nom d'en-tête comme argument direct de #include, vous mettez simplement un nom de macro à la place:

#define SYSTEM_H "system_1.h"


...
#include SYSTEM_H

SYSTEM_H sera développé et le préprocesseur recherchera system_1.h comme si le #include avait été écrit
de cette façon à l'origine. SYSTEM_H peut être défini par votre Makefile avec une option -D .

POINT DE TUTORIEL
Apprentissage simple et simple Épisode 122

CHAPITRE
25
Type Casting

T coulée ype est un moyen pour convertir une variable d'un type de données à un autre type de données.

Par exemple, si vous souhaitez stocker une valeur longue dans un entier simple, vous pouvez taper cast
long en int . Vous pouvez convertir les valeurs d'un type en un autre explicitement à l'aide de l' opérateur de
conversion comme suit:

( type_name ) expression

Prenons l'exemple suivant dans lequel l'opérateur de conversion entraîne la division d'une variable entière
par une autre en tant qu'opération à virgule flottante :

#include <stdio.h>

principal ()
{
somme int = 17 , compte
= 5 ; double moyenne ;
moyenne = ( double ) somme / compte ;
printf ( "Valeur de la moyenne:% f \ n" , moyenne );

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Valeur moyenne: 3.400000

Il convient de noter ici que l'opérateur de conversion a la priorité sur la division, de sorte que la valeur de
sum est d'abord convertie en type double et finalement elle est divisée par count, ce qui donne une valeur
double.

Les conversions de type peuvent être implicites, ce qui est effectué automatiquement par le compilateur, ou
elles peuvent être spécifiées explicitement via l'utilisation de l'opérateur de conversion. Il est considéré
comme une bonne pratique de programmation d'utiliser l'opérateur de conversion chaque fois que des
conversions de type sont nécessaires.

POINT DE TUTORIEL
Apprentissage simple et simple Épisode 123

Promotion d'entiers
La promotion Integer est le processus par lequel les valeurs de type entier "plus petit" que int ou unsigned
int sont converties en int ou unsigned int . Prenons un exemple d'ajout d'un caractère dans un int :
#include <stdio.h>

principal ()
{
int i = 17 ;
char c = 'c' ; / * la valeur ascii
est 99 * / int sum ;
somme = i + c ;
printf ( "Valeur de la somme:% d \ n" , somme );

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Valeur de la somme: 116

Ici, la valeur de la somme devient 116 parce que le compilateur fait la promotion d'entiers et convertit la
valeur de «c» en ascii avant d'effectuer l'opération d'addition réelle.

Conversion arithmétique habituelle


Les conversions arithmétiques habituelles sont implicitement effectuées pour convertir leurs valeurs dans
un type commun. Le compilateur effectue d'abord la promotion d'entiers, si les opérandes ont encore des
types différents, ils sont convertis au type qui apparaît le plus haut dans la hiérarchie suivante:

POINT DE TUTORIEL
Apprentissage simple et simple Épisode 124

Les conversions arithmétiques habituelles ne sont pas effectuées pour les opérateurs d'affectation, ni pour
les opérateurs logiques && et ||. Prenons l'exemple suivant pour comprendre le concept:

#include <stdio.h>
principal ()
{
int i = 17 ;
char c = 'c' ; / * la valeur ascii
est 99 * / somme flottante ;
somme = i + c ;
printf ( "Valeur de la somme:% f \ n" , somme );

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:


Valeur de la somme: 116.000000

Ici, il est simple de comprendre que le premier c est converti en entier, mais comme la valeur finale est
double, la conversion arithmétique habituelle s'applique et le compilateur convertit i et c en float et les
ajoute pour obtenir un résultat float.

POINT DE TUTORIEL
Apprentissage simple et simple Épisode 125

CHAPITRE

26
La gestion des erreurs

Une telle programmation C ne fournit pas de support direct pour la gestion des erreurs mais

étant un langage de programmation système, il vous permet d'accéder à un niveau inférieur sous la forme
de valeurs de retour. La plupart des appels de fonction C ou même Unix renvoient -1 ou NULL en cas d'erreur
et définit un code d'erreur errno est défini qui est une variable globale et indique une erreur survenue lors de
tout appel de fonction. Vous pouvez trouver divers codes d'erreur définis dans le fichier d'en-tête <error.h> .

Ainsi, un programmeur C peut vérifier les valeurs renvoyées et peut prendre les mesures appropriées en
fonction de la valeur de retour. Comme bonne pratique, le développeur doit définir errno sur 0 au moment de
l'initialisation du programme. Une valeur de 0 indique qu'il n'y a pas d'erreur dans le programme.
Les errno, perror () et strerror ()
Le langage de programmation C fournit les fonctions perror () et strerror () qui peuvent être utilisées pour
afficher le message texte associé à errno .

∙ La fonction perror () affiche la chaîne que vous lui passez, suivie d'un deux-points, d'un
espace, puis de la représentation textuelle de la valeur errno courante .

∙ La fonction strerror () , qui renvoie un pointeur vers la représentation textuelle de la


valeur errno courante.

Essayons de simuler une condition d'erreur et essayons d'ouvrir un fichier qui n'existe pas. Ici, j'utilise les
deux fonctions pour montrer l'utilisation, mais vous pouvez utiliser une ou plusieurs façons d'imprimer vos
erreurs. Le deuxième point important à noter est que vous devez utiliser le flux de fichiers stderr pour
générer toutes les erreurs.

#include <stdio.h>
#include <errno.h>
#include
<string.h>

extern int errno ;


int main ()
{
FILE * pf
; int
errnum ;

POINT DE TUTORIEL
Apprentissage simple et simple Épisode 126

pf = fopen ( "unexist.txt" ,
"rb" ); si ( pf == NULL )
{
errnum = errno ;
fprintf ( stderr , "Valeur de errno:% d \ n" ,
errno ); perror ( "Erreur imprimée par perror"
);
fprintf ( stderr , "Erreur lors de l'ouverture du fichier:% s \ n" ,
strerror ( errnum ));
}
autre
{
fclose ( pf );
}
return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Valeur de errno: 2
Erreur imprimée par perror: aucun fichier ou répertoire de ce type
Erreur lors de l'ouverture du fichier: aucun fichier ou répertoire de ce type

Diviser par zéro erreur


C'est un problème courant qu'au moment de diviser un nombre, les programmeurs ne vérifient pas si un
diviseur est égal à zéro et finalement cela crée une erreur d'exécution.

Le code ci-dessous corrige cela en vérifiant si le diviseur est égal à zéro avant de diviser:

#include <stdio.h>
#include
<stdlib.h>
principal ()
{
dividende int =
20 ; diviseur int
= 0 ; quotient
int ;

if ( diviseur == 0 ) {
fprintf ( stderr , "Division par zéro! Sortie ...
\ n" ); sortie (- 1 );
}
quotient = dividende / diviseur ;
fprintf ( stderr , "Valeur du quotient:% d \ n" , quotient );

sortie ( 0 );
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Division par zéro! Quitter ...

POINT DE TUTORIEL
Apprentissage simple et simple Épisode 127

État de sortie du programme


Il est courant de quitter avec la valeur EXIT_SUCCESS en cas de sortie de programmation après une
opération réussie. Ici, EXIT_SUCCESS est une macro et il est défini comme 0.

Si vous avez une condition d'erreur dans votre programme et que vous sortez, vous devez quitter avec un
statut EXIT_FAILURE qui est défini comme -1. Alors écrivons le programme ci-dessus comme suit:

#include <stdio.h>
#include
<stdlib.h>
principal ()
{
dividende int =
20 ; diviseur int
= 5 ; quotient
int ;

if ( diviseur == 0 ) {
fprintf ( stderr , "Division par zéro! Sortie ...
\ n" ); sortie ( EXIT_FAILURE );
}
quotient = dividende / diviseur ;
fprintf ( stderr , "Valeur du quotient:% d \ n" , quotient );

exit ( EXIT_SUCCESS );
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Valeur du quotient: 4
POINT DE TUTORIEL
Apprentissage simple et simple Épisode 128

CHAPITRE

27
Récursion

La r
en va de même pour
ecursion est le processus qui consiste à répéter des éléments d'une manière auto-similaire . Il

langages de programmation ainsi où si une programmation vous permet d'appeler une fonction à l'intérieur
de la même fonction qui est appelée appel récursif de la fonction comme suit.

récursivité vide ()
{
récursivité (); / * la fonction s'appelle elle-même * /
}

int main ()
{
récursivité ();
}

Le langage de programmation C prend en charge la récursivité, c'est-à-dire une fonction à appeler. Mais en
utilisant la récursivité, les programmeurs doivent faire attention à définir une condition de sortie de la
fonction, sinon elle ira en boucle infinie.

Les fonctions récursives sont très utiles pour résoudre de nombreux problèmes mathématiques comme le
calcul factoriel d'un nombre, la génération de séries de Fibonacci, etc.

Factorielle numérique
Voici un exemple qui calcule la factorielle pour un nombre donné à l'aide d'une fonction récursive:

#include <stdio.h>

int factoriel ( non signé int i )


{
si ( i <= 1 )
{
return 1 ;
}
retourne i * factorielle ( i - 1 );
}
int main ()

POINT DE TUTORIEL
Apprentissage simple et simple Épisode 129
{
int i = 15 ;
printf ( "Factorielle de% d est% d \ n" , i ,
factorielle ( i )); return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Factorielle de 15 est 2004310016

Série Fibonacci
Voici un autre exemple, qui génère une série de Fibonacci pour un nombre donné à l'aide d'une fonction
récursive:

#include <stdio.h>

int fibonaci ( int i )


{
si ( i == 0 )
{
return 0 ;
}
si ( i == 1 )
{
return 1 ;
}
retour fibonaci ( i - 1 ) + fibonaci ( i - 2 );
}
int main ()
{
int i ;
pour ( i = 0 ; i < 10 ; i ++)
{
printf ( "% d \ t% n" , fibonaci ( i ));
}
return 0 ;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

0 1 1 2 3 5 8 13 21 34
                   

POINT DE TUTORIEL
Apprentissage simple et simple Épisode 130

CHAPITRE

28
Arguments de variable

S o metimes, vous pouvez rencontrer une situation, quand vous voulez avoir une fonction,

qui peut prendre un nombre variable d'arguments, c'est-à-dire des paramètres, au lieu d'un nombre prédéfini
de paramètres. Le langage de programmation C fournit une solution à cette situation et vous êtes autorisé à
définir une fonction qui peut accepter un nombre variable de paramètres en fonction de vos besoins.
L'exemple suivant montre la définition d'une telle fonction.

int func ( int , ...)


{
.
.
.
}

int main ()
{
func ( 1 , 2 , 3
); func ( 1 , 2
, 3 , 4 );
}

Il est à noter que la fonction func () a le dernier argument comme ellipses c'est à dire trois points ( ... ) et
celui juste avant les ellipses est toujours un int qui représentera le nombre total d'arguments variables
passés. Pour utiliser une telle fonctionnalité, vous devez utiliser le fichier d'en-tête stdarg.h qui fournit des
fonctions et des macros pour implémenter la fonctionnalité des arguments variables et suivez les étapes
suivantes:

∙ Définissez une fonction avec le dernier paramètre comme des ellipses et celle juste
avant les ellipses est toujours un entier qui représentera le nombre d'arguments.
∙ Créez une variable de type va_list dans la définition de fonction. Ce type est défini dans
le fichier d'en-tête stdarg.h .
∙ Utilisez le paramètre int et la macro va_start pour initialiser la variable va_list à une liste
d'arguments. La macro va_start est définie dans le fichier d'en-tête stdarg.h.
∙ Utilisez la macro va_arg et la variable va_list pour accéder à chaque élément de la liste d'arguments.
∙ Utilisez une macro va_end pour nettoyer la mémoire affectée à la variable va_list .

Maintenant, suivons les étapes ci-dessus et écrivons une fonction simple qui peut prendre un nombre
variable de paramètres et renvoie leur moyenne:

#include <stdio.h>

POINT DE TUTORIEL
Apprentissage simple et simple Épisode 131

#include <stdarg.h>
moyenne double ( int num , ...)
{

va_list valist ;
double somme =
0,0 ; int i ;

/ * initialise valist pour num nombre d'arguments


* / va_start ( valist , num );
/ * accéder à tous les arguments assignés à
valist * / for ( i = 0 ; i < num ; i ++)
{
somme + = va_arg ( valist , int );
}
/ * mémoire propre réservée à valist
* / va_end ( valist );
return sum / num ;
}

int main ()
{
printf ( "Moyenne de 2, 3, 4, 5 =% f \ n" , moyenne ( 4 , 2
, 3 , 4 , 5 )); printf ( "Moyenne de 5, 10, 15 =% f \ n" ,
moyenne ( 3 , 5 , 10 , 15 ));
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant. Il est à noter que la fonction
average () a été appelée deux fois et à chaque fois le premier argument représente le nombre total
d'arguments de variable passés. Seules les ellipses seront utilisées pour passer un nombre variable
d'arguments.

Moyenne de 2, 3, 4, 5 = 3.500000

Moyenne de 5, 10, 15 = 10,000000

POINT DE TUTORIEL
Apprentissage simple et simple Épisode 132

CHAPITRE

29
Gestion de la mémoire

Ce chapitre expliquera la gestion dynamique de la mémoire en C. La programmation en C

language fournit plusieurs fonctions pour l'allocation et la gestion de la mémoire. Ces fonctions se trouvent
dans le fichier d'en-tête <stdlib.h>.

Fonction SN et description
void * calloc (int num, int size);
1 Cette fonction alloue un tableau de num éléments dont chacun de taille en octets seront de taille .

2 void free (void * address);


Cette fonction libère un bloc de bloc mémoire spécifié par adresse.
     
    void * malloc (int num);  
  3    
      Cette fonction alloue un tableau de num octets et les laisse initialisés.  
         
         
    void * realloc (void * adresse, int newsize);  
  4    
      Cette fonction réaffecte mémoire son extension jusqu'à NewSize .  
         

Allocation dynamique de la mémoire


Lors de la programmation, si vous connaissez la taille d'un tableau, c'est facile et vous pouvez le définir
comme un tableau. Par exemple pour stocker le nom de n'importe quelle personne, cela peut aller au
maximum
100 caractères pour que vous puissiez définir quelque chose comme suit:

carbonisation nom [ 100 ];

Mais considérons maintenant une situation où vous n'avez aucune idée de la longueur du texte que vous
devez stocker, par exemple vous souhaitez stocker une description détaillée d'un sujet. Ici, nous devons
définir un pointeur vers un caractère sans définir la quantité de mémoire requise et plus tard, en fonction
des besoins, nous pouvons allouer de la mémoire comme indiqué dans l'exemple ci-dessous:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main ()
{
carbonisation nom [ 100 ];

POINT DE TUTORIEL
Apprentissage simple et simple Épisode 133

char * description ;

strcpy ( nom , "Zara Ali" );


/ * allouer dynamiquement de la mémoire *
/ description = malloc ( 200 * sizeof (
char )); if ( description == NULL )
{
fprintf ( stderr , "Erreur - impossible d'allouer la
mémoire requise \ n" );
}
autre
{
strcpy ( description , "Zara ali un étudiant DPS en classe 10" );
}
printf ( "Nom =% s \ n" , nom );
printf ( "Description:% s \ n" , description );
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant.

Nom = Zara Ali


Description: Zara Ali, étudiante DPS en classe 10e

Le même programme peut être écrit en utilisant calloc (), la seule chose dont vous avez besoin pour
remplacer malloc par calloc comme suit:

calloc ( 200 , sizeof ( char ));


Ainsi, vous avez un contrôle total et vous pouvez passer n'importe quelle valeur de taille tout en allouant de
la mémoire contrairement aux tableaux où une fois que vous avez défini la taille ne peut pas être modifiée.

Redimensionner et libérer la mémoire


Lorsque votre programme sort, le système d'exploitation libère automatiquement toute la mémoire allouée
par votre programme, mais comme une bonne pratique lorsque vous n'avez plus besoin de mémoire, vous
devez libérer cette mémoire en appelant la fonction free ().

Vous pouvez également augmenter ou diminuer la taille d'un bloc de mémoire alloué en appelant la fonction
functionrealloc (). Vérifions à nouveau le programme ci-dessus et utilisons les fonctions realloc () et free ():

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main ()
{
carbonisation nom
[ 100 ]; char *
description ;

POINT DE TUTORIEL
Apprentissage simple et simple Épisode 134

strcpy ( nom , "Zara Ali" );


/ * allouer dynamiquement de la mémoire *
/ description = malloc ( 30 * sizeof (
char )); if ( description == NULL )
{
fprintf ( stderr , "Erreur - impossible d'allouer la
mémoire requise \ n" );
}
autre
{
strcpy ( description , "Zara ali un étudiant DPS." );
}
/ * supposons que vous souhaitiez stocker une
description plus grande * / description = realloc (
description , 100 * sizeof ( char )); if ( description
== NULL )
{
fprintf ( stderr , "Erreur - impossible d'allouer la
mémoire requise \ n" );
}
autre
{
strcat ( description , "Elle est en classe 10e" );
}

printf ( "Nom =% s \ n" , nom );


printf ( "Description:% s \ n" , description );
/ * libérer la mémoire en utilisant la
fonction free () * / free ( description
);
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant.

Nom = Zara Ali

Description: Zara Ali, étudiante en DPS, est en classe 10e


Vous pouvez par exemple ci - dessus , sans re-allocation fonction mémoire supplémentaire et strcat ()
donnera une erreur en raison du manque de mémoire disponible dans la description.

POINT DE TUTORIEL
Apprentissage simple et simple Épisode 135

CHAPITRE

30
Arguments de ligne de commande

Il est possible de transmettre certaines valeurs de la ligne de commande à vos programmes C lorsque

ils sont exécutés. Ces valeurs sont appelées arguments de ligne de commande et sont souvent importantes
pour votre programme, en particulier lorsque vous souhaitez contrôler votre programme de l'extérieur au
lieu de coder en dur ces valeurs à l'intérieur du code.

Les arguments de la ligne de commande sont traités à l'aide des arguments de la fonction main () où argc
fait référence au nombre d'arguments passés, et argv [] est un tableau de pointeurs qui pointe vers chaque
argument passé au programme. Voici un exemple simple qui vérifie s'il y a un argument fourni à partir de la
ligne de commande et prend les mesures nécessaires:

#include <stdio.h>

int main ( int argc , char * argv [])


{
si ( argc == 2 )
{
printf ( "L'argument fourni est% s \ n" , argv [ 1 ]);
}
sinon si ( argc > 2 )
{
printf ( "Trop d'arguments fournis. \ n" );
}
autre
{
printf ( "Un argument attendu. \ n" );
}
}

Lorsque le code ci-dessus est compilé et exécuté avec un seul argument, il produit le résultat suivant.
Test $. / a.out

L'argument fourni est testing

Lorsque le code ci-dessus est compilé et exécuté avec deux arguments, il produit le résultat suivant.

POINT DE TUTORIEL
Apprentissage simple et simple Épisode 136

$. / a.out test1 test2


Trop d'arguments fournis.

Lorsque le code ci-dessus est compilé et exécuté sans passer d'argument, il produit le résultat suivant.

$. / a.out
Un argument attendu

Il convient de noter que argv [0] contient le nom du programme lui-même et argv [1] est un pointeur vers le
premier argument de ligne de commande fourni, et * argv [n] est le dernier argument. Si aucun argument
n'est fourni, argc sera un, sinon et si vous passez un argument alors argc est mis à 2.

Vous passez tous les arguments de la ligne de commande séparés par un espace, mais si l'argument lui-
même a un espace, vous pouvez passer ces arguments en les mettant entre guillemets doubles "" ou
simples "". Réécrivons à nouveau l' exemple ci - dessus où nous allons imprimer le nom du programme et
nous passons également un argument de ligne de commande en mettant entre guillemets doubles:

#include <stdio.h>

int main ( int argc , char * argv [])


{
printf ( "Nom du programme% s \ n" , argv [ 0 ]);

si ( argc == 2 )
{
printf ( "L'argument fourni est% s \ n" , argv [ 1 ]);
}
sinon si ( argc > 2 )
{
printf ( "Trop d'arguments fournis. \ n" );
}
autre
{
printf ( "Un argument attendu. \ n" );
}
}

Lorsque le code ci-dessus est compilé et exécuté avec un seul argument séparé par un espace mais entre
des guillemets doubles, il produit le résultat suivant.

$. / a.out "test1 test2"

Nom du programme ./a.out


L'argument fourni est testing1 testing2

POINT DE TUTORIEL
Apprentissage simple et simple Épisode 137