Introduction au langage C++

Chapitres traités    Langage de bas niveau Langage de haut niveau C++ et Compilation Mémorisation d'une donnée en langage de haut niveau Définition d'une instruction et notion d'identificateur Types de données Types de données simples Déclaration d'une variable Déclaration de constantes Limites d'un type Commentaires Programme principal

Langage de bas niveau (langage machine)

Pourquoi le codage binaire ?

Les composants à l'intérieur de l'ordinateur sont des composants électroniques de type numérique. L'information véhiculée entre les composants se propage sur un ensemble de fils de connexion, et c'est cette information qui est numérique. En fait, le système contrôle la présence ou pas d'un courant sur chacun des fils de connexion. La valeur même de l'intensité du courant n'a pas d'importance. Ce qui importe c'est de savoir uniquement si le courant passe ou pas. Nous avons coutume d'utiliser la numération binaire pour représenter cet état de fait. La présence d'un courant est symbolisée par le chiffre binaire 1 et l'absence du courant par le chiffre binaire 0.

Organisation interne :

Si la communication entre les différents composants s'effectue en binaire, cela veut également dire qu'à l'intérieur de tous les composants, tout est structuré de façon binaire. Le µprocesseur s'occupe de réaliser tout un ensemble de traitements élémentaires qui sera déterminé par un programme, et cet ensemble d'instructions élémentaires devra être écrit et stocké dans la mémoire centrale de l'ordinateur. Ce programme est en fait une suite d'instructions écrites en binaire dont chacun des codes correspond à une action spécifique du µprocesseur, comme par exemple, l'opération +. Toutefois, pour que cette simple opération puisse être réalisée, il est nécessaire d'avoir au moins deux opérandes. Donc, cela veut dire que des données doivent être stockées dans un autre endroit de la mémoire centrale de l'ordinateur. Ces données sont également exprimées de façon binaire.

Orientation des langages :

