Introduction

Les structures de contrôle permettent comme leur nom l’indique de contrôler des conditions durant l’exécution de votre code. Cela peut varier de la valeur d’une variable en passant par le retour d’une fonction. Les structures de contrôle permettent également de traiter les éléments d’un tableau ou des listes de valeurs déterminées (par exemple : de 0 à 31).

Sans ces structures logiques, la programmation serait un véritable enfer où le choix des portion de code à exécuter reviendrai à la décision d’un humain et où il faudrait réécrire x fois la même portion de code pour traiter les x valeurs d’un tableau.

Dans les structures de contrôle et pour les langages que nous allons étudier, la condition à tester est un booléen, soit une valeur comprise entre 0 (FAUX) et 1 (VRAI). Une condition sera toujours déclenchée par un état VRAI. Si on souhaite faire le contraire, c’est à dire déclencher lorsque la vérification est fausse, il faut faire précéder son expression par un point d’exclamation !. Enfin, les conditions doivent être entourées par des parenthèses.

Les opérateurs de contrôle

Voici une liste non exhaustive des principaux symboles utilisés pour tester des conditions.

Voici quelques exemples de conditions et leur retour booléen:

• (12==13) FAUX
• (13==13) VRAI
• (12==(12+1)) FAUX
• (12==(13-1)) VRAI
• (13 > 12) VRAI
• (12 < 13) VRAI
• (12 > 13) FAUX
• (13 >= 13) VRAI
• (12!=13) VRAI

SI ou SINON et SINON-SI

La première structure de contrôle et aussi la plus simple consiste à vérifier une condition et à exécuter des instructions en fonction qu’elle soit vrai ou fausse. Il est également possible de tester plusieurs conditions dans une structure SI avec SINON-SI.

Voici comment se présente cette structure

SI (CONDITION VRAI)
	ALORS
	// Instructions à exécuter si la condition est vrai
SINON
	// Instructions à exécuter si la condition est fausse

SI (CONDITION VRAI)
	ALORS
	// Instructions à exécuter si la condition est vrai
SINON
	// Instructions à exécuter si la condition est fausse

Simple n’est-ce pas? Si la condition est vrai, on exécute les instructions définies en haut, sinon les autres. On peut même ne pas spécifier d’instruction pour SINON si ce n’est pas utile.

Pour illustrer l’exemple ci-dessous avec une valeur

SI (12 < 13)
	ALORS
	AFFICHER '12 est inférieur à 13'

SI (12 < 13)
	ALORS
	AFFICHER '12 est inférieur à 13'

Ici pas de sinon, 12 sera toujours inférieur à 13 et ce n’est pas la crise ni les attaques terroristes qui pourront y changer quelque chose…

Voici comment s’utilise cette structure en C

#define <stdio.h>
#define <stdlib.h>
 
int main(void) {
  int a=13;
  int b=12;
 
  /* SI */
  if (a > b) {
    printf("La valeur de a est supérieure à la valeur de b\n") ;
  }
  /* SINON */
  else {
    printf("La valeur de a est inférieure à la valeur de b\n") ;
  }
  /* Affichera :  La valeur de a est supérieure à la valeur de b */
 
  a=12 ; b=13 :
  /* SI */
  if (a > b) {
    printf("La valeur de a est supérieure à la valeur de b\n") ;
  }
  /* SINON */
  else {
    printf("La valeur de a est inférieure à la valeur de b\n") ;
  }
  /* Affichera :  La valeur de a est inférieure à la valeur de b */
}

#define <stdio.h>
#define <stdlib.h>
 
int main(void) {
  int a=13;
  int b=12;
 
  /* SI */
  if (a > b) {
    printf("La valeur de a est supérieure à la valeur de b\n") ;
  }
  /* SINON */
  else {
    printf("La valeur de a est inférieure à la valeur de b\n") ;
  }
  /* Affichera :  La valeur de a est supérieure à la valeur de b */
 
  a=12 ; b=13 :
  /* SI */
  if (a > b) {
    printf("La valeur de a est supérieure à la valeur de b\n") ;
  }
  /* SINON */
  else {
    printf("La valeur de a est inférieure à la valeur de b\n") ;
  }
  /* Affichera :  La valeur de a est inférieure à la valeur de b */
}

en Perl à présent

# !/usr/bin/perl
 
use strict ;
 
my $a=13 ;
my $b=12 ;
 
# SI
if ($a > $b) {
  # Instructions
  print "La valeur de a est supérieure à la valeur de b\n" ;
}
# SINON
else {
  # Instructions
  print "La valeur de a est inférieure à la valeur de b\n" ;
}
# Affichera :  La valeur de a est supérieure à la valeur de b
 
$a=12 ; $b=13 ;
# SI
if ($a > $b) {
  # Instructions
  print "La valeur de a est supérieure à la valeur de b\n" ;
}
# SINON
else {
  # Instructions
  print "La valeur de a est inférieure à la valeur de b\n" ;
}
# Affichera :  La valeur de a est inférieure à la valeur de b

# !/usr/bin/perl
 
use strict ;
 
my $a=13 ;
my $b=12 ;
 
# SI
if ($a > $b) {
  # Instructions
  print "La valeur de a est supérieure à la valeur de b\n" ;
}
# SINON
else {
  # Instructions
  print "La valeur de a est inférieure à la valeur de b\n" ;
}
# Affichera :  La valeur de a est supérieure à la valeur de b
 
$a=12 ; $b=13 ;
# SI
if ($a > $b) {
  # Instructions
  print "La valeur de a est supérieure à la valeur de b\n" ;
}
# SINON
else {
  # Instructions
  print "La valeur de a est inférieure à la valeur de b\n" ;
}
# Affichera :  La valeur de a est inférieure à la valeur de b

Au tour de PHP

<?php
 
$a=13 ; $b=12 ;
// SI
if ($a > $b) {
  // Instructions
  echo "La valeur de a est supérieure à la valeur de b<br/>" ;
}
// SINON
else {
  // Instructions
  echo "La valeur de a est inférieure à la valeur de b<br/>" ;
}
// Affichera :  La valeur de a est supérieure à la valeur de b
 
$a=12 ; $b=13 ;
// SI
if ($a > $b) {
  // Instructions
  echo "La valeur de a est supérieure à la valeur de b<br/>" ;
}
// SINON
else {
  // Instructions
  echo "La valeur de a est inférieure à la valeur de b<br/>" ;
}
// Affichera :  La valeur de a est inférieure à la valeur de b
?>

<?php
 
$a=13 ; $b=12 ;
// SI
if ($a > $b) {
  // Instructions
  echo "La valeur de a est supérieure à la valeur de b<br/>" ;
}
// SINON
else {
  // Instructions
  echo "La valeur de a est inférieure à la valeur de b<br/>" ;
}
// Affichera :  La valeur de a est supérieure à la valeur de b
 
$a=12 ; $b=13 ;
// SI
if ($a > $b) {
  // Instructions
  echo "La valeur de a est supérieure à la valeur de b<br/>" ;
}
// SINON
else {
  // Instructions
  echo "La valeur de a est inférieure à la valeur de b<br/>" ;
}
// Affichera :  La valeur de a est inférieure à la valeur de b
?>

Et finalement en Javascript

var a=13 ;
var b=12 ;
 
