CyBWarrior

Pour fonctionner, un programme à generalement besoin de pouvoir utiliser des données. Pour cela, il doit pouvoir
stocker les valeurs, et pouvoir y acceder par la suite. Le programme poura ensuite les controler, et pourquoi
pas, les modifier.
Pour cela, il existe un moyen simple qui est l’utilisation des variables.

Mais avant de voir tout ceci en détail, il nous faut tout d’abord distinguer les différents types de données
existants.
On peut commencer par distinguer les chiffres (données numeriques) du texte (chaînes de caractères).
Pour les nombres, rien de bien compliqué. En revanche, l’exploitation des chaînes de caractères est relativement complexe
en comparaison à d’autres langages plus accessibles comme le Basic ou le Pascal. C’est pourquoi nous les aborderons dans des sections futures, quand
nous serons plus calés .

Mais compliquons quand même un peu : dans les données numériques, on peut encore trouver des « sous-catégories », comme par exemple, les nombres entiers,
decimaux, signés (uniquement positifs)…

Commençons par les types de variables entiers, que voici :

En C, la déclaration d’une variable se fait selon la syntaxe suivante :

type identificateur;

type represente le type de la variable et identificateur le nom de cette variable.
Un identificateur doit suivre certaines regles, comme :

• Ne pas contenir d’espaces ou de carctères dits spéciaux comme les accents, la ponctuation (à l’execption du trait de soulignement),
  etc…
• Ne pas commencer par un chiffre (il peut par contre en contenir)
• Ne pas prendre le nom d’une fonction déjà existante

De plus, un identificateur de variable doit s’efforcer d’être explicite au maximum. C’est à dire que l’on devrai pouvoir savoir ce que représente
une variable rien qu’en lisant son nom.

Voici quelques exemples de déclaration de variables valides :

int i;/* Entier normal*/
char touchepressee;/* Caractère */

La déclaration des variables doit se faire avant toute instruction, sinon une erreur de compilation se produit. À notre stade, nous délarerons les
variables dans la fonction main(). Il est possible de les déclarer à l’exterieur, mais cela n’est utile que pour un programme possedant
plusieurs fonctions, ce qui n’est pas le cas pour l’instant.

Pour affecter une valeur à une variable, on utilise tout simplement l’opérateur = (égal). Ce qui est du coté droit de cet opérateur sera
alors affecté au coté gauche. Par exemple, pour affecter la valeur 5 à la variable nombre, on écrira :

int main(){
int nombre;/* Declaration de la variable nombre */
nombre = 5;/* Affectation de 5 à nombre */
return 0;
}

Bien evidement, le coté gauche de cet opérateur ne peut en aucun cas être une constante, puisque la valeur d’une constante est par définition invariable.
En revanche, on peut parfaitement affecter la valeur d’une variable à une autre :

int main(){
int nombre, autrenombre;
nombre = 5;/* Affectation de 5 à nombre */
autrenombre = nombre;/* Affectation de nombre à autrenombre */
return 0;
}

Vous remarquez que on a déclaré la variable nombre et la variable autrenombre sur la même ligne. Cette syntaxe est également
possible.
Maintenant que nous avons vu comment affecter une valeur à une variable, nous allons voir comment afficher sont contenu. Pour cela, nous allons utiliser
la fonction printf de la bibliothéque stdio.
La syntaxe de cette fonction est extrement complexe (ou plutôt très complete) et nous ne l’aborderons pas en détail dans cette section.
Pour afficher le contenu d’une variable numérique, nous utiliserons simplement la syntaxe suivante :

printf("Ceci est du texte %u", variable);

Vous avez reconnu la première partie de cette fonction, "Ceci est du texte %u". Il s’agit d’une chaîne de caractères qui sera affichée
à l’écran, à un petit détail près : la séquence %u sera remplacée par la variable variable passée comme second argument.
Si nous avions plusieurs variables, nous aurons pu écrire :

printf("A vaut %d et B vaut %d", A, B);

Le premier %d sera remplacé par le contenu de la variable A, et le second %d par celui de B.
Ainsi, pour afficher le contenu de notre variable nombre, nous écrirons :

#include <stdio.h>

int main(){
int nombre=5;/* Déclaration et affectation */

printf("Le contenu de nombre est %d", nombre);/* Sortie -> 5 */
return 0;
}

La première ligne (en fait, la seconde) permet de gagner du temps en déclarant une variable et en lui affectant une valeur initiale (ici, 5).

Maintenant, revenons à notre histoire de type signé et non-signé. Pour déclarer une variable non-signée, c’est à dire uniquement positive, il suffit
de rajouter le mot-clef unsigned devant la déclaration de la variable :

unsigned short MaVariable;/* Intervalle : 0 à 65535 */

Maintenant, si on affecte une valeur négative à MaVariable, aucune erreur ne se produira, mais le résultat sera arbitraire :

#include <stdio.h>

int main(){
unsigned short MaVariable=-10;

printf("Cet valeur n'est pas garantie %u", MaVariable);
return 0;
}

Il faut donc faire très attention aux valeurs utilisées.
Mais passons maintenant aux types flottants. Les voici répertoriés dans le tableau ci-dessous :

L’utilisation de ces types est identique que pour les types entiers.
Par contre, l’utilisation de printf sera differente. On poura par exemple écrire :

#include <stdio.h>

int main(){
float Nombre=3.1415;

printf("%f", Nombre);
return 0;
}