Plan du site  
pixel
pixel

Articles - Étudiants SUPINFO

Le C++ en bref Part.1

Par Franck MOURET Publié le 31/10/2016 à 10:50:23 Noter cet article:
(0 votes)
Avis favorable du comité de lecture

Introduction :

Le C++ est un langage que l’on rencontre souvent. Et la plupart du temps, on ne s’en rend même pas compte et pourtant il est présent dans beaucoup d’éléments de la vie de tous les jours. A vrai dire on peut presque tout faire avec du C++ comme par exemple : des jeux vidéo, des applications mobiles, des compilateurs, logiciels de gestion.

Présentation :

Lorsque l’on cherche sur Wikipédia, on obtient la réponse suivante : « C++ est un langage de programmation compilé, permettant la programmation sous de multiples paradigmes comme la programmation procédurale, la programmation orientée objet et la programmation générique. Le langage C++ n'appartient à personne et par conséquent n'importe qui peut l'utiliser sans besoin d'une autorisation ou obligation de payer pour avoir le droit d'utilisation. C++ est l'un des langages de programmation les plus populaires, avec une grande variété de plates-formes matérielles et de systèmes d'exploitation. Le langage C++ est normalisé par l'ISO. Sa première normalisation date de 1998 (ISO/CEI 14882:1998).» Et une dernière explication quant à son nom : « En langage C, ++ est l'opérateur d'incrémentation, c'est-à-dire l'augmentation de la valeur d'une variable de 1. C'est pourquoi C++ porte ce nom : cela signifie que C++ est un niveau au-dessus de C. » Du côté technique, il y a plusieurs aspects intéressants à l’utilisation de ce langage : Premièrement le C++ est un langage dit de bas niveau. Ce qui veut dire que son codage se rapproche de celui de la machine : le langage binaire. Cette proximité lui assure une plus grande compatibilité et un plus grand contrôle des actions que l’on veut effectuer (gestion de la mémoire, mettre des données en cache, etc...). Cela implique aussi qu’il y a plus de chances de générer des erreurs. Il existe bien évidemment d’autres langages encore plus proches de ce niveau, comme par exemple le C ou encore l’Assembleur. Ensuite, comme dit plus haut, c’est un langage très populaire, mais surtout il possède une multitude de bibliothèques (C++ Standard Library), et l’on peut également utiliser les bibliothèques du langage C. Ce que l’on désigne par librairie sont en fait des collections des fonctions, que le développeur va utiliser pour lui faciliter le travail dans la conception de ses programmes. Cette utilisation évite aux programmeurs d’avoir à réécrire certaines instructions. Dernier point : son utilisation. C’est un langage multi-paradigmes, ce qui veut dire qu’en développant en C++, il est possible de choisir entre trois approches différentes : programmation procédurale, la programmation orientée objet et la programmation générique.

Premier programme :

Il est temps de rentrer dans le vif du sujet. Lorsque l’on apprend un langage de programmation, le premier exercice que l’on réalise est l’affichage du message « Hello world ». Il s’agit d’un test message de test visant à faire une démonstration rapide d’un langage. Cette tradition fut initiée par le livre de Brian Kernighan et Dennis Richie dans leur livre sur la programmation en langage C. C’est aussi un bon exemple pour commencer à expliquer certains éléments du langage. Dans sa version C++, s’écrit de la manière suivante :

#include <iostream>

int main () {

Std ::count << « Hello World » ! » ;

}

Si tout c’est bien passé, une fenêtre console s’est ouverte, et le message « Hello world » est écrit dedans. Regardons maintenant ligne par ligne ce que ce programme nous dit.

#include <iostream> : Quand une ligne commence par le caractère #, cela veut dire qu’elle va être interprétée par le préprocesseur. Elles sont lues avant la compilation, car elles font souvent référence à des librairies qu’il va falloir inclure au programme. En l’occurrence, on va récupérer le composant iostream qui permet de gérer les entrées et sorties de données.

La fonction main(), qui est une fonction spéciale, puisque que c’est la première fonction qui est appelée lorsque que l’on exécute le programme. Elle peut en outre appeler d’autres fonctions, ou comme dans l’exemple afficher un message.

Std ::count << « Hello World ! » ; : La première partie std ::count va dire au programme de rediriger le résultat vers l’écran pour l’afficher. Le préfixe std veut dire que l’on utilise la librairie standard du C++. Cette librairie est là pour mettre à notre disposition tout un tas d’éléments que l’on peut utiliser dans nos programmes. La deuxième partie << est interprétée comme devant insérer le message « Hello world » dans le std ::count. Enfin, la ligne se termine par un « ; » pour signifier au programme la fin de cette instruction. Cette ponctuation doit revenir à la fin de chaque instruction, si on ne veut pas voir d’erreur de syntaxe (ce qui empêchera le programme de fonctionner).