// SI
if (a > b) {
  // Instructions
  console.log('La valeur de a est supérieure à la valeur de b') ;
}
// SINON
else {
  // Instructions
  console.log('La valeur de a est supérieure à la valeur de b') ;
}
// Affichera :  La valeur de a est supérieure à la valeur de b
 
a=12 ; b=13 ;
// SI
if (a > b) {
  // Instructions
  console.log('La valeur de a est supérieure à la valeur de b') ;
}
// SINON
else {
  // Instructions
  console.log('La valeur de a est supérieure à la valeur de b') ;
}
// Affichera :  La valeur de a est inférieure à la valeur de b

var a=13 ;
var b=12 ;
 
// SI
if (a > b) {
  // Instructions
  console.log('La valeur de a est supérieure à la valeur de b') ;
}
// SINON
else {
  // Instructions
  console.log('La valeur de a est supérieure à la valeur de b') ;
}
// Affichera :  La valeur de a est supérieure à la valeur de b
 
a=12 ; b=13 ;
// SI
if (a > b) {
  // Instructions
  console.log('La valeur de a est supérieure à la valeur de b') ;
}
// SINON
else {
  // Instructions
  console.log('La valeur de a est supérieure à la valeur de b') ;
}
// Affichera :  La valeur de a est inférieure à la valeur de b

La structure de contrôle SI-SINON existe dans la majorité des langages de programmation et est indispensable pour prendre des décisions dans un programme. On ne peut s’en passer et vous verrez par la suite que ceraines structures de contrôles plus complexes reposent sur celle-ci.

TANT QUE

Cette structure de contrôle fait partie des boucles. Parce que, tant que la condition est vrai, nous allons exécuter les mêmes instructions. Attention toutefois à réaliser les bons contrôles pour sortir de la boucle sans quoi votre programme peut boucler à l’infini (jusqu’à interruption manuelle).

Elle se présente comme suit

TANT-QUE (CONDITION VRAI) {
	// Instructions à exécuter à chaque passage dans la boucle
}

TANT-QUE (CONDITION VRAI) {
	// Instructions à exécuter à chaque passage dans la boucle
}

Voici ce que ça donne en C

#define <stdio.h>
#define <stdlib.h>
 
int main(void) {
  int position=12 ;
  int max=24 ;
 
  /* Tant que position est inférieur à max */
  while (position < max) {
    /* Instructions à exécuter tant que position est inférieur à max */
    printf("Valeur de position : %d\n", position) ; /* Affiche la valeur de position */
    position++ /* On augmente position de 1 à chaque passage */
  }
  /* La boucle affichera les valeurs de 12 à 23 puisque 24 étant == à max on sort de la boucle avant de l'afficher */
}

#define <stdio.h>
#define <stdlib.h>
 
int main(void) {
  int position=12 ;
  int max=24 ;
 
  /* Tant que position est inférieur à max */
  while (position < max) {
    /* Instructions à exécuter tant que position est inférieur à max */
    printf("Valeur de position : %d\n", position) ; /* Affiche la valeur de position */
    position++ /* On augmente position de 1 à chaque passage */
  }
  /* La boucle affichera les valeurs de 12 à 23 puisque 24 étant == à max on sort de la boucle avant de l'afficher */
}

En perl

# !/usr/bin/perl
 
use strict ;
 
my $pos=12 ;
my $max=24 ;
 
# Tant que pos est inférieur à max
while ($pos <= $max) {
  # Affiche la valeur de pos à chaque passage
  print "Valeur de pos : $pos\n" ;
  # Incrémente la valeur de pos à chaque passage (ajoute 1)
  $pos++ ;
}
# La boucle affichera les valeurs de 12 à 24 puisque nous avons utilisé l'opérateur <= (inférieur ou égal)

# !/usr/bin/perl
 
use strict ;
 
my $pos=12 ;
my $max=24 ;
 
# Tant que pos est inférieur à max
while ($pos <= $max) {
  # Affiche la valeur de pos à chaque passage
  print "Valeur de pos : $pos\n" ;
  # Incrémente la valeur de pos à chaque passage (ajoute 1)
  $pos++ ;
}
# La boucle affichera les valeurs de 12 à 24 puisque nous avons utilisé l'opérateur <= (inférieur ou égal)

En PHP

<?php
$pos=12 ; $max=24 ;
// Tant que pos est inférieur à max
while ($pos < $max) {
  // Affiche la valeur de pos à chaque passage
  echo "Valeur de pos : $pos<br/>" ;
  // Incrémente la valeur de pos à chaque passage (ajoute 1)
  $pos++ ;
}
/* La boucle affichera les valeurs de 12 à 23 puisque 24 étant == à max on sort de la boucle avant de l'afficher */
?>
 

<?php
$pos=12 ; $max=24 ;
// Tant que pos est inférieur à max
while ($pos < $max) {
  // Affiche la valeur de pos à chaque passage
  echo "Valeur de pos : $pos<br/>" ;
  // Incrémente la valeur de pos à chaque passage (ajoute 1)
  $pos++ ;
}
/* La boucle affichera les valeurs de 12 à 23 puisque 24 étant == à max on sort de la boucle avant de l'afficher */
?>
 

En Javascript

var pos=12 ;
var max=24 ;
 
while (pos <= max) {
  // Affiche la valeur de pos à chaque passage (dans la console)
  console.log('Valeur de pos : ' + pos) ;
  // Incrémente la valeur de pos à chaque passage (ajoute 1)
  $pos++ ;
}
/* La boucle affichera les valeurs de 12 à 24 puisque nous avons utilisé l'opérateur <= (inférieur ou égal) */
 

var pos=12 ;
var max=24 ;
 
while (pos <= max) {
  // Affiche la valeur de pos à chaque passage (dans la console)
  console.log('Valeur de pos : ' + pos) ;
  // Incrémente la valeur de pos à chaque passage (ajoute 1)
  $pos++ ;
}
/* La boucle affichera les valeurs de 12 à 24 puisque nous avons utilisé l'opérateur <= (inférieur ou égal) */
 

Dans les articles à venir nous allons étudier d’autres structures de contrôle plus complexes ou plus spécifiques à certains langages. Ces structures sont là pour faciliter le travail du développeur, aider à prendre des décision dans un programme mais aussi à parcourir des tableaux de donnée ou encore à traiter des ensembles de cas de figures spécifiques.

Cet article, sera le dernier de la série sur les variables traitera d’un type de variable très utile que sont les variables tableaux ou array en anglais.

Voici comment une variable tableau pourraît être représentée:

Une variable tableau est une liste de données rangées sous la forme d’un tableau indicé. Par exemple l’indice 0 contient Albert, l’indice 3 contient Corinne.

Voici la définition d’un tableau destiné à contenir 5 entiers en C:

// Définition de 5 emplacements pour entiers
int monTableau[5];
 
// Initialisation des emplacements (== indices)
// Premier emplacement
monTableau[0]=101;
// Second emplacement
monTableau[1]=102;
// Troisième emplacement
monTableau[2]=103;
// nième emplacement
monTableau[n-1]=nnn;

// Définition de 5 emplacements pour entiers
int monTableau[5];
 
// Initialisation des emplacements (== indices)
// Premier emplacement
monTableau[0]=101;
// Second emplacement
monTableau[1]=102;
// Troisième emplacement
monTableau[2]=103;
// nième emplacement
monTableau[n-1]=nnn;

