Caractères

Bien qu'utilisant toujours des nombres, les façons de représenter des caractères au sein d'un ordinateur sont nombreuses et variées. Ceci s'explique en général par certaines contraintes techniques liées au domaine d'utilisation.

Une représentation cependant, s'est imposée et reste encore très utilisée de nos jours : le codage ASCII, qui dans ses dernières versions est capable de représenter 256 caractères (un octet est utilisé) dont 95 sont effectivement affichables (les autres étant des caractères de contrôle ou des caractères dits semi-graphiques).

Ce codage est parfait pour l'anglais, mais n'offre pas la possibilité de représenter tous les caractères de toutes les autres langues. Et de toutes façons, le fait de ne pouvoir représenter que 256 symboles impose d'utiliser un autre codage pour des langues telles que le chinois qui possède plusieurs milliers d'idéogrammes. La norme Unicode a été établie pour palier ces manques, mais dans le cadre de ce cours nous ne manipulerons principalement que du codage ASCII.

Nombres

La représentation des nombres est également délicate. Depuis que nous sommes tout petits nous avons appris à compter et à faire la différence entre les différents groupes de nombres.

Le vocabulaire mathématique est très riche dans ce domaine et nous disposons des entiers naturels, des entiers relatifs, des rationnels, des réels et même des nombres complexes.

Chacun de ces groupes contient une infinité de nombres et c'est un des problèmes : tous ne seront pas représentés au sein d'un ordinateur.

