2

Les Variables

Les données qu'utilise un programme peuvent varier au cours de son exécution. On les appelle alors des variables. Les valeurs de ces variables peuvent être modifiées au moyen d'une série d'opérations. Toute variable utilisée par le programme doit posséder un type. En déclarant la variable, on précise donc le type de valeur qu'elle va contenir. Toute déclaration de variable doit être de la forme :

nom_du_type_de_la_variable   nom_de_la_variable;

• Les différents types
• Assigner une valeur à une variable
• Les conversions
• Opérateurs arithmétiques
• Opérateurs relationnels
• Opérateurs logiques
• Opérateurs de bits
• Opérateurs d'affectation

Les Différents Types

Entier

Ce type représente les données entières. La déclaration d'une variable entière doit être sous la forme :

int nom_de_la_variable;

C permet aussi de préciser si les entiers doivent être de types longs (long int) ou de types courts (short int). Ces extensions permettent de choisir les valeurs maximales et minimales que peuvent contenir les variables.

Exemple :

int n,p; /*n et p sont des nombres entiers*/
long int taille; /*taille est un nombre du type long int*/
unsigned int vitesse_de_la_lumiere; /*vitesse_de_la_lumiere est un nombre du type unsigned int*/
unsigned long int infini; /*infini est un nombre du type unsigned long int*/

Décimal

Ce type représente les données numériques réelles. La déclaration d'un tel type de variables sera de la forme :

float nom_de_la_variable;

Il y a également comme pour les entiers une extension de type float, il s'agit du type double.

Le type double permet une plus grande précision.

Exemple :

float PI; /*pi est un nombre décimal*/
double micro; /*micro est un nombre du type double*/

Caractère

C permet d'utiliser des variables caractères. La déclaration d'une variable caractère doit être de la forme :

char nom_de_la_variable;

Les valeurs possibles pour ce type de variable correspondent aux caractères ASCII. Nous pouvons remarquer qu'une valeur caractère doit toujours être entourée par des apostrophes ' '.

Exemple :

char lettre; /* on définit "lettre" comme étant de type caractère*/
lettre='A'; /* on affecte à "lettre" le symbole A, on remarque les apostrophes*/

2 fonctions utiles :

• getchar()
• putchar

La fonction getchar()
Cette fonction lit un caractère unique. La valeur renvoyée par la fonction correspond au caractère lu.

caractere_lu=getchar;

Exemple :

char caractere;
caractere=getchar();

La fonction putchar
Cette fonction écrit un caractère. Son format est le suivant :

putchar(item);

où item est une variable de type caractère ou un valeur caractère.

Exemple :

char caractere;
caractere='a';
putchar(caractere);
putchar('b');

Exemple utilisant getchar et puchar :

#include<stdio.h>

main()
{
    char carlu; /*définition d'une variable char pour stocker le caractère lu */
    printf("Entrez la lettre a.\n");
    printf("Validez votre saisie par <Entree> :");
    carlu=getchar(); /* lecture du caractère "a" via getchar et affectation du caractère à la variable "carlu" */
    putchar('\n'); /* saut de ligne via la séquence '\n' */
    putchar(97); /* affichage de la lettre "a" via son code ASCII */
    putchar('\n'); /* saut de ligne */
    putchar('a'); /* affichage de la lettre "a" en tant que constante */
}

Déroulement de ce programme :

Entrez la lettre a.
Validez votre saisie par <Entree> : a
a
a
a

Assigner une valeur à une variable

Il est possible d'assigner une valeur à une variable à l'aide du signe =. On peut le faire de deux manières différentes : soit lors de la déclaration de la variable, soit après ces déclarations.

Exemples :

#include<stdio.h>

main()
{
    int a=3, b=5, c; /* on assigne les valeurs 3 et 5 aux variables a et b lors de leur déclaration, et rien à c */
    float x=1.23, y;
    char lettre='z';

    printf ("Ici a vaut 3, b vaut 5 et on ne sait pas combien vallent c et y");

    a=6;
    b=8;
    c=6;
    y=-23.32;


    printf ("Ici a vaut 6, b vaut 8, c vaut 6 et y vaut -23.32");
}

Les conversions

Si mathématiquement les entiers constituent un sous-ensemble des nombres fractionnaires, on ne saurait dire la même chose des int, par rapport aux float.
Ces deux types représentent en fait, informatiquement, deux ensembles disjoints.
Par exemple, le nombre 1 avec le type int est différent du nombre 1 avec le type float.
Si on veut associer, en une même opération arithmétique un int et un float, il est nécessaire que les deux opérandes aient un type commun. On atteint ce type commun à partir d'une conversion généralement implicite.