Si l’indice x de la variable monTableau est modifié à x + 1, alors le curseur en mémoire avancera de la taille d’un int. A l’inverse, si l’indice est modifié à x – 3, alors le curseur reculera de 3 fois la taille d’un int. Survolez les int présents dans le tableau ci-dessous.

Chaque int pesant (hypothèse sur un système 32 bits) 4 octets, lorsqu’on avance d’un int, on déplace le curseur de 4 octets en mémoire.

En C le type chaîne de caractères n’existe pas comme on peut le trouver dans les autres langages. Il s’agit en fait d’un tableau de caractères qui peut se définir comme suit:

// On réserve 20 caractères
char maChaine[20];
 
// On réserve 11 caractères et on initialise le contenu de la variable
// Oui 11 et pas 10 car en C une chaîne doit se terminer par le caractère \0
// Il faut donc toujours prévoir un caractère de plus par rapport à la taille de la chaîne à contenir
char maChaine[]="Bonjour!!!";
// Equivalent de:
char maChaine[32];
maChaine[0]='B';
maChaine[1]='o';
maChaine[2]='n';
maChaine[3]='j';
maChaine[4]='o';
maChaine[5]='u';
maChaine[6]='r';
maChaine[7]='!';
maChaine[8]='!';
maChaine[9]='!';
maChaine[10]='\0';
/* ... etc ... */
// Equivalent de:
char maChaine[]={ 'B', 'o', 'n', 'j', 'o', 'u', 'r', '!', '!', '!', '\0' };
 
printf("%c - %c - %c", maChaine[0], maChaine[1], maChaine[2]); // Affichera B - o - n

// On réserve 20 caractères
char maChaine[20];
 
// On réserve 11 caractères et on initialise le contenu de la variable
// Oui 11 et pas 10 car en C une chaîne doit se terminer par le caractère \0
// Il faut donc toujours prévoir un caractère de plus par rapport à la taille de la chaîne à contenir
char maChaine[]="Bonjour!!!";
// Equivalent de:
char maChaine[32];
maChaine[0]='B';
maChaine[1]='o';
maChaine[2]='n';
maChaine[3]='j';
maChaine[4]='o';
maChaine[5]='u';
maChaine[6]='r';
maChaine[7]='!';
maChaine[8]='!';
maChaine[9]='!';
maChaine[10]='\0';
/* ... etc ... */
// Equivalent de:
char maChaine[]={ 'B', 'o', 'n', 'j', 'o', 'u', 'r', '!', '!', '!', '\0' };
 
printf("%c - %c - %c", maChaine[0], maChaine[1], maChaine[2]); // Affichera B - o - n

Tous les types de variables peuvent être ordonnés en tableau. On retrouve les tableaux dans la majorité des langages de programmation modernes. Il est possible également de créer des tableaux contenant des tableaux. Attention toutefois à ne pas sombrer dans la complexité et ne perdez jamais de vue que tout cela a un coût en mémoire.

Définition de deux tableaux en PHP:

<?php
// Tableau indicé
$epices=array('poivre', 'cumin', 'piment', 'coriandre', 'curry');
// Equivalent de
$epices=array();
$epices[0]='poivre';
$epices[1]='cumin';
$epices[2]='piment';
$epices[3]='coriandre';
$epices[4]='curry';
 
echo "Un peu de ".$epices[2]."?"; // Affichera: Un peu de piment?
 
// Tableau associatif
// On remplace l'index numérique par une chaîne de caractères appelée clé
// Ainsi le tableau associatif, comme son nom l'indique devient un tableau d'associations de clé=>valeur
$fiche=array('nom' => 'Dupont', 'prenom' => 'Henry', 'email' => 'hdupont@exemple.org');
// Pour accéder à l'adresse email de monsieur dupont, il suffit d'appeler la variable ainsi
echo $fiche['email'];  // Affichera: hdupont@exemple.org

<?php
// Tableau indicé
$epices=array('poivre', 'cumin', 'piment', 'coriandre', 'curry');
// Equivalent de
$epices=array();
$epices[0]='poivre';
$epices[1]='cumin';
$epices[2]='piment';
$epices[3]='coriandre';
$epices[4]='curry';
 
echo "Un peu de ".$epices[2]."?"; // Affichera: Un peu de piment?
 
// Tableau associatif
// On remplace l'index numérique par une chaîne de caractères appelée clé
// Ainsi le tableau associatif, comme son nom l'indique devient un tableau d'associations de clé=>valeur
$fiche=array('nom' => 'Dupont', 'prenom' => 'Henry', 'email' => 'hdupont@exemple.org');
// Pour accéder à l'adresse email de monsieur dupont, il suffit d'appeler la variable ainsi
echo $fiche['email'];  // Affichera: hdupont@exemple.org

Définition de deux tableaux en Javascript:

// Tableau indicé
epices=['poivre', 'cumin', 'piment', 'coriandre', 'curry'];
// Equivalent de:
epices=[];
epices[0]='poivre';
epices[1]='cumin';
epices[2]='piment';
epices[3]='coriandre';
epices[4]='curry';
 
console.log('Aimez-vous le ' + epices[1] +'?'); // Affichera dans la console Javascript: Aimez-vous le cumin?
 
// Tableau associatif
// Même fonctionnement qu'en PHP, seule la syntaxe change
fiche={'nom': 'Dupont', 'prenom': 'Henry', 'email': 'hdupont@exemple.org'};
// Deux méthodes permettent d'accéder à l'adresse email de monsieur dupont
console.log(fiche['email']);  // Affiche hdupont@exemple.org dans la console javascript
// Ou
console.log(fiche.email);  // Affiche hdupont@exemple.org dans la console javascript

// Tableau indicé
epices=['poivre', 'cumin', 'piment', 'coriandre', 'curry'];
// Equivalent de:
epices=[];
epices[0]='poivre';
epices[1]='cumin';
epices[2]='piment';
epices[3]='coriandre';
epices[4]='curry';
 
console.log('Aimez-vous le ' + epices[1] +'?'); // Affichera dans la console Javascript: Aimez-vous le cumin?
 
// Tableau associatif
// Même fonctionnement qu'en PHP, seule la syntaxe change
fiche={'nom': 'Dupont', 'prenom': 'Henry', 'email': 'hdupont@exemple.org'};
// Deux méthodes permettent d'accéder à l'adresse email de monsieur dupont
console.log(fiche['email']);  // Affiche hdupont@exemple.org dans la console javascript
// Ou
console.log(fiche.email);  // Affiche hdupont@exemple.org dans la console javascript

Définition de deux tableaux en Perl:

# Déclaration d'une variable tableau (indicé)
my @epices;
# Initialisation du contenu du tableau
@epices=('poivre', 'cumin', 'piment', 'coriandre', 'curry');
print "Encore un peu de ".$epice[0]."?"; # Affichera: Encore un peu de poivre?
# Equivalent de:
@epices=();
$epices[0]='poivre';
$epices[1]='cumin';
$epices[2]='piment';
$epices[3]='coriandre';
$epices[4]='curry';
print "Encore un peu de ".$epice[0]."?"; # Affichera: Encore un peu de poivre?
 
# En perl, on définit une variable tableau en faisant précéder son nom d'un @
# Mais pour accéder à ses valeurs, on utilise le symbole $ comme une variable classique
 