Les groupes d'entiers vont être représentables de manière exacte au sein d'un ordinateur (mais n'oublions pas, toujours en nombre limité).

Les nombres qui ne sont pas des entiers soulèvent un autre problème en plus de la limite du nombre d'éléments représentables : la précision de la représentation est également limitée.

Tableau

Le tableau est la structure la plus simple. Elle permet de stocker un nombre prédéfini d'éléments ayant tous le même type. Certains langages de programmation autorisent l'utilisation de tableaux dynamiques dont la taille n'est pas connue a priori et/ou peut varier au cours de l'exécution : c'est le cas du C++.

D'un point de vue de l'organisation de la mémoire, tous les éléments d'un tableau sont stockés les uns à la suite des autres. Ainsi, si l'on connaît l'adresse de la case mémoire représentant le premier élément du tableau et la taille unitaire des données qu'il stocke, il est possible de connaître l'adresse de n'importe lequel de ses éléments.

L'avantage est un accès direct et rapide à n'importe quel élément. Mais une lourdeur apparaît si l'on désire, par exemple, insérer ou retirer un élément au milieu du tableau : il va falloir procéder à des décalages pour faire la place au nouvel arrivant ou pour éviter les trous.

Les tableaux sont en général à une dimension (un vecteur). Cependant les langages de programmation proposent souvent des raccourcis syntaxiques permettant au programmeur d'avoir l'impression qu'il manipule des tableaux à plusieurs dimensions.

Liste chaînée

La liste est une structure complexe, définie comme une suite de cellules qui ont toutes la même organisation interne et qui permettent de stocker un ensemble de données éventuellement hétérogènes. La gestion d'une liste est à la fois plus souple et plus délicate que celle d'un tableau.

Cette souplesse est obtenue via l'adoption d'une organisation mémoire plus complexe que celle des tableaux. En effet, contrairement à ces derniers, toutes les cellules d'une liste ne sont pas forcément contiguës en mémoire : l'adresse de la deuxième cellule n'est plus égale à l'adresse de la première cellule à laquelle on ajoute l'occupation mémoire d'une cellule.

Ceci nécessite d'adopter un mécanisme de chaînage des cellules qui va, pour chacune, préciser quel est la suivante. Chaque cellule va donc contenir une référence (une adresse mémoire) à la cellule suivante. C'est ce point qui est délicat dans la gestion des listes. Une mauvaise gestion des références peut faire perdre une partie de la liste et gaspiller de la mémoire (on parle de fuite mémoire).

Cette organisation empêche donc d'accéder rapidement et directement à une quelconque cellule de la liste : il faut toujours partir de la première et avancer jusqu'à trouver la bonne.

Par contre, l'ajout ou la suppression d'une cellule est bien plus simple puisque cette fois, il n'y a plus besoin de procéder à des décalages, que ce soit dans un sens ou dans l'autre, il suffit de créer une nouvelle cellule en mémoire et de redéfinir quelques références pour la relier logiquement aux autres.

Différents types de listes existent comme les listes doublement chaînées (référence vers la cellule suivante et vers la cellule précédente) ou encore les anneaux (la liste ne se termine jamais, la dernière cellule a une cellule suivante qui est la première cellule.

Arbre

L'arbre est une structure de données que l'on peut imaginer comme une généralisation de la liste chaînée (en fait, il est plus raisonnable d'imaginer la liste comme un cas particulier de l'arbre). Le principe est le même que la liste puisque la structure permet de stocker des données hétérogènes au sein de cellules. Mais cette fois, chaque cellule contient des références à plusieurs cellules que l'on nomme cellules filles. La cellule qui n'a pas de père est appelée cellule racine et une cellule qui n'a pas de fille est appelée feuille.

Les méthodes de traitement particulières aux listes ne s'appliquent pas exactement aux arbres ; des méthodes différentes existent.

L'utilisation des arbres en informatique est très répandue dans le domaine de la recherche d'information (arbre binaire de recherche, arbre de localisation, arbre lexicographique, ...) ou dans la description de parcours logiques (les différents coups à jouer sur un échiquier par exemple).

Graphe

Un graphe est une structure de données organisées en sommets et en arrêtes. Un sommet est éventuellement relié à un autre via une ou plusieurs arrêtes. Les arrêtes peuvent être orientées ou non, pondérées ou non.

Contrairement aux trois structures précédentes, il est très rare, d'un point de vue informatique, de représenter un graphe tel quel. En effet, la gestion de sommets ayant un nombre non fixe de relations, orientées ou non, pondérées ou non, s'avère ne pas être optimale. Pour contourner ce problème des représentation à base de tableaux (matrices d'adjacences) ou de listes (listes d'incidences) ont été imaginées.

D'un point de vue informatique, ce qui est intéressant avec les graphes c'est non pas le fait qu'il puisse stocker des données, mais plutôt qu'il soit très adapté à la modélisation de nombreux problèmes et qu'il existe de nombreux algorithmes permettant de les traiter. Par exemple, un graphe peut représenter un réseau routier et l'algorithme dit du plus court chemin permet de trouver la moyen le plus rapide de se rendre d'un endroit à un autre.

Objet

Le terme d'objet est parfois utilisé pour désigner l'instance d'une classe. La classe reste dans le domaine du conceptuel alors que l'objet lui, est ce qui est manipulé lors de l'exécution du programme.

Attributs

Une classe peut posséder des attributs (ou encore des champs), qui représentent des valeurs, éventuellement de différents types, en nombre choisi par le programmeur.

Notre classe vehicule peut par exemple contenir des attributs comme le nombre de places disponibles, la quantité de carburant dans le réservoir, la vitesse maximale et la consommation horaire.

Méthodes

Une classe propose des méthodes qui permettent de lui faire passer des messages et de nous renvoyer des réponses. C'est par exemple au travers de méthodes que l'on peut accéder à la valeur d'un attribut ou même, qu'il est possible de la modifier. Mais une méthode peut aussi simplement décrire un comportement de notre classe. Par exemple, nous pouvons imaginer avoir une méthode qui permette de mettre un véhicule en route, ou une méthode qui donnerait la quantité de carburant disponible dans le réservoir.

Structure

Une structure peut être vue rapidement comme une classe qui ne possède que des attributs et pas de méthodes. Nous pouvons imaginer que c'est un espace de stockage de données éventuellement hétérogènes mais que l'on désire manipuler comme une seule entité.

Héritage multiple

Parfois, lorsque l'on défini une nouvelle classe et que l'on décide de la faire hériter d'une autre, peut se poser le problème de déterminer de quelle classe il est le plus approprié de partir. Par exemple, la classe hydravion héritera-t-elle de la classe bateau ou de la classe avion ?

Pour répondre à ce problème, certains langages permettent de faire de l'héritage multiple. Notre classe hydravion pourrait donc hériter à la fois des propriétés des avions et des bateaux.

Tous les langages n'autorisent pas cette possibilité. Par exemple, l'héritage multiple est possible en C++ mais n'existe pas en Java.

Protection

Dans l'exemple précédent sur la consommation, nous pouvons légitimement nous demander pourquoi l'utilisateur d'une classe irait faire appel à des méthodes (avec un surcoût en terme de temps d'exécution) plutôt que de lire ou écrire directement les valeurs des attributs, surtout s'il sait à quoi correspondent les valeurs, quelles en sont les unités, etc.

La réponse est que, le concepteur de la classe d'origine aura pris soin de protéger certains attributs et certaines méthodes pour que tout programmeur utilisant cette classe ne puisse pas y accéder directement. Ceci lui permet de proposer une sorte de boîte noire avec quelques boutons en façade dont on sait précisément quel sera le comportement en fonction de l'action que l'on mène dessus. C'est l'interface de la classe.

Pour arriver à cet objectif, il existe différents niveaux de protection pour les méthodes et les attributs :

• private : seule la classe a le droit d'accéder aux attributs et méthodes définis ainsi ;
• protected : seule la classe et ses descendantes ont le droit d'accéder aux attributs et méthodes définis ainsi ;
• public : tout le monde a le droit d'accéder aux attributs et méthodes définis ainsi (en C++ c'est le niveau par défaut lorsque rien n'est précisé).

Types

Les types de base du langage sont les suivants :

char,
short int, unsigned short int,
int, unsigned int,
long int, unsigned long int,
bool,
float,
double,
long double

Il existe également un type nommé void qui signifie l'absence de type. Donc, s'il n'y a pas de type, il n'y a pas de variable ; pourtant, c'est un type fort utile et nous en reparlerons plus loin.

Variables

Une variable est un espace de stockage, une zone de la mémoire de l'ordinateur, qu'il nous est possible de manipuler. Une variable a un type qui est défini au moment de sa création et il n'est pas possible qu'elle en change pendant sa durée de vie.

Le contenu d'une variable peut changer pendant l'exécution d'un programme. C'est d'ailleurs en général le but des variables : stocker une information donnée à un moment donné.

L'exemple suivant nous montre comment déclarer une variable de type double dont le nom est var et comment lui donner une valeur :

double var ;
var = 1.618 ;

Vous remarquerez au passage, que chaque instruction se termine obligatoirement par un pont-virgule et cela pour que le compilateur sâche où elles se terminent.

Bien entendu, il est possible de donner une valeur à une variable au moment de sa création :

double var = 1.618 ;

Les variables ont une durée de vie, c'est à dire qu'elles n'existent pas forcément partout et tout le temps dans notre programme. La règle pour déterminer la durée de vie d'une variable est extrêmement simple :

Une variable a la durée de vie du bloc dans lequel elle est définie.

Reste à définir un bloc pour que nous sachions exactement de quoi nous parlons :

Un bloc est un ensemble d'instructions englobées dans une paire d'accolades.

Nous verrons où et comment utiliser ces blocs. Il suffit de retenir que chaque variable n'existe que dans le bloc dans lequel elle est défini.

Constantes

Il est également possible de définir des constantes. Contrairement aux variables, la valeur d'une constante est censée rester la même du début à la fin du programme.

Les constantes sont de deux types : celles qui sont définies (et non typées) et celles qui sont déclarées (et typées).

La façon de créer une constante déclarée ressemble beaucoup à la façon de créer une variable. Seul l'ajout du mot clé const nous permet de faire la différence. De plus, comme la valeur de cette constante ne peux pas changer, il est nécessaire de l'initialiser au moment de sa création, comme dans l'exemple ci-dessous :

const int nCols = 5 ;
const char separateur = ':' ;

Une constante définie se crée non pas à l'aide d'une variable typée, mais par le biais de la directive du préprocesseur^↓ define (une directive du préprocesseur est toujours introduite par le caractère # en tout début de ligne) :

#define VAL_MAX 20

Ici, notre constante a pour nom VAL_MAX et pour "valeur" 20.

Cette façon de définir des constantes s'apparente, pour le préprocesseur, à faire du rechercher/remplacer. Partout où il va trouver VAL_MAX dans le code source, il va le remplacer par 20, sans vérification que ce soit sur la cohérence de l'expression résultante. Cette vérification est laissée à la tâche du compilateur qui fera de son mieux...

Les tests

Le but ici est de tester une condition. Par exemple, " Est-ce que cet entier est positif ? " ou " Ce mot est il le même que cet autre ? "

Les tests peuvent être plus complexes et présenter une forme de dépendance les uns des autres : " Si le réel b est égal à zéro alors afficher qu'il n'est pas possible de diviser par b, sinon afficher le résultat de la division de a par b. ". Ou encore " Si l'entier est négatif alors ajouter la valeur i à cet entier sinon si l'entier est positif alors retirer la valeurs j à cet entier, sinon ne rien faire ".

Voici un exemple de tests écrit en C++ :

int recentrage(int e, int i, int j)
{
	if ( e < 0 ) {
		e += i ;
		cout << "Ajout de la valeur " << i << endl ;
	} else if ( e > 0 ) {
		e -= j ;
		cout << "Retrait de la valeur " << j << endl ;
	} else {
		cout << "On ne touche plus à rien !" << endl ;
	}
}

Il existe d'autres formes de tests et parmi celles là, la construction switch ... case. En première approche elle peut être considérée comme un écriture différente du classique if ... else if ... else qui prend moins de place. C'est le cas, mais son mode de fonctionnement est en fait très différent et elle permet d'autres souplesses.

la syntaxe de cette construction est illustrée dans le morceau de code suivant :

void testeCaractere(char c)
{
	switch (c) {
		case 'a' :
			// code à exécuter quand c vaut 'a'
			break ;
		case 'b' :
			// code à exécuter quand c vaut 'b'
		case 'c' :
			// code à exécuter quand c vaut 'c'
			// Attention : il n'y a pas d'instruction
			//    break pour le cas 'b'. Cette partie
			//    sera donc également exécutée si
			//    c vaut 'b'
			break ;
		default :
			// code à exécuter quand c ne vaut
			// ni 'a', ni 'b', ni 'c'
	}
}

L'idée ici est de comparer le contenu de la variable présente dans les parenthèses du switch avec les constantes numériques décrites par chacune des étiquettes case. Le fait que ces case soient des étiquettes nous force à utiliser l'instruction d'arrêt break pour montrer l'endroit où le traitement pour ce cas particulier prend fin. Si cette instruction n'est pas présente, alors le code pour ce cas sera exécute, puis le code pour le cas suivant et ainsi de suite jusqu'à ce qu'un break soit rencontré ou que l'on arrive à la fin du bloc du switch.

Il existe un cas particulier optionnel pour désigner l'action par défaut (l'action à envisager si aucun des cas au dessus n'est satisfait). Il est décrit par le mot-clé default.

Les boucles

Les boucles permettent de répéter la même instruction plusieurs fois. Le nombre de fois peut dépendre d'une valeur prédéfinie (" ajouter 1 aux 10 éléments du tableau ") ou dépendre d'une action extérieure (" Tant que l'utilisateur n'a pas relâché la touche, faire avancer mon personnage ").

Voici trois exemples de boucle en C++. Ces trois exemples proposent trois façons de faire la même chose avec les trois structures de boucle existantes en C++.

void afficheListeEntiers(int d, int f)
{
	for (int compteur = d ; compteur <= f ; compteur ++)
	cout << compteur << endl ;
}

void afficheListeEntiers(int d, int f)
{
	int compteur ;

	compteur = d ;
	while (compteur <= f) {
		cout << compteur << endl ;
		compteur ++ ;
	}
}

void afficheListeEntiers(int d, int f)
{
	int compteur ;

	compteur = d ;
	do {
		cout << compteur << endl ;
		compteur ++ ;
	} while (compteur < f) ;
}