Lorsque que l’on regarde le code que l’on vient d’écrire, on peut s’apercevoir que toutes les lignes ne commencent pas au même endroit. Certaines sont plus en retrait que d’ autres, cela s’appelle l’indentation. Le fait de disposer son code de cette manière ne pose aucun problème aux compilateurs, puisque ces derniers vont interpréter le code de la même manière que l’on dispose comme nous l’avons fait ou non.

Les tabulations vont nous permettre d’avoir une meilleure compréhension du code. De bien séparer chacune de nos instructions. Cela devient très vite nécessaire lorsque notre programme va commencer à devenir plus consistant.

En C++ comme dans beaucoup de langage, la fin d’une instruction est signifiée par la présence d’un point-virgule (;).

Les seules instructions échappant à cette règle, sont celles qui concernent le préprocesseur. Il s’agit des lignes qui se trouvent au tout début de notre code et qui commencent par un dièse (#). Si on ajoute un point-virgule à cet endroit, notre compilateur retournera une erreur.

Les commentaires :

Ils ne changent pas le comportement de notre programme. Les commentaires servent à apporter des précisions sur le code ou des explications sur ce que l’on a voulu faire. Cela s’avère pratique surtout dans deux cas :

- Si quelqu’un doit reprendre notre code, ils vont l’aider à comprendre plus facilement ce que l’on a fait.

- Quand on veut reprendre un code que l’on n’a pas touché depuis longtemps. Les commentaires nous permettent de nous remémorer ce que l’on a voulu faire.

Il existe deux types de commentaires :

- Ceux sur une ligne, qui s’arrêtent si l’on retourne à la ligne et que l’on rencontre sous la forme suivante :

// Ceci est un commentaire sur une ligne

Et les commentaires sur plusieurs lignes :

/*

Je Suis un commentaire

Sur plusieurs Lignes

*/

Les variables :

Le langage C++ est ce que l’on appelle un langage typé. Ce qui veut dire que chacune des données que l’on va utiliser doit correspondre à un type. Cela permet de savoir quelle place peut lui être allouée en mémoire, mais aussi quelles valeurs peuvent lui être attribuées.

Les valeurs de nos variables sont stockées quelque part dans la mémoire de notre ordinateur sous une forme binaire, c’est-à-dire quelles existent sous forme de uns et de zéros.

Lorsque que l’on veut définir une variable, on lui attribue un type. Cela va permettre au programme de savoir quelle quantité de mémoire il va devoir réserver pour stocker les données que l’on va lui donner et pour nous de savoir le type de données que l’on va mettre dedans.

Ces types de données peuvent être classés en quatre grandes familles :

- Le type caractère : qui représente un caractère unique comme un ‘b’ ou un ‘$’ et que l’on va souvent rencontrer sous la forme d’un type « char » codé sur un octet et qui ne prend qu’un caractère à la fois.

- Le type numérique : que l’on utilise pour stocker nombres entiers, tel que 7 ou 42. Il est capable de prendre des valeurs positives ou négatives. Et peut-être de type signé ce qui lui permet d’utiliser des valeurs positives et négatives ou de type non-signé qui ne contiendra que des valeurs positives.

- Le type booléen : Le type booléen se déclare sous la forme : bool et permet de vérifier le résultat d’une condition est vrai ou faux. Il s’agit d’un type particulier car il ne prend que deux valeurs : true, false (que le compilateur comprend comme 0 pour « true » et 1 pour « false ») et n’a pas de taille spécifiée.

Pour assigner lui une valeur :

bool a = true ;

- Le type Float / Double : Nous avons vu que les « integer » ne peuvent pas contenir de nombres à virgules. Pour stocker ces variables, nous avons deux possibilités :

- Le « float », codé sur 4 octets, pour les types flottants de petite taille (six chiffres après la virgule).

- Le « double », codé sur 8 octets on l’utilise pour les types flottants supérieurs ou égal au « float » (quinze chiffres après la virgule). On les utilise de la manière suivante :

float a = 0.45 ;

double b = 0.5854876 ;

Integer :

Le type « integer » que l’on abrège par : int est le type que l’on utilise pour le stockage des entiers et il ne peut donc pas stocker de nombres à virgule (il existe un autre type pour cela que nous verrons après) ou de caractères. Il est codé sur quatre octets pour les processeurs 16bits et sur 4 octets pour les processeurs 32bits. Il existe sous deux formes, « signed int » (équivalent de int) et « unsigend int ».

On le déclare de la manière suivante :

Int a = 5 ;

Long :

Le type long, ou « long int » est un « integer » de valeur égale ou supérieur à l’integer vue précédemment.

Il se déclare :

long = 2 147 483 648 ; //(ici le maximum de notre « integer » +1)

Character :

Les « char » est le type qui peut contenir les données de type caractères. Ce sont généralement ceux de la table ASCII. Il est codé sur 1 octet. Tout comme le type « integer » il existe sous la forme « signed char » (de -127 à 127 caractères) ou « unsigned char » (de 0 à 255 caractères).

Une variable de type « char » ne stocke qu’un seul le caractère.

On le retrouve sous cette forme :

char a = ‘z’ ;

String :

Le type string est une variable qui permet de stocker des chaînes de caractères, comme des mots ou des phrases, ce qui s’avère souvent très pratique. Cependant, il n’est pas exactement pareil que les types précédents. Tout de suite, on remarque, que pour pouvoir l’utiliser, on est obligé d’inclure l’entête : #include <string>.

#include <iostream>

#include <string>

int main () {

std::string myString;

std ::myString = "Ceci est ma chaine de caracteres. ";

return 0;

}

Les types décrits ci - dessus (caractères, entiers, en virgule flottante, et booléen) sont ce que l’on appelle des types arithmétiques. Mais il existe deux autres types supplémentaires : void qui identifie le manque de type; et le type nullptr, qui est un type spécial que l’on verra avec les pointeurs.

Déclarer des variables :

Le langage C++ étant un langage possédant un fort typage, il est obligatoire de déclarer la variable et son type avant de pouvoir l’utiliser. Un fois de plus si on ne fait pas cette déclaration, le compilateur va retourner une erreur. Déclarer ces variables ainsi que leur type permet au compilateur de savoir quelle taille il va devoir réserver en mémoire et comment il va devoir se comporter lors de son traitement. La déclaration des variables en C++ est très simple et possède la même syntaxe que la plupart des langages de programmation, il suffit de déclarer le type suivit du nom de notre variable sans oublier bien entendu d’ajouter un point-virgule après.

int i ;

Cette déclaration va créer une variable de type integer appeler « i ».

Si l’on a besoin de déclarer plusieurs variables possédant un même type, on peut très bien le faire de la manière suivante :

int i;

int j;

int k;

Ou d’une manière plus rapide, en les regroupant toutes dans une déclaration unique en les séparant par une virgule :

int i, j, k ;

Ces deux déclarations seront interprétées de la même manière par le compilateur.

Initialisation de variables :

Lorsque l’on déclare une variable, on lui permet « d’exister ». Ce qui va se passer, c’est que tant que l’on a pas initialiser notre variable, on ne fait que réserver un emplacement en mémoire qui à pour valeur ce qui se trouvait là avant. Mais on ne sait pas vraiment ce qu’elle vaut. Pour remédier à ça, on va lui affecter une valeur. On appelle ça l’initialisation.

Pour initialiser une variable il suffit d’attribuer une valeur à notre variable précédemment créer.

int i = 7 ;

Si l’on fait le test, notre variable aura bien la valeur que l’on vient de lui attribuer.

#include <iostream>

int main () {

int i; i = 7;

std::cout << i;

return 0;

}

Portées d’une variable :

Pour le moment, lorsque nous avons déclaré des variables nous ne nous sommes jamais souciés de leur portée. Et pourtant, lorsque l’on définit une variable, cette dernière ne peut agir que dans ce que l’on appelle son « scope ». Et suivant là où l’a défini cette portée (ou visibilité) n’est pas la même. Par exemple si elle est créée dans une fonction, on ne peut y accéder depuis une autre fonction.

On distingue deux comportements, les variables dites globales que l’on déclare dans une fonction avant le bloc d’instruction et qui est utilisable par n’importe lequel des blocs contenus dans notre fonction. Et la variable locale, qui est déclarée dans un bloc d’instruction et qui ne peut être utilisée en dehors de ce bloc.

Les variables constantes :

Synthaxe : #define identifier replacement

Ces variables possèdent la particularité de ne pas changer de valeur tout au long du programme. Pour définir une variable de ce type, il suffit de la précéder par la directive de préprocesseur : #define. Lorsque l’on emploi ce mot clef, toute les occurrences de la variable définie seront remplacées par la valeur déclarée.

#include <iostream>

#define PI 3.14159

int main () {

PI = 10;

std::cout << PI;

}

Ce code ne compilera pas tant que la ligne PI = 10 ; ne sera pas retiré du programme. Une petite remarque concernant le #define, il s’agit d’une instruction pour le préprocesseur, elle ne prend donc pas de point-virgule à la fin.

Le problème de l’utilisation de constante est qu’il n’est pas typé. Remplacez : 3.14159 par n’importe quelle chaine de caractère ou nombre entier, votre code compilera sans problème. C’est pourquoi, lors de la définition de la définition de cette variable, on peut ajouter le mot clef : const. Notre variable reste non modifiable pour l’ensemble du programme, mais elle devient typée, elle ne peut donc plus recevoir n’importe quel type de données.

cont float PI = 3.14159;

Les Opérateurs

Maintenant que l’on a vu les variables et les constantes il est temps de commencer à voir comment on peut travailler avec. Les opérateurs sont ce qui va nous permettre de les manipuler un peu. Pour le moment le seul que l’on ait vu est l’opérateur « = » avec lequel nous avons assigné une valeur à nos variables. Mais il existe d’autres opérateurs nous permettant d’effectuer d’autre opérations.

L’opérateur « = », est donc l’opérateur d’affectation. Il nous permet d’affecter une valeur à une variable que celle-ci soit de type string, int, char, float, etc… Son affection se fait toujours de droite à gauche, qu’il s’agisse d’une initialisation ou de variable entre elles.

#include <iostream>

int main ()

{

int i = 5;

std::cout << i << “\n”; //La \n est le caractère utilisé pour le retour à la ligne

int j = 7;

i = j;

std::cout << i;

}

Ici, on assigne la valeur 7 a « j » puis « j » à « i », la valeur de « i » est donc 7.

Une affectation peut aussi être utilisée pour afficher un résultat.

Les opérations d'affectation sont des expressions qui peuvent être évaluées. Par exemple :

i = 7 + ( j = 8) ;

Il est tout à fait possible de faire des additions de valeurs lors d’une affectation. Dans cette expression, j vaut 7 + 2 (qui est la valeur de i). Donc j vaut 9.

i = 7 ;

j = i + 2 ;

L'expression suivante est également valable en C ++:

j = i = k = 7 ;

Il attribue 5 aux trois variables: j, i et k; Toujours de droite à gauche.

Opérateurs arithmétiques :

Le langage C++ est tout à fait capable de traiter les 5 opérateurs classiques que sont l’addition (+), la soustraction (-), la multiplication (*), la division (/) et le modulo (%).

En ce qui concerne les quatre premiers, leur utilisation n’est pas très compliquée, puisqu’ils fonctionnent de la même manière en programmation que dans les mathématiques.

En ce qui concerne le modulo, il s’agit du reste de la division euclidienne, le reste de la division d’un chiffre par un autre. Plus simplement et très grossièrement, il s’agit de savoir combien de fois un chiffre existe dans notre valeur.

7%3 = 1

2*3 = 6 + 1 = 7

3 existe deux fois dans 7, il ne reste nous reste 1. Il s’agit donc du résultat de notre modulo.

Affectations composées :

Les opérateurs d'affectation composés modifient la valeur courante d'une variable en effectuant une opération sur elle-même. Ils reviennent à assigner le résultat d'une opération à la première variable :

i += j ;

Ce qui revient à écrire i = i + j ;

Et cela vaut quel que soit l’opérateur utilisé.

i -= j ;

Ce qui équivaut à écrire i = i - j ;

i /= j ;

Ce qui équivaut à écrire i = i / j ;

i *= j ;

Ce qui équivaut à écrire i = i * j ;

Incrémentation et décrémentation :

Ces opérations servent à augmenter ou diminuer une valeur stockée dans une variable. Jusqu’à maintenant, on écrivait cette opération de la manière suivante :

i = i + 1 ;

Ou encore

i +=1 ;

Ce qui permet d’augmenter la valeur de i de plus un à chaque fois. Mais il existe une manière raccourcie pour écrire ces expressions, il s’agit de :

i++ ;

Une particularité de cet opérateur est qu'il peut être utilisé comme un préfixe ou un suffixe. Cela signifie qu'il peut être écrit avant le nom de la variable (++i) ou après (i++). Bien que dans des expressions simples comme i++ou ++i, les deux ont exactement le même sens ; dans d’autres expressions dans lesquelles le résultat de l'opération d'augmentation ou la diminution est évaluée, ils peuvent avoir une différence importante dans leur sens : Dans le cas où l'augmentation de l'opérateur est utilisée comme un préfixe (++i) de la valeur, l'expression une fois qu'elle est déjà augmentée. D'autre part, dans le cas où il est utilisé comme un suffixe (i++), la valeur est également augmentée, mais l'expression est évaluée à la valeur que X avait avant d’être augmenté. Notez la #include <iostream>

int main () {

int i = 5;

int y;

std::cout << i << "\n";

y = ++i; std::cout << y;

}

Affiche 5 et 6.

#include <iostream>

int main ()

{

int i = 5;

int y;

std::cout << i << "\n";

y = i++;

std::cout << y;

}

Affiche 5 et 5.

Opérateurs relationnels et de comparaison :

Ces opérateurs sont là pour permettre d’effectuer des comparaisons ou vérifier une égalité entre différents éléments.

Ces opérateurs relationnels sont les suivants :

== : égal à

!= : n’est pas égal à

> : est plus grand que

< : est inférieur à

<= : inférieur ou égal à.

>= : supérieur ou égal à.

Si dès fois il vous arrive de douter de l’emplacement de l’opérateur =, sachez qu’il est toujours positionné à droite.

Il est possible d’évaluer des entiers :

(7 >= 5)

(7 == 5)

(7 != 5 )

Il est bien entendu possible d’évaluer des variables le résultat d’opérations.

(i == 7)

(i * j >= a)

Attention cependant à une chose ! L'opérateur d'affectation (opérateur =, avec un signe égal) n’est pas le même que l'opérateur de comparaison d'égalité (opérateur ==, avec deux signes égal); le premier ( =) affecte la valeur de droite à la variable située sur sa gauche, alors que l'autre ( ==) compare si les valeurs des deux côtés de l'opérateur sont égales.

Les opérateurs logiques :

Les opérateurs logiques sont typiquement utilisés avec des valeurs booléennes (logiques) ; lorsque c'est le cas, ils renvoient une valeur booléenne également. Cependant, les opérateurs && et || renvoient en réalité la valeur d'un des opérandes spécifiés. Si ces opérateurs sont utilisés avec des valeurs non booléennes, ils peuvent donc également renvoyer une valeur non booléenne.

Les opérateurs && correspond à l’opérateur logique ET quand à || il correspond à OU.

L’opérateurs est utilisé pour l’évaluation de deux expressions. Regardons les résultats attendus pour l’opérateur ET :

Table 1. && OPÉRATEUR (et)

a b a && b
true true true
true false false
false true false
false false false


Une remarque importante concernant l’opérateur logique &&. Le C++ évalue les expressions de gauche à droite et si la première expression qu’il trouve équivaut à « false », il passe à la suite sans évaluer l’autre expression.

L'opérateur ||correspond à l'opération logique booléenne OU, qui donne true si l’un de ses opérandes est true. Voici les résultats possibles de a||b:

Table 2. || OPÉRATEUR (ou)

a b a || b
true true true
true false true
false true true
false false false


Une remarque importante concernant l’opérateur logique OU. Si la première expression qu’il trouve équivaut à « true », il passe à la suite sans évaluer l’autre expression.

((7 == 7) || (7 > 10)) Le premier cas étant vrai, le compilateur ne prendra pas la peine d’évaluer l’expression (7> 10). On appel cette manière de fonctionner, l’évaluation court-circuit.

Webographie :

https://fr.wikipedia.org/wiki/C%2B%2B

http://alp.developpez.com/tutoriels/debuter-cpp/

https://openclassrooms.com/courses/programmez-avec-le-langage-c/

http://www.cplusplus.com/

Livres :

Pour les nuls – C++

Editions Eyrolles – Programmer en C++

A propos de SUPINFO | Contacts & adresses | Enseigner à SUPINFO | Presse | Conditions d'utilisation & Copyright | Respect de la vie privée | Investir
Logo de la société Cisco, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société IBM, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société Sun-Oracle, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société Apple, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société Sybase, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société Novell, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société Intel, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société Accenture, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société SAP, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société Prometric, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société Toeic, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo du IT Academy Program par Microsoft, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management

SUPINFO International University
Ecole d'Informatique - IT School
École Supérieure d'Informatique de Paris, leader en France
La Grande Ecole de l'informatique, du numérique et du management
Fondée en 1965, reconnue par l'État. Titre Bac+5 certifié au niveau I.
SUPINFO International University is globally operated by EDUCINVEST Belgium - Avenue Louise, 534 - 1050 Brussels