# Tableau associatif (aussi appelé table de hachage)
my %fiche=('nom' => 'Dupont', 'prenom' => 'Henry', 'email' => 'hdupont@exemple.org');
print $assoc{'email'}."\n"; # Affichera: hdupont@exemple.org

# Déclaration d'une variable tableau (indicé)
my @epices;
# Initialisation du contenu du tableau
@epices=('poivre', 'cumin', 'piment', 'coriandre', 'curry');
print "Encore un peu de ".$epice[0]."?"; # Affichera: Encore un peu de poivre?
# Equivalent de:
@epices=();
$epices[0]='poivre';
$epices[1]='cumin';
$epices[2]='piment';
$epices[3]='coriandre';
$epices[4]='curry';
print "Encore un peu de ".$epice[0]."?"; # Affichera: Encore un peu de poivre?
 
# En perl, on définit une variable tableau en faisant précéder son nom d'un @
# Mais pour accéder à ses valeurs, on utilise le symbole $ comme une variable classique
 
# Tableau associatif (aussi appelé table de hachage)
my %fiche=('nom' => 'Dupont', 'prenom' => 'Henry', 'email' => 'hdupont@exemple.org');
print $assoc{'email'}."\n"; # Affichera: hdupont@exemple.org

L’utilité de ce type de variable c’est de pouvoir traiter un grand volume de données avec un seul algorithme.

Par exemple, prenons l’algorithme suivant (en PHP):

<?php
// Liste d'abonnés
$liste=array(
  'jacques'  => 'jacques@truc.info',
  'Henry'    => 'henry@machin.fr',
  'Mike'    => 'mike@chose.com',
  'Pierre'  => 'pierre@bidule.net'
);
 
// On envoie le même mail à tous les abonnés
// A chaque passage dans cette boucle $clé contient le nom de l'abonné et $valeur l'adresse email de l'abonné
// Initialisation du sujet du mail
$sujet='Joyeuses fêtes';
foreach ($liste AS $cle=>$valeur) {
  // Initialisation du contenu du mail
  $message="Bonjour ".$cle."!".PHP_EOL.PHP_EOL.
    "Le blog ANDEE vous souhaite de joyeuses fêtes de fin d'année!".PHP_EOL;
  // Cette fonction n'existe pas, c'est une hypothèse pour l'exemple
  envoyerUnMail($sujet, $message, $valeur);
}

<?php
// Liste d'abonnés
$liste=array(
  'jacques'  => 'jacques@truc.info',
  'Henry'    => 'henry@machin.fr',
  'Mike'    => 'mike@chose.com',
  'Pierre'  => 'pierre@bidule.net'
);
 
// On envoie le même mail à tous les abonnés
// A chaque passage dans cette boucle $clé contient le nom de l'abonné et $valeur l'adresse email de l'abonné
// Initialisation du sujet du mail
$sujet='Joyeuses fêtes';
foreach ($liste AS $cle=>$valeur) {
  // Initialisation du contenu du mail
  $message="Bonjour ".$cle."!".PHP_EOL.PHP_EOL.
    "Le blog ANDEE vous souhaite de joyeuses fêtes de fin d'année!".PHP_EOL;
  // Cette fonction n'existe pas, c'est une hypothèse pour l'exemple
  envoyerUnMail($sujet, $message, $valeur);
}

Dans l’exemple ci-dessous, nous avons envoyé un mail personnalisé à tous les abonnés avec un seul code. Grâce à l’utilisation d’un tableau associatif nous avons réussi à écrire un code simple qui traite une liste d’abonnés et envoie un mail à chacun d’eux.

Les tableaux sont la solution pour traiter des informations en masse avec un code simple et réexploitable.

Maintenant que nous avons parcouru la plupart des types de variables, nous pourrons étudier à partir du prochain article les structures de contrôle et commencer à faire des choses concrètes.

Dans l’article précédent, nous avons défini ce qu’était une variable, une constante. Nous avons également introduit la notion de typage même présenté différents types de variables. Toutefois il existe encore d’autres types très importants en programmation et nous allons tâcher de les présenter dans cet article. Rappel sur les variables

Une variable c’est quoi?

Nous avons vu plus tôt qu’une variable représentait l’association entre un mot et une valeur. Nous avons vu également qu’une variable était définie par son type, qui va déterminer sa taille en octets et la manière de stocker et traiter les données contenues afin d’en interprêter la valeur.

Pour faire plus simple, une variable c’est donc un espace mémoire dédié au stockage d’une valeur auquel on associe un mot (ex: maVariable).

En C une variable se défini ainsi

/* On défini une variable nommée maVariable et on l'initialise avec la valeur 5 */
int maVariable=5;

/* On défini une variable nommée maVariable et on l'initialise avec la valeur 5 */
int maVariable=5;

En PHP une variable se défini ainsi

<?php
/* On défini une variable nommée $maVariable et on l'initialise avec la valeur 5 */
$maVariable=5;

<?php
/* On défini une variable nommée $maVariable et on l'initialise avec la valeur 5 */
$maVariable=5;

En Javascript une variable se défini ainsi

/* On défini une variable nommée maVar et on l'initialise avec la valeur 5 */
var maVariable=5;

/* On défini une variable nommée maVar et on l'initialise avec la valeur 5 */
var maVariable=5;

En Perl une variable se défini ainsi

# On définit une variable nommée maVariable et on l'initialise avec la valeur 5
my $maVariable=5;

# On définit une variable nommée maVariable et on l'initialise avec la valeur 5
my $maVariable=5;

Notez qu’il est important de toujours initialiser (attribuer une valeur) ses variables. Si vous ne le faîtes pas, vous pouvez vous retrouver avec des variables contenant des valeurs inconnues et non maîtrisées qui peuvent planter votre programme.

Un pointeur c’est quoi?

Un pointeur, c’est une variable qui va contenir en guise de valeur, l’adresse d’une autre variable. Par exemple:

En C un pointeur se défini comme suit:
/* On défini un pointeur nommé monPointeur et on le fait pointer vers l'adresse (adresse mémoire) d'une variable. */
int *monPointeur=&maVariable;

En C un pointeur se défini comme suit:
/* On défini un pointeur nommé monPointeur et on le fait pointer vers l'adresse (adresse mémoire) d'une variable. */
int *monPointeur=&maVariable;

Le symbole & indique au compileur que nous ne voulons pas la valeur de la variable (soit 5) mais l’adresse mémoire à laquelle il a rangé cette valeur. Ainsi l’affichage de &maVariable pourrait donner 0x12aec345. (Correspond à une adresse mémoire en 32 bits)

Le symbole * précise que nous ne demandons pas la création d’une variable de type int, mais bien d’un pointeur dont l’adresse de destination va contenir une valeur de type int.

Quel est l’intérêt des pointeurs?

En C les pointeurs sont très utilisés pour donner aux fonctions (que nous étudierons plus tard) l’accès à de grosses quantités de données rapidement. il faut savoir que lorsqu’on appelle une fonction avec en paramètres des variables, nous ne donnons qu’une copie des valeurs contenues dans ces variables à la fonction. Elle ne peut que les utiliser pour faire des calculs ou d’autres copies, mais en aucun cas les modifier. C’est là qu’interviennent les pointeurs.

/* Illustration en C */
/* Dans ma variable Big, je stocke 1Go de données dans un type imaginaire */
monGrosType Big="1 Go de données";
 
/* Si je dois la donner en paramètre d'une fonction */
maFonction(Big);
 
