Leçons de niveau 14

Introduction au langage C/Variables et constantes

Une page de Wikiversité.
Sauter à la navigation Sauter à la recherche
Début de la boite de navigation du chapitre
Variables et constantes
Icône de la faculté
Chapitre no 4
Leçon : Introduction au langage C
Chap. préc. :Mots clés
Chap. suiv. :Types
fin de la boite de navigation du chapitre
Icon falscher Titel.svg
En raison de limitations techniques, la typographie souhaitable du titre, « Introduction au langage C : Variables et constantes
Introduction au langage C/Variables et constantes
 », n'a pu être restituée correctement ci-dessus.

Introduction à la notion de variables[modifier | modifier le wikicode]

Les variables sont au cœur de la programmation. Un programme ne peut fonctionner sans variables.
Une variable associe un nom à une valeur. Il ne faut en aucun cas confondre le nom et la valeur. La variable n’est pas constante, elle peut varier pendant l'exécution du programme.

Variables et programme[modifier | modifier le wikicode]

Déclaration de la variable dans le programme[modifier | modifier le wikicode]

Pour déclarer une variable dans un programme, il faut écrire par exemple :

  • Le type de la variable (int)
  • son nom (var1, par exemple)
  • initialisation = (valeur de départ) facultatif mais recommandé.
  •  ;

Un exemple :

int main(int argc, char *argv[]) //Fonction principale main
{
    int var1 = 3;
    /* Autres instructions ... */
}

Ce code aura pour fonction d'associer à la variable var1 de type int la valeur 3.

Conseil de codage à respecter : c_lis_16.

Syntaxe correcte pour le nom des variables[modifier | modifier le wikicode]

  • Il est déconseillé d’utiliser le symbole _, son utilisation est réservée aux identificateurs de constantes et à la programmation système (programmation en mode noyau).
  • Tous les identifiants sont sensibles à la casse, c'est-à-dire que les minuscules et les majuscules ont leur importance.
Identificateurs corrects Identificateurs incorrects Pourquoi ?
nom1 1nom Ne peut commencer par un chiffre
nom_2 nom.2 Les points ne sont pas autorisés
_nom_3 -nom-3 Les tirets ne sont pas autorisés
nom_de_variable Nom de variable Les espaces ne sont pas autorisés
deuxieme_choix deuxième_choix Les caractères accentués ne sont pas autorisés
mot_francais mot_français Les cédilles ne sont pas autorisées

Conseils de codage à respecter : c_lis_8, c_lis_9, c_rec_1.

Afficher une variable[modifier | modifier le wikicode]

Pour afficher une variable à l'écran ou l'écrire dans un fichier, il faut appeler une fonction des fonctions de sortie dont le prototype est dans stdio.h, comme par exemple printf().

Par exemple, pour afficher un entier, il faut appeler la fonction

printf("%d", variable);

Ce qui donne en programme complet :

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
    int variableEntiere = 4;
    (void)printf("%d", variableEntiere); /* Ce code affichera donc 4 */
    return EXIT_SUCCESS;
}


Remarques

  • printf() est une fonction à nombre de paramètres variable : son premier paramètre obligatoire est une chaîne décrivant le format de la sortie, les suivants sont des variables qui remplaceront les indicateur de conversion % de la chaine de conversion.
  • Pour afficher une variable flottante, il faut écrire :
printf("%f", variableFlottante);
  • les fonctions de la famille de printf() retournent en cas de succès le nombre de caractères écrits dans le flux de sortie, et en cas d'erreur une valeur négative. Un programme opérationnel doit tester ce code retour. Ici, pour simplifier nous l'ignorons explicitement par le cast (void).
  • Les indicateurs de conversion de la chaine de format de printf doivent correspondre en nombre et type aux variables passées en paramètre sous peine d'erreur à l'exécution.

Récupérer une variable[modifier | modifier le wikicode]

Pour lire une variable sur le flux d'entrée stdin (associé par défaut au clavier), il faut faire appel à la fonction scanf("%d", &variable); (%d est remplacé par : %f pour les nombres réel (float), %s pour les chaines de caractères (char * / char []), %c pour un caractère, etc. )

Il faut auparavant déclarer la variable à utiliser, puis passer son adresse à la fonction scanf à l'aide de l'opérateur &.

Voilà un code complet :

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
    int variableEntiere = 0;
    (void)puts("Tapez un nombre puis la touche Entree :");
    (void)scanf("%d", &variableEntiere); /* Lecture du nombre entier */
    (void)printf("Vous avez saisi le nombre %d\n", variableEntiere);
    return EXIT_SUCCESS;
}

Dans les prochains chapitres, nous verrons comment additionner des variables, les utiliser dans des boucles ou conditions, etc.

Remarque :

  • Les remarques concernant printf() s'appliquent à scanf().
  • La fonction scanf() a besoin de l'adresse de vos variables pour y écrire. Pour cette raison, on utilise le symbole & voir le chapitre 9
  • Sans ce passage par adresse, la fonction scanf() tenterait d'écrire le nombre lu à l'adresse 0 (contenu de variableEntiere), qui n'appartient pas à votre domaine d'adressage autorisé. Le système enverait alors un signal à votre programme, qui s'arrêtera prématurément.

Portée et persistance des variables[modifier | modifier le wikicode]

Des règles définissent la visibilité et la persistance des variables déclarées ou définies (= espace mémoire de stockage réservé). Ces caractéristiques dépendent de l'endroit où elles sont déclarées et de mots réservés (classes de stockage et qualificateurs) placés avant leur type.

Conseil de codage à respecter : c_rec_11

Searchtool.svg Plus d'explications dans le WikiLivre Programmation C, chapitre Classe de stockage.

