Les bases de la programmation C ∞
programmation
Voici un de mes premiers tutorial du net. J'espère qu'il vous aidera dans votre apprentissage du C.
Histoire du C
Le langage C a été mis au point par D.Ritchie et B.W.Kernighan au début des années 70. Leur but était de permettre de développer un langage qui permettrait d'obtenir un système d'exploitation de type UNIX portable. D.Ritchie et B.W.Kernighan se sont inspirés des langages B et BCPL, pour créer un nouveau langage: le langage C. La première définition de ce langage a été donnée dans leur livre commun "The C programming language". Toutefois, suite à l'apparition de nombreux compilateurs C, l'ANSI (American National Standards Institute) a décidé de normaliser ce langage pour donner ce que l'on appelle le C-ANSI. Suite à cette norme, Ritchie et Kernighan ont sorti une deuxième édition du livre en intégrant les modifications apportées par l'ANSI. Le langage C reste un des langages les plus utilisés actuellement. Cela est dû au fait que ce langage non seulement comporte des instructions et des structures de haut niveau mais génére également un code très rapide grâce à des compilateurs très performant. Ces performances sont en réalité dues au fait que les instructions du langage sont proches du langage machine, ce qui se traduit par un programme compact (donc rapide) dans la mesure où le programmeur respecte une syntaxe proche des spécifications... Ainsi, les programmes en C sont très peu longs. En contrepartie le langage C reste un langage assez compliqué.
Les programmes
Qu'est-ce qu'un programme ? Un programme est tout simplement une suite d'instructions qui s'exécutent.
Ces instructions sont envoyées au microprocesseur, qui se charge de les traiter, et de dialoguer/piloter l'ensemble
de votre ordinateur. Comme il s'agit d'une communication avec le microprocesseur, il donc faut un
langage. Ce langage se nomme le langage machine fait de 0 et de 1 (binaire).
Pourquoi du binaire ? La simplicité même mais également la contrainte technologique.
Comme le microprocesseur est fait de composants électroniques, il ne circule que du courant.
Et donc par convention, faire passer du courant dans une certaine fourchette de volts (par exemple entre 3v et 4v)
équivaut à 1, en faire passer dans une autre fourchette (par exemple entre 1v et 2v) équivaut à 0.
Ainsi avec un assemblage de circuits électroniques et une convention pour communiquer avec lui, on peut
écrire des programmes à base de 0 et de 1. C'est bien mais ca reste encore un peu compliqué en vue d'une industrialisation
des développements. Afin de pouvoir contrôler plus facilement un microprocesseur, un jeu d'instructions
, nommé assembleur
a été créé. En voici un exemple :
L'assembleur est le langage naturel de l'ordinateur et sa maîtrise vous permettra de faire beaucoup de choses. L'écrivain Rudy Rucker, dont je vous invite à lire sa page Wikipédia, disait : "Le langage Assembleur, c'est vraiment simple, c'est comme de programmer en ADN !". Composé d'instructions basiques ce langage est très puissant, mais il rebute beaucoup de personnes car sa programmation est longue et complexe. Plus tard de nouveaux langages dis de "haut niveau" (c'est à dire plus proche du langage humain) font leur apparition : le Basic, le Fortran, l'Ada, le Cobol, le Pascal, le C... Mais comment fonctionnent tous ces langages ? Comment peut-on écrire un programme exécutable à partir d'un langage ? Réponse : avec un ensemble d'outils proche des systèmes d'exploitation que l'on nomme : compilateurs. Les compilateurs, prennent un fichier avec du code écrit dans un langage spécifique, et vont le transformer les fichiers texte en un exécutable. Comme ce tutoriel s'oriente vers le langage C, je vais prendre pour exemple les compilateurs C. Voici les étapes de la "compilation" d'un fichier C : Le compilateur prend le fichier C le compile en fichier OBJ : il le traduit en langage machine. Ce fichier en langage machine donc maintenant être prêt à être exécuté ? Pas tout à fait. Pour pouvoir être exécuté il faut transformer une nouvelle fois, ce binaire en un fichier lisible par le système d'exploitation. Je parle du format qu'on les fichiers EXE dans un système d'exploitation. Exemple, si je veux qu'il s'exécute sous Windows, il faut que je convertisse ce fichier OBJ dans le format EXE pour Windows. Cet étape s'appelle donc l'Édition de liens.
Expliquons maintenant les règles de programmations en C. Ce langage possède certains mot clé. Les mots clés sont des commandes déjà intégré au langage et par conséquent ils ne peuvent être qu'utilisé. Par exemple pour créé une nouvelle variable en C on procède comme suit :
Ceci déclare une nouvelle variable. Une variable est comme une sorte de boite d'une certaine taille dans
laquelle on va ranger une valeur. Si je parle de "taille" c'est parce que la mémoire d'un ordinateur à ses
limites et on ne peut pas créer n'importe quelle boite avec n'importe quelle taille. Ainsi l'unité de mesure
est l'octet. Il existe certains mots clés pour définir la taille et dans l'exemple précédent il s'agit du mot int
.
Une variable de type int
, signifie qu'elle fait partie du domaine des nombres entiers et qu'elle prend en mémoire
(dans la mémoire vive) 2 ou 4 octets (en fonction des compilateurs).
Le nom maVariable
correspond à l'intitulé que je donne à ma boite. Bien évidemment on ne peut pas donner
n'importe quel nom. Si par exemple j'écris en C ceci:
cela provoque une erreur. Pourquoi ? Parce que main
est un mot clé du langage C et ne peux donc être utilisé
ainsi (c'est à dire comme la définition d'une variable).
Le C différencie les majuscules des minuscules. Exemple:
La dernière commande est bien entendu fausse. Chaque ligne d'instructions en C fini par un ; afin d'indiquer d'indiquer au compilateur que la ligne est fini et qu'il faut passer à la suivante. Le texte qui suit et qui commence par "//" indique qu'il s'agit d'un commentaire.
Exemple avec le très classique : HELLO THE WORLD!
void main(void) { printf("Hello the World!\r\n"); }
Ce code source a pour but d'afficher le message: Hello the World!
. Je vais tout d'abord commenter la commande
void main(void)
.
Il s'agit en fait d'une déclaration d'une fonction. Une fonction exécute l'ensemble des instructions qu'elle contient. Ici cette fonction n'est pas n'importe laquelle, c'est le point d'entré du programme, c'est-à-dire que lorsque nous exécuterons notre programme (une fois compilé) il exécutera les instructions qui se trouveront en premier lieu dans cette fonction.
Vous pouvez remarquer que le symbole qui marque le début de ma fonction est {
et celui qui marque la fin est }
.
La déclaration de fonctions sera traitée dans le chapitre "Fondements du C". Ensuite dedans, on trouve un
mot bizarre printf
. Il s'agit en fait d'une fonction déjà existante dans le langage C ! En effet, dans
tous les langages on trouve des fonctions primitives et des opérateurs permettant d'effectuer toutes les
opérations possible de base. Ici la fonction printf
a la capacité d'afficher en message le 1er paramètre
que l'on va lui donner. Pour l'instant retenez que chaque fonction a cette syntaxe:
<nom_de_la_fonction>(param1, param2, ...)
.
Ici le 1er paramètre est : hello the world!
.
Ce 1er paramètre est une chaine de caractères. On le remarque notamment grâce aux guillemets " "
qui l'entoure.
Pour indiquez à C qu'une instruction est terminée et qu'il doit passer à l'instruction suivante,
on la termine par le caractère point-virgule ;
.
Enfin, tout en haut vous voyez l'instruction :
Il s'agit d'une commande dite commande préprocesseur. Elle indique tout simplement à C d'ouvrir le fichier
stdio.h
qui se trouve dans le dossier include
ou h
de votre compilateur. Ce fichier est en fait une
librairie qui contient des définitions de types, de fonctions, et beaucoup d'autres choses. On peut donc en déduire,
que stdio.h
nous permet d'utiliser la fonction printf
. Sans l'inclusion de ce fichier, le compilateur
ne trouverais pas la définition de la fonction printf
.
Toutes les fonctions de base sont définies dans des fichiers h
. Ainsi tout appel à une fonction de base,
nécessite d'indiquer à C où chercher sa définition. Les commandes préprocesseur seront traités dans le chapitre
"Préprocesseur".
Les commentaires
Qu'est-ce qu'un commentaire ? Il s'agit d'une ou plusieurs ligne où l'utilisateur pourra saisir tout ce qu'il
lui passe par la tête ! En bref, les commentaires, sont des messages en français qui vont vous aidez dans
votre tâche de programmeur. Lorsque vous créez des programmes qui font plus de 10 000 lignes de code,
insérer quelques commentaires par-ci, par-là dans le code vous permettra de bien comprendre ce que vous faites.
Comment écrire un commentaire ? En C il existe deux facons de déclarer des commentaires. Si votre commentaire
doit tenir sur 1 seule ligne, on utilisera alors : //
, sinon pour un commentaire sur
plusieurs ligne, on utilisera pour marquer le début : /*
, et pour marquer la fin : */
.
Voici un exemple :
// définition du point d'entrée void main(void) { printf("Hello the World!\r\n"); }
Le compilateur, lorsqu'il traite votre fichier C ignore ces commentaires, et s'occupe uniquement de votre code. Les commentaires servent énormement à tous bon programmeur, alors sachez en abuser, car c'est gratuit !!
Les types de données
Dans tous langages, lorsque vous programmez, vous devez manipuler des données, afin de traiter des informations. Toutes ces données, doivent être ranger dans des types de données codé sur ce que l'on appelle "Octet". Voici un schéma sur la codification d'un octet en mémoire : Un octet équivaut à 8 Bits (0 ou 1). Avec un octet on possède 256 façons de placer des 1 et des 0, on peut donc obtenir alors un nombre compris entre 0 et 255, soit 256 nombres possibles. Si on doit déclarer le type de donnée, c'est pour que C puisse réserver la mémoire dans une certaine taille, et sa forme de mémorisation. En C, il existe deux types de données : celles qui sont standard (prédéfinis) ou celle que les utilisateurs crée (définis).
En résumé, on trouve :
Type Entier (sans décimales)
- type char : défini un type entier occupant 1 octet en mémoire ;
- type short : défini un type entier occupant 2 octets en mémoire ;
- type int : défini un type entier occupant 2 ou 4 octets en mémoire ;
- type long : défini un type entier occupant 4 octets en mémoire.
Tous les types peuvent être déclarés soit signed (par défaut) soit alors unsigned. Dans le premier cas, la donnée est signée, c'est à dire que sa valeur peut être négative. Tandis que dans le deuxième cas, la valeur sera positive. On obtient donc le résultat suivant :
- type signed char : la valeur de cette donnée sera comprise entre -128 et 127 ;
- type signed short : la valeur de cette donnée sera comprise entre -32 768 et 32 767 ;
- type signed int : la valeur de cette donnée sera soit de type signed short, soit de type signed long ;
- type signed long : la valeur de cette donnée sera comprise entre -2 147 783 648 et 2 147 483 647 ;
- type unsigned char : la valeur de cette donnée sera comprise entre 0 et 255 ;
- type unsigned short : la valeur de cette donnée sera comprise entre 0 et 65535 ;
- type unsigned int : la valeur de cette donnée sera soit de type unsigned short, soit de type unsigned long ;
- type unsigned long : la valeur de cette donnée sera comprise entre 0 et 4 294 967 295.
Mais alors pourquoi selon que le type soit signée ou pas, la fourchette de nombre diffère pour un même type ??? On va prendre le type le plus simple: Le type char.
char occupe en mémoire un et un seul octet, et en binaire il n'existe pas de nombre négatif. Alors comment peut-on dire que le type signed char existe ? Le type signed, réserve simplement le 8ème bit pour dire si notre type est positif ou négatif. Si le 8ème bit vaut 1 alors notre nombre est négatif, sinon il est positif. Donc si on refais nos calculs pour connaitre le nombre de possibilités d'un type, le fait qu'on réserve tout le temps le 8ème bit pour le signe, alors il ne nous reste plus que 7 bits pour notre nombre ! Soit 27 = 128 possibilités. On obtient donc pour le type signed char (7 bits) : -128 à +127. Tandis qu'avec le type unsigned char (8 bits) : 0 à +255. C'est le même principe pour tous les autres type entiers.
En C, le type par défaut est signed (c'est à dire sans préciser si il est signed ou unsigned). Bien alors dans la 1ère partie nous avons pu voir de manière général le fonctionnement du C et son histoire. En résumé :
- le C est un langage de haut niveau procédural (il s'exécute ligne par ligne) ;
- pour terminer chaque instructions (autres que logiques) il faut saisir
;
; - le C fait la différence entre les minuscules et majuscules ;
- le point d'entrée de tout programme commence par (définition par défaut) :
void main(void)
; - dans Visual C++ par exemple les mots clés sont écris en BLEU. Ces mots clé font partie intégrante du noyau même de C ;
- on peut placer des commentaires dans le code afin de s'y réperer plus tard ;
- il existe 4 grand type d'entier (dans l'ordre du plus petit en place mémoire au plus grand) char, short, int et long. Toutefois on peut préciser si ils sont signé ou pas (si ils peuvent prendre des valeurs négative ou pas).
La génèse du compilateur
Un compilateur c'est quoi ? Il s'agit d'un ensemble de fichiers regroupant des exécutables et des librairies. Prenons l'exemple de Visual C++. Ouvrons son dossier d'installation, puis allons dans le dossier "VC98" (dossier ou est installé le compilateur VC++). Vous devriez avoir quelque chose comme l'écran suivant : Vous avez trois dossier spécifique au compilateur Visual C++ 6.0 et auxquels l'on ne va pas s'interesser il s'agit de : "ATL", "CRT" et "MFC" :
- le dossier BIN va regrouper tout les exécutables (les programmes) du compilateur, celui qui va compiler, celui qui va faire l'édition des liens et beaucoup d'autres. Son nom BIN est tiré de Binaire ;
- le dossier Include va regrouper tous les fichiers
h
(fichiers d'en-têtes) qui vont servir de déclarations des fonctions déjà existantes en C (par exemplemath.h
pour les fonctions mathématique) ; - le dossier
Lib
va regrouper tous les fichiers portant l'extension*.lib
(fichiers librairies) qui eux servent de fichier de définitions. Contrairement aux fichiersh
les fichierslib
, ne sont pas en texte clair. Ils contiennent toutes les définitions les fonctions elle même.
Prenons un exemple pour mieux comprendre : la fonction printf()
. Dans le fichier stdio.h
on trouvera :
Comme on peut le voir il s'agit juste d'une déclaration de la fonction printf()
on ne voit pas les détails
de cette fonction, c'est-à-dire les instructions saisies dedans pour obtenir l'affichage à l'écran.
En effet la définition de cette fonction se trouve dans un fichier lib
associé.
Laquelle ? Avec Visual C++ 6.0 je ne sais pas ! Le logique du C veut que pour un fichier h
un
fichier lib
équivalent porte le même nom. Cependant comme il s'agit des fichiers prédéfinis par le compilateur,
cette logique n'est pas vraiment respecté.
Les variables
Une variable est comme une boîte ou l'on range une certaine valeur. Cette boite possède un certain "format".
Comme on a pu le voir dans la 1ère partie. Ces formats sont en fait le type d'une variable.
Etant codé de 1 à 4 octects on peut y ranger une valeur plus ou moins importante. Par exemple, une variable de
type char non signé
(codé sur 8 bits avec aucun bit réservé pour le signe +/-) peut prendre une valeur de 0 à 255.
Si l'on souhaite ranger la valeur 257 dans cette variable cela ne marchera pas.
La syntaxe pour déclarer une variable est la suivante : <type_de_la_variable> nom_de_la_variable;
.
Cette déclaration est vrai pour toute les formes de déclaration d'une variables que ce soit comme ca en globale,
en locale dans une fonction ou encore en tant que paramètre. En ce qui concerne des types, j'en ai omis un
volontairement car beaucoup plus compliqué pour l'explication de son codage en mémoire : il s'agit du nombre réel
(avec décimal). Pour ranger des nombres à virgule dans une variable il faut utiliser les types :
float
,double
ou long double
selon le nombre de décimal que l'on souhaite.
double
étant plus précis et long double
encore plus précis. Toutefois c'est très rare que
l'on utilise le type double
et long double
(car lent). Exemple :
Pour attribuer une valeur à une variable il suffit de faire par exemple :
On peut attribuer une valeur par défaut à une variable lors de sa création :
Les opérations concernant les variables sont :
+
addition ;-
soustraction ;/
division ;%
modulo : reste d'une division ;*
multiplication.
Exemple :
myVar = myVar * 5 + 6 - 2; myVar = myVar + 1;
(Les ordres de priorités sont les mêmes qu'en mathématiques.) Il existe certains "raccourci" aussi pour effectuer plus rapidement des opérations. Vous allez comprendre :
On peut toutefois effectuer des opérations binaires sur les nombres à l'aide des commandes suivantes :
&
ET logique ;|
OU inclusif ;^
OU exclusif.
Les tableaux
Les tableaux sont identiques aux variables sauf qu'ils prennent plusieurs "cases" mémoire et permettent de ranger
plusieurs valeurs dans une même variables à l'aide d'un index
. Exemple :
Ici on a déclaré un tableau appelé monTablo
de 10 cases de type char
. C'est-à-dire que chaque case du
tableau prendra 1 octet mémoire. Pour accéder à une case donné il suffit de lui passer en index (entre crochet)
son numéro de case. ATTENTION ! La numérotation des cases se fait TOUJOURS à partir de 0 :
Les fonctions
Qu'est-ce qu'une fonction ? Une fonction est un ensemble d'instructions regroupé dans un sous programme nommé.
La facon la plus compréhensible par tous est sans aucun doute celle de faire l'analogie avec les maths !
En maths on décrit la fonction affine comme ceci : y = f(x) = ax+b
. Ici la fonction s'appelle F.
Cette fonction est un peu différente d'une fonction simple. En effet il s'agit d'une fonction paramétrable.
A quoi le voit-on ? Il s'agit du x
entre parenthèses. En passant dans x
une valeur quelconque
la fonction va effectuer un traitement. Ce traitement est : a * x + b
. a et b ne sont pas défini
mais on pourrait très bien l'imaginer. Une fois ce traitement fait que ce passe-t-il ?
Et bien F (notre fonction) va renvoyer le résultat de ce traitement, et c'est y qui va la recevoir.
Et donc on retombe sur ce que l'on nous a appris : f(x) = ax + b
, permet pour une valeur x
d'obtenir son
image y
. Il s'agit des coordonnées x, y
dans un plan cartésien. Alors les maths c'est beau,
mais ce n'est pas tout. Cet exemple nous permet de bien voir que la notion de "fonction" ne nous est pas inconnu.
Voici la syntaxe d'une fonction en C :
Il s'agit d'une fonction sans paramètres, et cette fonction ne renvoi aucune valeur. On appelle en général
ce type de fonction : une procédure. Une procédure est un simple sous programme pour faire des tâches
(en lui passant des paramètres ou pas) mais à la différence d'une fonction elle ne renvoie rien.
Alors on peut se demander à quoi ca sert d'écrire une procédure simple comme celle ci (sans paramètres) ?
Et bien imaginez que vous souhaitez afficher par exemple un message et qu'ensuite vous souhaitez attendre
que l'utilisateur presse une touche. Ceci prendra donc plusieurs lignes d'instructions.
Imaginez ensuite que vous souhaitez faire ce processus à plusieurs reprise dans votre programme
(dans void main(void)
). Vous allez réecrire toutes les lignes à chaque fois ? Non, le mieux c'est
d'écrire une fois ce traitement dans une simple procédure et ensuite de l'appeller à chaque fois que vous
en aurez besoin.
Détaillons à présent la syntaxe de la déclaration de cette procédure. Le premier mot que vous voyez est
void
. Ce mot clé correspond au type de de la valeur qui sera renvoyé par notre fonction
(cf. y = f(x)
). Comme il s'agit d'une simple procédure (qu'on ne veux rien renvoyer), on utilise
le mot clé : void
. Ce mot clé défini le type de valeur VIDE
. Si on aurez voulu renvoyer
une valeur de type entier codé sur 2 octets, il aurait fallu saisir :
Ensuite entre parenthèse c'est ici que l'on va définir les paramètres que l'on souhaite avoir pour notre fonction.
Ici on en veut pas, on a donc mis une nouvelle fois : void
. La syntaxe concernant les paramètres
est la suivante : <type> nom_de_la_variable1, <type> nom_de_la_variable2, ...
Pour exemple on peut écrire la fonction CARRE qui va calculer la valeur carré d'un nombre et la renvoyer :
Le mot clé return permet de renvoyer un résultat (du même type que la fonction) et de sortir de la fonction aussitôt.
Le Préprocesseur
Qu'est-ce que le préprocesseur ? Il s'agit de commandes bien spécifique qui vont s'exécuter avant la compilation
du code source. Je dirais même que la compilation se détermine en fonction justement des commandes préprocesseur.
Sans entrer pour l'instant dans les détails, je vous explique ici la commande préprocesseur la plus utilisé dans
la programmation C : #include
. Comme on l'a vu dans la 1ère partie, #include
va servir de
référence sur certaine fonctions déjà écrite en C. Par exemple la fonction printf()
qui écrit un message
texte à l'écran à besoin du fichier stdio.h
. Lorsqu'on appelle cette fonction dans notre programme,
le compilateur ne va pas savoir d'ou viens cette fonction printf()
. Rappellons que le compilateur
ne connait que les mots clé, la syntaxe général du C et les commandes préprocesseur. C'est pourquoi il faut alors
préciser dans quelle fichier se trouve ce que l'on appelle la "déclaration" de cette fonction. Pour printf()
,
celle-ci se trouve dans le fichier stdio.h
. Nous savons ou ce trouve les fichiers *.h
et nous savons
qu'en regardant dedans on va trouver la déclaration de la fonction printf()
. Donc voila la commande
à rajouter tout en haut de notre fichier pour utiliser la fonction printf()
:
Mais la commande #include ne s'arrête pas la. On peut voir que notre fichier *.h
se trouve entre
<
et >
et parfois dans notre programme on pourrait très bien écrire la syntaxe suivante :
#include "monfichier.h"
. Où est la différence ? La différence est que l'on met le nom du fichier
d'en-tête entre "
et "
lorsque ce fichier se trouve dans le même dossier du projet que l'on travaille,
et on met le nom du fichier d'en-têtes entre <
et >
lorsque ce fichier se trouve dans le dossier
par défaut du compilateur. Il existe une autre commande préprocesseur souvent utilisé,
il s'agit de la commande #define
. Cette commande est ce que l'on appelle une macro en général.
Elle permet entre autres de définir certains mots. Ces mots correpondront à une valeur.
Par exemple:
void affiche(void) { if (MAX_MESH == 60) printf("ok"); }
Ici on peut voir la définition d'un mot clé : MaxMesh qui à pour valeur 60. Cette commande est traité avant la compilation du code (car c'est une commande préprocesseur). Que va faire alors le compilateur ? Et bien c'est simple, il va remplacer tout les mots MaxMesh du code source par 60.
Donc dans notre exemple ca deviendra :
Les commandes préprocesseurs ne sont pas influencé par la casse (majuscules/minuscules), contrairement au reste du code.
Les conditions
Un programme c'est quoi ? C'est des instructions qui s'exécute... c'est des données que l'on manipule,
en résumé c'est beaucoup de choses. Tout ceci n'est pas fait sans ordre, mais avec une LOGIQUE.
Cette logique c'est à vous de la définir à l'aide de différentes opérations et de CONDITIONS.
La conditions la plus simple est sans aucun doutes le if
(traduction si). Si ceci alors cela... sinon si ceci
alors cela... sinon faire ceci... Voila comment se résume le if
. Le if
fonctionne selon
une table de vérité. Si ceci est vrai... alors tu fait ca... sinon tu fait ca... Comment cette table ce fait-elle ?
En comparant.
Exemple :
Examinons ce code. if (myVar == 3)
se lie : si myVar
est bien égale à 3. La comparaison myVar = 3
renvoi VRAI
si c'est vérifié et FAUX si il y a erreur. Si cette condition est vrai alors le programme va executer
ce qui suit ENTRE ACCOLADES. Ces accolades comme pour les fonctions définissent le début et la fin d'un bloc.
Le mot clé suivant : ELSE va traiter TOUS LES AUTRES CAS si la condition précédente est fausse.
C utilise une syntaxe particulière en ce qui concerne la comparaison, donc voici l'énumération :
var1 == var2
égal à ;var1 != var2
différent de ;var1 <= var2
inférieur ou égal à ;var1 < var2
inférieur à ;var1 >= var2
supérieur ou égal à ;var1 > var2
supérieur à.
Toutefois les conditions ne dépendent pas forcement que d'un seul paramètre on peut très bien avoir deux variables de tester. Exemple:
On trouve ici un nouveau mot clé. Il s'agit d'opérateur de condition. Ici les deux comparaison doivent être VRAI pour entrer dans le if. Il existe plusieurs opérateur logique que j'énumère ici :
&&
(ET logique : l'un doit être VRAI et l'autre aussi) ;||
(OU logique : soit l'un doit être VRAI soit l'autre ou même les deux) ;^^
(OU exclusif : soit l'un doit être VRAI soit l'autre MAIS PAS LES DEUX).
Il existe un mot clé spécial aussi pour définir la négation d'une condition, il s'agit de !
Par exemple:
Toutes ces notions relève de la logique booléenne. Il faut savoir que chaque comparaison possède un contraire exprimable avec ! ou même sans. IF n'est pas la seule conditions qu'il existe en C. Il en existe d'autres, toutefois elles servent de boucles. Il existes 3 type de boucles :
while
tant que... ;do while
faire ... tant que... ;for
à partir d'une valeur donnée et continuer tant que...
while
est peut être la plus simple. La boucle s'exécute tant que la condition est vérifié. Exemple :
// ici on rentre dans la boucle en faisant un premier test : si myVar = 3 alors on rentre while ( myVar == 3 ) { // on exécute le code qu'on veut faire...
} // et la on remonte à while en haut et on refais un test si myVar est toujours égal à 3 alors on rerentre
// on arrive ici lorsque myVar est devenu différent de 3.
La boucle do while
est identique à while
sauf qu'elle rentre au moins une fois dans la boucle sans faire de test.
Exemple :
do { } while (myVar == 3); // et on fais un test si myVar est égal à 3 alors on remonte à do et on recommence
// on arrive ici lorsque myVar est devenu différent de 3.
La dernière boucle est la boucle for
. Cette boucle permet de partir d'un point à un autre. Elle est idéale pour
parcourir une tranche d'un tableau.
Voila pour ce premier tutorial que j'ai réédité. J'espère qu'il vous aura aidé dans votre démarche sur l'apprentissage du C.