/* le système va d'abord réaliser une copie locale de Big et donc consommer 1Go de mémoire en plus alors que ce n'est pas utile et en prime, il va consommer du temps processeur le temps de copier les 1Go de données. */

/* Illustration en C */
/* Dans ma variable Big, je stocke 1Go de données dans un type imaginaire */
monGrosType Big="1 Go de données";
 
/* Si je dois la donner en paramètre d'une fonction */
maFonction(Big);
 
/* le système va d'abord réaliser une copie locale de Big et donc consommer 1Go de mémoire en plus alors que ce n'est pas utile et en prime, il va consommer du temps processeur le temps de copier les 1Go de données. */

En résumé, nous perdons beaucoup de temps et beaucoup de mémoire pour une opération aussi anodine que l’exécution d’une fonction. Soit quelque chose qui ne devrait pas prendre plus de quelques millisecondes sur un système moderne. Imaginez un peu sur les jeux vidéos moderne la perte de temps que cela représenterai si le système copiait 1Go de donnée à chaque fois qu’un objet se déplace à l’écran en perdant plusieurs secondes. On serait loin des performances connues aujourd’hui.

/* Le même exemple avec un pointeur */
/* P_Big contient la position en mémoire du contenu de la variable Big */
monGrosType *P_Big=&Big;
 
/* Ici ma fonction est prévue pour travailller avec un pointeur */
maFonction(P_Big);
 
/* Elle récupère donc l'adresse contenu dans P_Big soit 4 octets en 32 bits et 8 octets en 64 bits. */

/* Le même exemple avec un pointeur */
/* P_Big contient la position en mémoire du contenu de la variable Big */
monGrosType *P_Big=&Big;
 
/* Ici ma fonction est prévue pour travailller avec un pointeur */
maFonction(P_Big);
 
/* Elle récupère donc l'adresse contenu dans P_Big soit 4 octets en 32 bits et 8 octets en 64 bits. */

Vous admettrez qu’entre 8 octets max et 1Go la différence est toute faîte. Nous gagnons ici un temps processeur précieux et une quantité de mémoire non négligeable.

Les pointeurs sont spécifiques aux langages C et C++. Dans d’autres langages, on parle de référence, mais attention! Même si on retrouve quelques similarité, il ne s’agit pas de la même chose. Bien d’autres usages spécifiques sont réservés aux pointeurs, nous n’avons vu ici que la base.

Une référence c’est quoi?

Une référence est un type de variable qui partage quelques similarités avec les pointeurs, mais qui ne sont pas des pointeurs.

En PHP

<?php
/* Initialise le contenu de $maVariable avec "Beaucoup de blabla" */
$maVariable = "Beaucoup de blabla";
echo $maVariable; // Affichera: Beaucoup de blabla
 
/* Initialise le contenu de $bobVariable avec une copie du contenu de $maVariable */
$bobVariable = $maVariable;
 
echo $bobVariable; // Affichera: Beaucoup de blabla
 
/* Modifie le contenu de $bobVariable */
$bobVariable = "Coucou c'est Bob!";
 
echo $bobVariable; // Affichera: Coucou c'est Bob!
echo $maVariable; // Affichera encore: Beaucoup de blabla
 
/* Initialise le contenu de $totoVariable avec une référence vers $maVariable */
$totoVariable = &$maVariable;
 
echo $totoVariable; // Affichera: Beaucoup de blabla
 
/* Modifie le contenu référencé par $totoVariable */
$totoVariable = "Coucou c'est Toto!";
 
echo $totoVariable; // Affichera: Coucou c'est Toto!
echo $maVariable; // Affichera cette fois: Coucou c'est Toto!
?>

<?php
/* Initialise le contenu de $maVariable avec "Beaucoup de blabla" */
$maVariable = "Beaucoup de blabla";
echo $maVariable; // Affichera: Beaucoup de blabla
 
/* Initialise le contenu de $bobVariable avec une copie du contenu de $maVariable */
$bobVariable = $maVariable;
 
echo $bobVariable; // Affichera: Beaucoup de blabla
 
/* Modifie le contenu de $bobVariable */
$bobVariable = "Coucou c'est Bob!";
 
echo $bobVariable; // Affichera: Coucou c'est Bob!
echo $maVariable; // Affichera encore: Beaucoup de blabla
 
/* Initialise le contenu de $totoVariable avec une référence vers $maVariable */
$totoVariable = &$maVariable;
 
echo $totoVariable; // Affichera: Beaucoup de blabla
 
/* Modifie le contenu référencé par $totoVariable */
$totoVariable = "Coucou c'est Toto!";
 
echo $totoVariable; // Affichera: Coucou c'est Toto!
echo $maVariable; // Affichera cette fois: Coucou c'est Toto!
?>

Nous constatons

• Que lorsqu’on modifie le contenu copié depuis une autre variable, cela n’affecte que le contenu de la copie, l’original reste intact.
• Que lorsqu’on modifie le contenu référencé depuis autre variable, cela affecte le contenu de l’original car il n’y a pas création d’une copie. La zone mémoire pointée par $totoVariable est donc la même que $maVariable.
• Qu’en PHP une référence vers une variable se fait en faisant précéder la variable d’un et commercial ‘&’

En Javascript

// Initialise le contenu de maVar avec Beaucoup de blabla
var maVar = 'Beaucoup de blabla';
 
console.log(maVar); // Affiche: Beaucoup de blabla
 
// Initialise le contenu de $bobVar avec une copie de la valeur de maVar
var bobVar = maVar;
 
console.log(bobVar); // Affiche: Beaucoup de blabla
 
// Modifie le contenu de la variable bobVar avec Salut c'est Bob
bobVar = 'Salut, c\'est Bob!';
 
console.log(bobVar); // Affiche: Salut, c'est bob!
console.log(maVar); // Affiche: Beaucoup de blabla
 
/* Sur un objet à présent les choses diffèrent */
// Initialisation d'un objet vide
var monObj={};
// Initialisation de la propriété contenu avec Beaucoup de blabla
monObj.contenu = 'Beaucoup de blabla';
 
console.log(monObj.contenu); // Affiche: Beaucoup de blabla
 
// Initialisation de l'objet bobObj avec une copie de monObj
var bobObj = monObj;
 
console.log(bobObj.contenu); // Affiche: Beaucoup de blabla
 
// Modification du contenu référencé dans la copie de l'objet
bobObj.contenu = 'Salut c\'est bob!';
 
console.log(bobObj.contenu); // Affiche: Salut, c'est bob!
 
console.log(monObj.contenu); // Affiche: Salut, c'est bob!

// Initialise le contenu de maVar avec Beaucoup de blabla
var maVar = 'Beaucoup de blabla';
 
console.log(maVar); // Affiche: Beaucoup de blabla
 
// Initialise le contenu de $bobVar avec une copie de la valeur de maVar
var bobVar = maVar;
 
console.log(bobVar); // Affiche: Beaucoup de blabla
 
// Modifie le contenu de la variable bobVar avec Salut c'est Bob
bobVar = 'Salut, c\'est Bob!';
 
console.log(bobVar); // Affiche: Salut, c'est bob!
console.log(maVar); // Affiche: Beaucoup de blabla
 
/* Sur un objet à présent les choses diffèrent */
// Initialisation d'un objet vide
var monObj={};
// Initialisation de la propriété contenu avec Beaucoup de blabla
monObj.contenu = 'Beaucoup de blabla';
 