Portée[modifier | modifier le wikicode]

  • locale : la variable n'est visible que dans le fichier ou le bloc (espace entre deux accolades {} de même niveau) où elle est définie.
  • globale : la variable est visible dans tout le fichier source, mais aussi dans les autres fichiers sources du projet. Elle est persistante.
  • Remarque Qualité : l'usage des variables globales doit être limité, elles peuvent créer des problèmes :
    • dits d'effets de bord : elles peuvent être modifiées par erreur par une autre fonction;
    • à l'édition de lien : définition multiple d'un symbole.

Quelques modificateurs[modifier | modifier le wikicode]

  • extern : déclare une variable globale qui doit être définie ailleurs.
  • static : rend une variable persistante et limite sa portée au fichier si elle est définie hors du corps des fonctions.
  • register : information pour le compilateur lui demandant de permettre un accès plus rapide de cette variable.
  • auto (par défaut) :
    • dans le corps d'une fonction : la variable est dite automatique : sa portée est limitée au bloc où elle est définie et aux blocs inclus. Son espace mémoire de stockage n’est pas préservé au dehors.
    • En dehors d'une fonction : c’est une définition de variable globale (avec réservation de mémoire).

Localisation[modifier | modifier le wikicode]

Les variables peuvent se définir :

  • À l'extérieur du corps des fonctions
    • sans modificateur de portée : définition = réservation de mémoire d'une variable globale
    • avec static : portée limitée au fichier courant, variable persistante.
  • En tête d'un bloc (limité par deux accolades {} de même niveau)
    • sans modificateur : variable automatique, portée locale.
    • avec static : variable persistante, portée locale.

Les constantes[modifier | modifier le wikicode]

Introduction[modifier | modifier le wikicode]

Les constantes sont proches des variables, à un point près :
Elles ne peuvent pas changer de valeur au cours du programme.

Les constantes littérales[modifier | modifier le wikicode]

Les constantes littérales représentent des valeurs numériques ou caractères entrés dans le code source du programme et réservés et initialisés lors de la phase de compilation de code source.

Exemple d'écriture des constantes littérales numériques :

  • 6 : la constante entière 6 codée sur un entier avec signe.
  • 6u ou 6U : la constante entière non signée 6.
  • 6l ou 6L : la constante entière signée 6 codée sur un entier long.
  • 6ul ou 6UL : la constante entière non signée 6 codée sur un entier long.
  • 010 : la constante 8 (en base 10) codée 10 (base 8) : Danger.
#include <stdio.h>
#include <stdlib.h>
 
int main(int argc, char argv[])
{
	int i = 010;
	(void)printf("i=%d\n", i); /* Affiche 8 */	
  
	return EXIT_SUCCESS;
}
  • 0x12 : la constante hexadécimale 12 (base 16) qui vaut 18 en base 10.
  • 5.f : la constante réelle simple précision 5.
  • 5. : la constante réelle double précision 5.
  • -5.12E-18 : la constante réelle double précision -5,12 × 10-18.
  • '2' : le caractère alphabétique 2.
  • '\10' : le caractère ASCII de code octal 10 = 8 en décimal.
  • '\x1A' : le caractère ASCII de code hexadécimal 1A = 26 en décimal.
  • '\n' : le caractère correspondant à la séquence d'échappement \n qui représente un saut de ligne.
  • "Bonjour Aude" : représente une zone mémoire de 13 caractères (12+1) allouée lors de la compilation et initialisée avec la chaîne de caractère Bonjour Aude à laquelle est ajoutée le caractère de fin de chaine de code ASCII 0 ('\0').

Les constantes symboliques[modifier | modifier le wikicode]

Les constantes symboliques sont définies par le programmeur ou pour lui dans des fichiers inclus par exemple stdio.h.

Variable déclarée avec le modificateur const[modifier | modifier le wikicode]

Ce sont des variables dont la valeur n’est pas modifiable, sauf au niveau de leurs déclarations.

Pour déclarer une constante, il faut ajouter le mot réservé const avant son type.

const int var1 = 5 ;

Constantes préprocesseur[modifier | modifier le wikicode]

Avec le commande #define, il est possible de donner un nom symbolique à une constante littérale définies dans les fichiers d'entête ou dans le texte du programme (de préférence au début).

#include <stdio.h>
#include <stdlib.h>

/* Les constantes symboliques définies par l'utilisateur */
#define MAX 100
#define PI 3.14
#define LANGAGE "C++"

int main(int argc, char *argv[])
{
    /* Ce code affichera les noms des 3 constantes et leur valeurs */
    (void)printf("MAX = %d, PI = %e, LANGAGE= \"%s\"\n",
        MAX, PI, LANGAGE);

    return EXIT_SUCCESS;
}

Compilation et résultat :

MacMini-TM:~/Documents/developpement/c thierry$ gcc -o constante.exe constante.c
MacMini-TM:~/Documents/developpement/c thierry$ ./constante.exe
MAX = 100, PI = 3.140000e+00, LANGAGE= "C++"

Constante énumérée[modifier | modifier le wikicode]

L'énumération est une suite de constantes renfermées dans une seule.

enum DIRECTION {NORD, SUD, EST, OUEST};

Il est possible de donner une valeur entière à ces constantes, si vous ne donnez qu'une seule valeur à une seule constante les suivantes prendront la même valeur incrémentée de 1.

enum DIRECTION {NORD=10, SUD, EST, OUEST}; 
printf("Nord : %d\n", NORD); // affiche 10
printf("Sud : %d\n", SUD); // affiche 11
printf("Est : %d\n", EST); // affiche 12

Remarque : Si vous ne donnez aucune valeur, par défaut la première valeur sera zéro.

TP[modifier | modifier le wikicode]

Searchtool.svg Faîtes les exercices du WikiLivre Exercices en langage C au chapitre sur les variables et constantes.