Expression mixte

Les opérateurs arithmétiques ne sont définis que lorsque leurs deux opérandes sont de même type. Mais on peut écrire ce que l'on nomme des "expressions mixtes" dans lesquelles interviennent des opérandes de types différents.

Exemple :

n * x + p (avec n et p de type int et x de type float)
Dans ce cas, le compilateur sait, compte tenu des règles de priorité, qu'il doit d'abord effectuer le produit n*x. Pour que ce soit possible, il va convertir n dans le type float (car on considère que le type float permet de représenter un int, l'inverse étant faux). La multiplication portera donc sur deux opérandes de type float et elle fournira un résultat de type float. Pour l'addition, on se retrouve à nouveau en présence de deux opérandes de types différents. Le même mécanisme sera mis en place et, le résultat final sera de type float.

Conversions implicites

Dans l'affectation, la valeur de l'expression à droite du signe égal est convertie, avant affectation, selon le type de la variable réceptrice située à gauche du signe égal.

Exemple :

#include<stdio.h>

main()
{
int n;
float x=2.1;
n=x+5.3; /* le compilateur calcule d'abord x+5.3, puis convertit le */
/* résultat (qui est 7.4) en un entier : on a donc n=7 */
}

Conversions explicites

L'opérateur cast permet toutes les conversions explicites, ayant un sens.

Syntaxe :

(type) donnee_a_convertir

Exemple :

#include<stdio.h>

main()
{
int i=10,j=3; /* i et j sont un entier */
double x; /* x doit recevoir la valeur de i/j */
x= (double) (i/j);

/* x a pour valeur l'expression entière i/j convertie en double */
/* Il y a d'abord calcul dans le type int de i/j : ici le résultat */
/* est 3, puis ce résultat est convertit en double. x=3.0 */

x= (double) i/j;

/* i est d'abord convertit en double, les règles de conversions */
/* implicites font que j est convertit en double également, puis */
/* vient le calcul de i/j : ici le résultat est donc de 3.3333... */
/* Et enfin, ce résultat est mis dans x : x=3.33333... */
}

Opérateurs Arithmétiques

Les opérateurs de cette catégorie procèdent à des opérations arithmétiques sur leurs opérandes. Outre les opérateurs de calculs élémentaires, il existe un opérateur de changement de signe, et un opérateur pour calculer le reste entier d'une division (modulo).

Opérateurs Relationnels

Les opérateurs de comparaison en C font partie des opérateurs binaires et comparent les valeurs de leurs opérandes. Ils testent, ce faisant, la nature de la relation entre les deux opérandes. Le résultat d'une comparaison est, d'un point de vue logique, une assertion de type VRAI ou FAUX.

Remarque : un entier est estimé VRAI si sa valeur est différente de 0, FAUX si elle vaut 0.

Opérateurs Logiques

Les opérateurs logiques en C effectuent les opérations classiques de la logique des prédicats : ET (AND), OU (OR), NON (NOT). Grâce à eux, il est possible de relier logiquement des instructions. Il y a trois opérateurs logiques, deux d'entre eux sont binaires, et l'autre est unaire. Comme avec les opérateurs relationnels, l'évaluation des expressions comportant des opérateurs logiques donne un résultat de type VRAI, FAUX, exprimé en tant que grandeur de type int. Ce résultat peut prendre les valeurs 0 (FAUX) ou 1 (VRAI).

Remarque : un entier est estimé VRAI si sa valeur est différente de 0, FAUX si elle vaut 0.

Opérateurs de Bits

Ces opérateurs, semblables aux opérateurs logiques, permettent de réaliser des opérations sur les bits de données. Outre les opérations logiques ET, OU, NON, sur les bits, on peut également effectuer des opérations de décalage. Toutes opérations de bits exigent des opérandes entiers.

Opérateurs d'Affectation

L'affectation des entiers est l'opération la plus fondamentale de tout langage de programmation. Cette opération est matérialisée par le signe "=". La valeur qui se trouve à la droite de ce signe est mise dans la variable située à sa gauche. Elle constitue également la valeur résultat de l'expression.

Exemple :

A=2; /* on affecte ici 2 à la variable A */
B=A+3; /* on affecte ici 5 (car A+3=5) à la variable B */

Les affectations combinées mélangent une opération d'affectation avec une opération arithmétique ou logique.