console.log(monObj.contenu); // Affiche: Beaucoup de blabla
 
// Initialisation de l'objet bobObj avec une copie de monObj
var bobObj = monObj;
 
console.log(bobObj.contenu); // Affiche: Beaucoup de blabla
 
// Modification du contenu référencé dans la copie de l'objet
bobObj.contenu = 'Salut c\'est bob!';
 
console.log(bobObj.contenu); // Affiche: Salut, c'est bob!
 
console.log(monObj.contenu); // Affiche: Salut, c'est bob!

Nous constatons

• Que le contenu d’une variable simple est copié mais que les éléments contenus dans les objets sont des références. La zone mémoire pointée par monObj.contenu et bobObj.contenu est donc la même.

En Perl

# Initialise le contenu de $maVar avec Beaucoup de blabla
my $maVar = 'Beaucoup de blabla';
 
# Initialise le contenu de la variable $bobVar avec le contenu de la variable $maVar
my $bobVar = $maVar;
 
print $bobVar."\n"; # Affiche: Beaucoup de blabla
 
# Modification du contenu de la variable $bobVar
$bobVar = "Salut c'est Bob!";
 
print $bobVar."\n"; # Affiche: Salut c'est Bob
 
print $maVar."\n"; # Affiche: Beaucoup de blabla
 
# Initialise le contenu de la variable $totoVar avec une référence vers le contenu de $maVar
my $totoVar = \$maVar;
 
print $$totoVar."\n"; # Affiche: Beaucoup de blabla
 
# Modifie le contenu référencé par $totoVar
$$totoVar = "Salut c'est Toto!";
 
print $$totoVar."\n"; #Affiche: Salut c'est Toto!
 
print $maVar."\n"; #Affiche: Salut c'est Toto!

# Initialise le contenu de $maVar avec Beaucoup de blabla
my $maVar = 'Beaucoup de blabla';
 
# Initialise le contenu de la variable $bobVar avec le contenu de la variable $maVar
my $bobVar = $maVar;
 
print $bobVar."\n"; # Affiche: Beaucoup de blabla
 
# Modification du contenu de la variable $bobVar
$bobVar = "Salut c'est Bob!";
 
print $bobVar."\n"; # Affiche: Salut c'est Bob
 
print $maVar."\n"; # Affiche: Beaucoup de blabla
 
# Initialise le contenu de la variable $totoVar avec une référence vers le contenu de $maVar
my $totoVar = \$maVar;
 
print $$totoVar."\n"; # Affiche: Beaucoup de blabla
 
# Modifie le contenu référencé par $totoVar
$$totoVar = "Salut c'est Toto!";
 
print $$totoVar."\n"; #Affiche: Salut c'est Toto!
 
print $maVar."\n"; #Affiche: Salut c'est Toto!

Nous constatons

• Que lorsqu’on modifie le contenu copié depuis une autre variable, cela n’affect que le contenu de la copie, l’original reste intact.
• Que lorsqu’on modifie le contenu référencé depuis une autre variable, cela affecte le contenu de l’original car il n’y a pas création d’une copie.
• La zone mémoire piontée par $totoVar est donc la même que $maVar.
• Qu’en Perl les références sont appelée en faisant précéder le nom de la variable par un antislash ‘\’
• Qu’en Perl le contenu pointé par une référence s’appelle en faisant précéder le nom de la variable contenant une copie de la référence par un dollar ‘$’

En conclusion de cet article, nous avons étudié les pointeurs qui sont propres en C et les références que vous pouvez retrouver dans de nombreux langages. Les références sont très utilisées dans le monde de la programmation car elles permettent de travailler sur des quantités de données très grandes sans avoir à copier systématiquement des contenus économisant ainsi du temps processeur et de la mémoire. Leur utilisation va bien au delà de ce qui est décrit dans cet article bien entendu, mais il s’agit ici de bases de programmation.

Dans le prochain article nous allons parler des énumérations et des variables tableaux qui sont très utiles en programmation. En attendant, je vous laisse avec un peu de lecture.

Liens et références

• http://fr.wikipedia.org/wiki/Pointeur_%28programmation%29
• http://fr.wikipedia.org/wiki/R%C3%A9f%C3%A9rence_%28programmation%29
• http://boredzo.org/pointers/

Introduction et commentaires

Dans cette série d’articles nous allons voir des bases de programmation. Il est recommandé d’avoir consulté au préalable l’article traitant des données numériques. Les sujets traités seront les variables (types, constantes, tableaux, les pointeurs ou références), les structures de contrôle (boucle, switch, conditions) et les fonctions (déclaration, utilisation). Au delà, les détails propres à chaque langages seront traités dans des articles dédiés à chacun d’entre eux.

Les différents langages traités ici, ne pas du même niveau. En effet, le langage C est un langage bas niveau qui doit être compilé (comprendre transformé) en instruction machine lui donnant ainsi une rapidité d’exécution sans pareil. Les autres langages (Perl, PHP et Javascript) sont pour leur part des langages dits de haut niveau. Chacune de leur instruction est interprété par un programme appelé interpréteur qui peut être au choix, votre navigateur web pour javascript, ou un programme spécifique au langage dans les cas du Perl et de PHP.

Pour information dans les parties code définies comme ci-dessous, vous trouverez des commentaires aidant à la bonne compréhension des codes. Il seront représentés comme suit:

// Ceci est un commentaire (Javascript, PHP, C)
 
/* Il s'agit également d'un commentaire
* Pouvant être rédigé
* Sur plusieurs lignes (Javascript, PHP, C) */
 
# C'est un commentaire aussi (Perl, Shell)

// Ceci est un commentaire (Javascript, PHP, C)
 
/* Il s'agit également d'un commentaire
* Pouvant être rédigé
* Sur plusieurs lignes (Javascript, PHP, C) */
 
# C'est un commentaire aussi (Perl, Shell)

Les commentaires sont des chaînes de caractères (mots, phrases) insérés dans du code de manière à ne pas être interprété. Ils n’ont de valeur que pour les programmeurs, lecteurs du code. Un commentaire n’influencera pas le déroulement d’un programme. Il pourra par contre aider un programmeur reprenant le code d’un autre.

Présentation des variables

En programmation, on appelle variable l’association entre un mot clé (nom de variable) et une (ou plusieurs) valeur pouvant être modifiée au fur et à mesure du déroulement du programme.

Pour ceux qui se sentent déjà perdus, voici un exemple simple en PHP.

<?php
// En PHP les noms variables doivent être précédés du symbole $
// Je renseigne ici ma variable $nomprenom avec un nouveau contenu
$nomprenom='Henry Dupont';
 
// J'utilise ici le contenu de cette variable
// La fonction echo permet d'afficher du texte et le contenu (ASCII, affichable) de certaines variables simples
echo "Salutations $nomprenom";
?>

<?php
// En PHP les noms variables doivent être précédés du symbole $
// Je renseigne ici ma variable $nomprenom avec un nouveau contenu
$nomprenom='Henry Dupont';
 
// J'utilise ici le contenu de cette variable
// La fonction echo permet d'afficher du texte et le contenu (ASCII, affichable) de certaines variables simples
echo "Salutations $nomprenom";
?>

Le code ci-dessus affichera: Salutations Henry Dupont