Le premier langage informatique est donc le langage binaire. Seulement, il est très fastidieux d'écrire directement en binaire, surtout qu'il existe un très grand risque de se tromper. Un 1 peut très vite se transformer en 0, ce qui peut avoir des conséquences désastreuses. Pour éviter ces erreurs, l'idée a été d'utiliser le codage hexadécimal qui est en fait une autre façon de représenter le binaire (L'hexadécimal est une concaténation de quatre chiffres binaires). Finalement, que l'on parle du binaire ou de l'hexadécimal, il s'agit de la même chose, c'est-à-dire du langage machine.

Ce langage machine pose un autre problème ; le code correspondant à une instruction d'un processeur ne fonctionne pas nécessairement pour un autre processeur. En effet, chaque processeur possède son propre codage binaire. Du coup, il n'est pas possible de déployer des applications sur des plateformes où les systèmes d'exploitations sont différents (surtout si les machines possèdent des µprocesseurs différents).

L'idée a été donc de proposer des langages de plus haut niveau qui soient d'une part plus proche de la pensée humaine, et qui soient également non tributaire du processeur utilisé.

Langage de haut niveau C++ et Compilation

Le langage C++ est un langage qui s'approche fortement de la pensée humaine et donc plus facilement compréhensible par le programmeur. C'est à la fois un langage structuré mais aussi Orienté Objet. Malgré tout, le seul langage compréhensible par le µprocesseur reste le langage machine. Il faut donc qu'il existe un système qui analyse notre code en langage évolué (fichier source avec l'extension cpp ) et qui le transforme en un code écrit en langage machine (fichier objet avec l'extension obj ). Ce système s'appelle un compilateur et joue donc le rôle de traducteur.

Pour tous les langages de programmation compilés, le code source est toujours un texte. Donc, pour écrire votre programme, un simple éditeur de texte suffit. Toutefois, il sera nécessaire de posséder un compilateur pour réaliser la traduction vers le code binaire (code objet).

Mémorisation d'une donnée dans un langage de haut niveau

Questions par rapport à la structure d'une case mémoire :

Définition d'une instruction et notion d'identificateur

Les identificateurs servent à donner des noms aux variables, types, constantes, fonctions, aux objets, etc. C'est le programmeur qui choisi le nom de l'identificateur, ce qui lui offre une grande souplesse. Toutefois, il existe un certain nombre de limites.

1. Les identificateurs peuvent contenir des lettres minuscules ou majuscules, des chiffres, ou le caractère spécial de soulignement «  _  ». Par contre, ils ne doivent pas commencer par un chiffre ou posséder des lettres accentuées. Pour finir, les espaces ne sont pas admis dans l'identificateur, sinon, cela voudrait dire qu'il en existe plusieurs.
2. Le langage C++ fait une différence entre les minuscules et les majuscules. Attention, c'est généralement une source d'erreur. Par convention, on utilise très souvent les majuscules pour les types et les constantes, alors que les minuscules seront plutôt utilisées pour les variables.

Il existe deux cas de figure où le symbole «  ;  » n'est pas utilisé pour ponctuer une ligne. Le premier, c'est lorsque nous utilisons des directives de compilation. Dans ce cas là, nous demandons au compilateur d'effectuer un traitement particulier avant de commencer la compilation proprement dite. Cela ne correspond donc pas à une instruction du langage C++. Il est facile de reconnaître une directive de compilation, celle-ci est systématiquement précédée du symbole « # ». Le deuxième cas de figure, c'est lorsque nous utilisons des blocs d'instructions comme pour les alternatives, les itératives, les fonctions, etc…

Bloc d'instructions

Le bloc d'instructions correspond à l'action composée en langage algorithmique

Les blocs peuvent être imbriqués

Types de données

Un langage informatique manipule de l'information, comme le terme l'indique. Celle-ci est stockée dans les cases mémoire de l'ordinateur sous forme de bits. Cependant, il est rare que l'on est besoin de manipuler ces bits en tant que tels. En général, on souhaite plutôt utiliser des entités plus sophistiquées, comme des entiers, des réels, des caractères, etc. Chacune de ces entités va elle-même être codée sur un certain nombre de bits dans la mémoire.

Un langage évolué, comme le C++, permet d'utiliser des données de haut niveau, comme des nombres entiers par exemple, en se chargeant lui-même de la basse besogne consistant à convertir les bits de mémoire en ce type de donnée, ou inversement (lors de la compilation).

Types :

Une donnée possède un type qui indique deux choses importantes :

1. l'ensemble des valeurs dont elle fait partie,
2. l'ensemble des propriétés qui la caractérise.

Par exemple le type entier int (abréviation de l'anglais integer), qui est le type le plus utilisé en C++, a pour ensemble de valeurs tous les nombres de -2.147.483.648 à 2.147.483.647 compris (pour ordinateur compatible en compilation 32 bits). Cela correspond à un nombre considérable de valeurs, mais qui comporte tout de même des limites. Ainsi, il n'est pas possible de prendre, par exemple, la valeur réelle 1.5 pour ce type de données. Cette façon de voir fait penser tout à fait, à l'ensemble de définition que l'on utilise en mathématique.

Parmi les propriétés qui le caractérisent, on trouve un grand nombre d'opérations possibles, comme l'addition « + », la soustraction « - », la multiplication « * », la division entière « / » et modulo « % », etc.

Le type réel double a un ensemble de valeurs différent de celles du type int, et certaines opérations comme la division modulo « % » n'ont pas de sens sur ce type. Les propriétés du type double sont donc différentes de celles du type int. On peut dire également que comme pour les mathématiques, la division entière n'a rien à voir avec une division de nombres réels.

Types de données simples

Déclaration d'une variable

Une donnée est une brique élémentaire dans un programme que l'on caractérise par son type, d'une part, et par sa valeur actuelle d'autre part. Nous venons de voir ce qu'est un type; la valeur actuelle de la donnée (par exemple 12 pour un entier) est sujette à modification en général, sous la contrainte qu'elle reste dans l'ensemble de valeurs du type. Par contre, le type de la donnée reste toujours le même; en conséquence, les propriétés d'une donnée, qui sont celles de son type, sont constantes.

Lorsque le programmeur veut utiliser une donnée, il doit :

1. Préciser son type en écrivant le nom de celui-ci.
2. Donner un nom particulier «  identificateur  » à la donnée afin de pouvoir y faire référence.

Sauf précision de la part du programmeur, le contenu de la variable est aléatoire et correspond à la valeur qu'il y avait dans cet emplacement mémoire au moment où on lance le programme.

Utilisation des variables :

Une fois que la variable est déclarée, il est possible maintenant de l'utiliser tout au long du programme. Comme son nom l'indique une variable est une donnée dont la valeur est modifiable au cours du temps. Il sera donc possible d'affecter une nouvelle valeur à cette variable grâce à l'opérateur « = » qui est le symbole de l'affectation. Nous pourrons également effectuer du calcul numérique grâce aux opérations simples « +, -, *, / ».

Déclaration de plusieurs variables dans la même instruction :

Il est possible de déclarer plusieurs variables dans la même ligne de commande. Il suffit alors d'utiliser l'opérateur de séparation qui est l'opérateur « , » dans le langage C++.

float y, resultat ;

Initialisation des variables :

En pratique, il est fréquent que l'on souhaite initialiser une variable, c'est à dire lui donner une valeur dès le départ. En effet, il est important de savoir que lorsqu'on déclare une variable, sa valeur est la plupart du temps indéfinie . En général, ce n'est pas spécialement la valeur nulle «  0  ». Ce point est essentiel, il est très souvent source de nombreuses erreurs.

Une variable peut donc éventuellement être initialisée par une valeur qui soit bien entendue compatible avec le type de la variable. Cette valeur est appelée, constante littérale.

Constantes littérales

Quand une valeur comme 1 apparaît dans un programme, elle est appelée constante littérale : littérale car on ne peut parler d'elle qu'à travers sa valeur, et constante car sa valeur ne peut être changée. Chaque littéral possède un type associé. Par exemple, 0 est de type entier, 3.1459 est une constante littérale de type double.

Exemples  de déclarations de variables :

int x, y=28, z ; // x, y, z : trois variables de type entier signé et y prend la valeur 28 grâce à la constante littérale entière.
char c = ‘A' ; // c : variable de type caractère, prend la valeur ‘A' grâce à la constante littérale caractère.
unsigned short i ; // i : variable de type entier non signé dont la valeur est indéterminée.
double d = 5.23 ; // d : variable de type réel double précision initialisée à 5.23 grâce à la constante littérale double.
bool test=true ; // test : variable de type booleen qui est initialisée à vrai grâce à la constante littérale bool

Déclaration de constantes

Dans un programme, il peut arriver que l'on ait besoin de manipuler des entités qui demeurent constantes. p en mathématique en est un bon exemple, le taux de la TVA en est un autre. Il existe un mot réservé dans le langage C++ qui manipule ces entités, il s'agit de «  const  ». La syntaxe à utiliser est la même que pour les variables, il suffit de rajouter le préfixe const. Cela veut dire qu'une constante correspond également à un type, ce qui permet de conserver la cohérence entre les variables et les constantes.

Exemples  :

const double PI = 3.1415927 ; // PI constante de type double (on utilise généralement les majuscules pour les constantes)
double rayon = 3.0 ; // rayon variable réelle initialisée avec une constante littérale double ( 3.0 ? 3)
double circonference = 2*rayon*PI ; // Il est possible d'avoir une expression à l'initialisation de la variable
const double TAXE = 1.196 ;

Il est plus facile d'utiliser une constante plutôt que les constantes littérales. En effet, imaginez que vous fassiez référence de l'entité p une trentaine de fois dans votre code. Sans la définition de la constante, il faudrait écrire trente fois 3.1415927, ce qui peut être long.

Un autre point important, c'est qu'au cours du temps une constante peut avoir une nouvelle valeur. Prenons l'exemple de la taxe. On peut facilement imaginer que le taux va varier d'une année sur l'autre. Ce qui veut dire que si nous avions un programme qui utilise cinquante fois la constante littérale 1.196 et que le taux change, il faudrait alors changer cinquante fois cette valeur par la nouvelle valeur. En utilisant une constante pour la taxe, lors d'un changement du taux, il suffit de modifier une seule ligne.

Remarque  : Comme son nom l'indique une constante ne peut être modifiée après qu'elle ait été définie
.

const int VALEUR = 12 ;
VALEUR = 45 ; // Erreur de compilation, cette opération n'est pas autorisée puisque VALEUR est constante.

Du coup, cela impose que la constante soit impérativement initialisée, puisque plus tard, il n'est pas possible de lui fournir une valeur.

const double PI ; // Erreur de compilation, PI non initialisée. Cette écriture n'a pas de sens

Limites d'un type

Comme pour l'ensemble de définition que l'on utilise en mathématiques, Il existe un certain nombre de valeurs possibles et d'autres qui ne font pas parties de l'ensemble. Dans le langage C++, il est impératif de connaître toutes les valeurs possibles d'un type et les limites à ne pas dépasser. Prenons l'exemple du type unsigned short.

Remarque : Il est nécessaire de connaître les bornes des données manipulées, notamment pour éviter les problèmes de dépassement lors de calcul avec la variable.
.

unsigned short x = 50000 ; // 50000 valeur autorisée puisqu'elle se situe à l'intérieur des limites.
x = x + 20000 ; // Résultat désiré : x = 70000 (50000 + 20000)
// Résultat obtenu (à cause du dépassement) : x = 4464 (70000-65536)

Commentaires

Le premier type est hérité du langage C. Il peut être introduit à n'importe quel endroit en le faisant précédé du doublon «  /* » et en se terminant par le doublon «  */  ». Il peut alors éventuellement s'étendre sur plusieurs lignes :

Il existe un deuxième type de commentaire qui est propre au langage C++. Il s'agit du commentaire de fin de ligne. La syntaxe utilisée est le doublon «  //  ». Dans ce cas, tout ce qui est situé entre «  //  » et la fin de la ligne est un commentaire. Cette nouvelle possibilité apporte un surcroît de confort et de sécurité. En effet, une ligne telle que :

cout << «bonjour\n » ; // formule de politesse

peut toujours être écrite ainsi :

cout << «bonjour\n » ; /* formule de politesse */

Programme principal

Tout programme C++ doit comprendre au moins une fonction, nommée main (adjectif anglais signifiant  principal ), qui est le point d'entrée du programme en ce sens que le programme commence au début de main et s'arrête à la fin de celle-ci. Une fonction se différencie des autres instructions par la présence de parenthèses. Lorsqu'une fonction n'utilise pas d'arguments, nous ne plaçons rien entre les parenthèses.

Très souvent, un programme C++ débutera par une ou plusieurs directives de compilations «  #include  ». Cette directive permet d'introduire, avant de commencer la compilation proprement dite, un autre texte qui comporte toutes les déclarations nécessaires aux objets que l'on utilise dans le programme principal comme, par exemple cin  et  cout  qui se trouve dans le fichier « iostream.h ». Ces fichiers textes, généralement, ne comportent que les déclarations qui sont utiles au programme. On les appelle des fichiers entêtes (header en anglais, d'où l'extension « h »). Cela permet d'éviter d'écrire systématiquement toujours les mêmes déclarations qui peuvent s'avérer longues et fastidieuses. C'est écrit une fois pour toute, il suffit de proposer une seule ligne d'inclusion.

Il faut préciser que la lecture d'un programme s'effectue toujours de façon séquentielle, c'est-à-dire que le compilateur lit les instructions ligne après ligne en commençant par le haut. Ainsi, tout objet qui est utilisé dans un programme doit toujours être déclaré au préalable. Pour utiliser un élément, il doit être connu.