Si la valeur de la variable $nomprenom venait à être modifié, le même morceau de code affichera le nouveau contenu de $nomprenom.

Cela pourrait permettre par exemple de créer des salutations pour une liste de prénom-nom sans avoir à réécrire le code pour chaque cas de figure.

Une variable peut avoir un contenu bien plus complexe qu’un simple texte et c’est ce que nous allons voir ci-dessous.

Les constantes

En opposition avec les variables, on trouve les constantes qui, comme leur nom l’indique ont un contenu qui ne change pas.

Par exemple, PI est une constante, sa valeur ne changera pas au cours de l’exécution d’un programme. (en tout cas pas sans remettre en cause un certain nombre de choses)

Exemple en Javascript

// Définition de la constante PI
const PI=3.14159265359;
 
// Définition de la variable r (pour rayon)
r=12;
 
// Utilisation de la constante PI avec la variable r
console.log('Circonférence d’un cercle de rayon r: ' + r + '=' + (2*PI*r);

// Définition de la constante PI
const PI=3.14159265359;
 
// Définition de la variable r (pour rayon)
r=12;
 
// Utilisation de la constante PI avec la variable r
console.log('Circonférence d’un cercle de rayon r: ' + r + '=' + (2*PI*r);

L’exemple ci-dessus affichera: Circonférence d’un cercle de rayon r: 12 = 75.39822368616001

Exemple en PHP

<?php
// Définition de la constante PI
define("PI", 3.14159265359);
 
// Définition de la variable r (pour rayon)
$r=12;
 
// Utilisation de la constante PI avec la variable r
echo "Circonférence d’un cercle de rayon r: $r = ".(2*PI*$r);
?>

<?php
// Définition de la constante PI
define("PI", 3.14159265359);
 
// Définition de la variable r (pour rayon)
$r=12;
 
// Utilisation de la constante PI avec la variable r
echo "Circonférence d’un cercle de rayon r: $r = ".(2*PI*$r);
?>

L’exemple ci-dessus affichera: Circonférence d’un cercle de rayon r: 12 = 75,39822368616

Exemple en C

#include <stdio.h>
#include <stdlib.h>
 
/* Pour compiler ce code source:
*       gcc constante.c -o constante.exe
* Pour éxécuter ce programme une fois compilé ./constante.exe (sous UNIX/Linux) ou constante.exe (sous Windows)
*/
 
/* Définition de la constante PI */
#define PI 3.14159265359
 
int main(void) {
        /* Définition de la variable r (pour rayon)
        short int r=12;
        /* Utilisation de la constante PI */
        printf("Circonférence d’un cercle de rayon r: %d = %f\n", r, (float) (2*PI*r));
 
        return EXIT_SUCCESS;
}

#include <stdio.h>
#include <stdlib.h>
 
/* Pour compiler ce code source:
*       gcc constante.c -o constante.exe
* Pour éxécuter ce programme une fois compilé ./constante.exe (sous UNIX/Linux) ou constante.exe (sous Windows)
*/
 
/* Définition de la constante PI */
#define PI 3.14159265359
 
int main(void) {
        /* Définition de la variable r (pour rayon)
        short int r=12;
        /* Utilisation de la constante PI */
        printf("Circonférence d’un cercle de rayon r: %d = %f\n", r, (float) (2*PI*r));
 
        return EXIT_SUCCESS;
}

L’exemple ci-dessus affichera une fois compilé et éxécuté: Circonférence d’un cercle de rayon r: 12 = 75.398224

Exemple en Perl

#!/usr/bin/perl
 
use strict;
use warnings;
# Définition de la constante PI
use constant PI => 3.14159265359;
 
# En Perl, comme en PHP les noms de variable doivent être précédés du symbole $
# Définition de la variable r (pour rayon)
my $r=12;
 
# Utilisation de la constante PI avec la variable r
print "Circonférence d'un cercle de rayon r: $r = ".(2*PI*$r)."\n";

#!/usr/bin/perl
 
use strict;
use warnings;
# Définition de la constante PI
use constant PI => 3.14159265359;
 
# En Perl, comme en PHP les noms de variable doivent être précédés du symbole $
# Définition de la variable r (pour rayon)
my $r=12;
 
# Utilisation de la constante PI avec la variable r
print "Circonférence d'un cercle de rayon r: $r = ".(2*PI*$r)."\n";

L’exemple ci-dessus affichera une fois exécuté: Circonférence d’un cercle de rayon r: 12 = 75.39822368616

Pour une constante il est important que quelqu’un ne puisse pas faire quelque chose comme ça: PI=8.53!!! C’est pour cela que les constantes sont en général définies d’une manière différente des variables.

Typage

Le typage correspond à la définition du type des données à stocker. Il existe différents niveaux de typage dépendants du langage utilisé.

Par exemple on parlera de typage statique un langage bas niveau comme C où le programmeur doit définir à l’avance (début de fonction ou de programme) le type de données qui sera stocké dans la variable (char, int, cf: Article sur les données numériques). Au contraire on parlera plutôt de typage dynamique pour des langages de plus haut niveau (PHP par exemple) qui ne demanderont pas au programmeur de définir à l’avance ses variables ni de spécifier le type des données qui seront stockées.

3 est un nombre. Nombre est un type.

3.1415 est un nombre à virgule. Nombre à virgule est un type.

C est une lettre. Lettre est également un type.

Bonjour est un mot. Mot est aussi un type (en fonction des langages).

-8 est un nombre négatif. Nombre négatif a lui aussi un type pour le représenter.

Déclarez vos variables

Dans l’oeuvre de Douglas Adams Le guide du voyageur intergalactique il est dit que la réponse à la Grande Question sur la Vie, l’Univers et le Reste est 42. Essayons de rentrer le nombre 42 dans une variable et ceci dans différents langages.

En C (typage statique)

 
/* On précise un type numérique adapté */
short int reponse=42;
/* On pourrait également utiliser un type plus large */
int reponse=42;
/* Ou encore plus petit car le nombre est inférieur à 127 */
/* Attention! Dans ce cas de figure le nombre n'est pas stocké sous forme de caractère mais bien sous sa forme numérique */
/* Ce qui donne en hexadécimal: 2A */
/* Le caractère ASCII associé à 2A est * ce qui vous vous en doutez n'a rien à voir avec le contenu que nous venons d'entrer dans cette variable */
char reponse=42;
/* Ici il sera stocké sous forme d'une chaîne de caractère ASCII soit 2 caractères de 8 bits chacun */
/* Soit en hexadécimal:  34 32 */
/* N'étant pas de type numérique, il sera alors impossible de l'utiliser dans des calculs en l'état. */
char reponse[]="42";
/* B est un caractère donc de type char et sera stocké avec son code ASCII : 42 */
char lettre='B';
/* Bonjour est un mot, en C un mot est un tableau de caractères (appelé aussi string)
* Ce tableau (que nous verrons plus en détails dans un autre article) contiendra respectivement les codes ASCII des lettres
* B o n j o u r soit 42 6F 6E 6A  6F 75 72 */
char mot[]="Bonjour";

 
/* On précise un type numérique adapté */
short int reponse=42;
/* On pourrait également utiliser un type plus large */
int reponse=42;
/* Ou encore plus petit car le nombre est inférieur à 127 */
/* Attention! Dans ce cas de figure le nombre n'est pas stocké sous forme de caractère mais bien sous sa forme numérique */
/* Ce qui donne en hexadécimal: 2A */
/* Le caractère ASCII associé à 2A est * ce qui vous vous en doutez n'a rien à voir avec le contenu que nous venons d'entrer dans cette variable */
char reponse=42;
/* Ici il sera stocké sous forme d'une chaîne de caractère ASCII soit 2 caractères de 8 bits chacun */
/* Soit en hexadécimal:  34 32 */
/* N'étant pas de type numérique, il sera alors impossible de l'utiliser dans des calculs en l'état. */
char reponse[]="42";
/* B est un caractère donc de type char et sera stocké avec son code ASCII : 42 */
char lettre='B';
/* Bonjour est un mot, en C un mot est un tableau de caractères (appelé aussi string)
* Ce tableau (que nous verrons plus en détails dans un autre article) contiendra respectivement les codes ASCII des lettres
* B o n j o u r soit 42 6F 6E 6A  6F 75 72 */
char mot[]="Bonjour";

Le langage C est très précis et propose de nombreux types de données pour définir les variables.

En PHP (typage dynamique)

<?php
/* PHP déterminera qu'il s'agit d'un numérique et adaptera le type de la variable en conséquence */
$reponse=42;
 
// Affiche integer ce qui correspond à un entier
echo gettype($reponse)
 
/* Si 42 est entouré de double quotes, PHP l’interprétera alors comme une chaîne de caractères, c'est une forme de typage en PHP */
$reponse="42";
// Affiche string ce qui correspond à une chaîne de caractères
echo gettype($reponse)
 
// Toutefois, si on utilise $reponse défini avec les doubles quotes dans un calcul, celui-ci sera alors interprété comme un nombre */
echo ($reponse + $reponse);    // Affichera 84
?>

<?php
/* PHP déterminera qu'il s'agit d'un numérique et adaptera le type de la variable en conséquence */
$reponse=42;
 
// Affiche integer ce qui correspond à un entier
echo gettype($reponse)
 
/* Si 42 est entouré de double quotes, PHP l’interprétera alors comme une chaîne de caractères, c'est une forme de typage en PHP */
$reponse="42";
// Affiche string ce qui correspond à une chaîne de caractères
echo gettype($reponse)
 
// Toutefois, si on utilise $reponse défini avec les doubles quotes dans un calcul, celui-ci sera alors interprété comme un nombre */
echo ($reponse + $reponse);    // Affichera 84
?>

En Perl (typage dynamique)

/* Perl détermine qu'il s'agit d'une valeur numérique */
my $reponse=42;
 
/* Perl détermine qu'il s'agit d'une chaîne de caractères */
my $reponse="42";
 
// Comme en PHP, utiliser $reponse défini comme une chaîne de caractère dans un calcul interprétera ce dernier comme un nombre.
print ($reponse + $reponse);    # Affichera 84

/* Perl détermine qu'il s'agit d'une valeur numérique */
my $reponse=42;
 
/* Perl détermine qu'il s'agit d'une chaîne de caractères */
my $reponse="42";
 
// Comme en PHP, utiliser $reponse défini comme une chaîne de caractère dans un calcul interprétera ce dernier comme un nombre.
print ($reponse + $reponse);    # Affichera 84

Enfin le cas particulier du Javascript

/* Javascript détermine qu'il s'agit d'une valeur numérique */
var reponse=42;
console.log(typeof(reponse));    // Affichera number
 
/* Javascript détermine qu'il s'agit d'une chaîne de caractères */
my $reponse="42";
console.log(typeof(reponse));    // Affichera string
 
// A la différence de Perl de PHP, Javascript traitera un string en tant que tel, même dans un calcul
console.log((reponse + reponse));    // Affichera 4242, on parle alors de concaténation (à suivre dans un autre article)

/* Javascript détermine qu'il s'agit d'une valeur numérique */
var reponse=42;
console.log(typeof(reponse));    // Affichera number
 
/* Javascript détermine qu'il s'agit d'une chaîne de caractères */
my $reponse="42";
console.log(typeof(reponse));    // Affichera string
 
// A la différence de Perl de PHP, Javascript traitera un string en tant que tel, même dans un calcul
console.log((reponse + reponse));    // Affichera 4242, on parle alors de concaténation (à suivre dans un autre article)

Les signes

Le mot clé unsigned permet de préciser que le type n’est pas signé et ne pourra contenir par conséquent que des valeurs positives allant de 0 à 2^x (où ^x vaut le nombre de bits du type). Un type signé permet lui de contenir des valeurs négatives comme positives allant de -2^(x-1) à 2^(x-1)-1. Pourquoi la valeur positive est diminuée de 1? C’est simple, la valeur 0 est une valeur qu’il faut prendre en compte dans nos calculs car elle existe bien.

Par exemple, un type unsigned char permet de coder des valeurs allant de 0 à 255 soit 256 valeurs. Dans le cas d’un char signé, on ne peut coder que de 256 valeurs également allant de -128 à 127 ce qui nous fait bien 256 valeurs en comptabilisant le 0. Le signe du nombre contenu utilise 1 bit dont la valeur est soit à 0 indiquant que le nombre est positif, soit à 1 indiquant que le nombre est négatif. Pour mieux comprendre, voici un petit exemple utilisant deux signed char de même valeur avec avec un signe différent. Attention! Cet exemple ne tient pas compte de l’architecture endianness un PC ne codera pas la valeur comme dans l’exemple ci-dessous, mais plutôt 11101001₂ soit e9₁₆ (l’ordre des bits est inversé).

Les flottants

Voici un type dédié au stockage des nombre décimaux.

En C il existe plusieurs types de flottant

/* Le flottant à précision simple */
float valeur=12.75;
/* Le flottant à précision double */
double valeur=3.14159265358979323846264338327950288419716939937510582097494459230781640628620899;

/* Le flottant à précision simple */
float valeur=12.75;
/* Le flottant à précision double */
double valeur=3.14159265358979323846264338327950288419716939937510582097494459230781640628620899;

Voici comment les données sont rangées en fonction du type. Une fois encore, ce schéma ne tient pas compte de l’architecture. Garder une lecture de gauche à droite permet de simplifier la présentation de ces types plus complexes..

Le type float

Le type double

Les autres langages traités ici (Perl, Javascript et PHP) ne feront pas de différence. Javascript nous répondra number quoi qu’il arrive, PHP stockera décrétera qu’il s’agit d’un double que nous souhaitions stocker 2.75 ou un nombre avec 50 décimales.

Nous venons de balayer dans cet article les variables simples avec la plupart des types de base utilisés en programmation. Il en existe d’autres plus complexes et plus spécifique dont nous étudierons (pour certain) les détails dans d’autres articles à venir.

Liens et références

En attendant le prochain article, si vous souhaitez vous documenter un peu sur le sujet, voici quelques liens intéressants:

• Article Wikipedia sur le C
• Article Wikipedia sur les types de données du C (en anglais)
• Manuel de programmation en C (en anglais)
• Article Wikipedia sur le Javascript
• Manuel de programmation en Javascript
• Article Wikipedia sur le Perl
• Manuel de programmation en Perl (en anglais)
• Article Wikipedia sur le PHP
• Le manuel de programmation en PHP

Ma documentation préférée reste celle du PHP que je trouve particulièrement bien présentée et facile à comprendre. Pour le reste, je vous souhaite une bonne lecture.