C++, Qt, OpenGL, CUDA

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.

^ [[programme_minimal|Chapitre précédent]] ^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ [[histoire|Chapitre suivant]] ^

__ Todo : tabulation, retour à la ligne, quoted.  Caractère spéciaux sous forme hexa.  __

====== Le programme "hello world" ======

Dans le chapitre précédent, vous avez vu la structure de base d'un programme C++ et un aperçu du processus de compilation. Cependant, le code présenté ne faisait rien, ce n'était pas très intéressant. Dans ce chapitre, vous allez voir comment afficher un message.

Pour illustrer cette fonctionnalité en C++, nous allons prendre le programme "hello world" comme exemple. Ce programme permet simplement d'afficher le message "hello, world!". Il est traditionnellement utilisé pour montrer la syntaxe de base d'un langage informatique, ce qui explique qu'il possède son propre nom. Vous pouvez voir sur Wikipédia ce programme dans différents langages : [[http://fr.wikipedia.org/wiki/Liste_de_programme_Hello_world|Wikipédia]].

Le programme //hello world// en C++ est assez proche du programme minimal présenté dans le chapitre précédent. Vous pouvez ouvrir ce code dans [[http://coliru.stacked-crooked.com/a/d4c54f7ea6b23310|Coliru]] et copier-coller le code dans l'éditeur de votre choix.

<code cpp main.cpp>
#include <iostream>

int main() {
    std::cout << "Hello, world!" << std::endl;
}
</code>

Par rapport au code minimal, vous pouvez voir que l'on a ajouté deux lignes. La première ligne, qui contient la directive ''#include'', permet de spécifier des fonctionnalités utilisées par le programme. "iostream" fournit les fonctionnalités de base pour afficher un message et récupérer les textes saisies par l'utilisateur.

La quatrième ligne, commençant par ''std::cout'', permet l'affichage proprement dit. On voit sans problème le message à afficher "hello, world!" en clair dans le code. Vous pouvez vous amuser à changer le texte et voir ce que cela donne. L'instruction ''std::endl'' permet d'indiquer la fin d'une ligne et donc de passer à la ligne suivante (endl pour "end line", "fin de ligne")

Ces deux lignes de code permettent d'utiliser le flux de sortie ''std::cout'' de la bibliothèque standard.

===== La bibliothèque standard =====

Lorsque l'on parle du C++, il faut en fait distinguer deux choses : le langage C++ et la bibliothèque standard. Le langage C++ proprement-dit propose uniquement les fonctionnalités fondamentales indispensables pour écrire un programme. La conséquence est que de nombreuses fonctionnalités ne sont pas intégrées directement dans le langage (même l'affichage d'un message ne fait pas partie du langage).

Heureusement, lorsqu'une fonctionnalité n'existe pas dans le langage, cela ne veut pas dire que l'on ne peut pas utiliser cette fonctionnalité. Il est possible d'écrire des bibliothèques, qui fournissent de nouvelles fonctionnalités utilisables en C++ (ou dans d'autre langages, mais cela sort du cadre de ce cours).

Cela veut dire aussi que si vous créer un programme qui propose des fonctionnalités intéressantes, vous pouvez également créer une bibliothèque pour que d'autres développeurs utilisent vos fonctionnalités (ou que vous puissiez vous même utiliser ces fonctionnalités dans plusieurs de vos programmes. La création d'une bibliothèque sera vu par la suite.

**La bibliothèque standard fait partie intégrante du C++, il est indispensable d'apprendre à l'utiliser en même temps que le langage, l'un ne va pas sans l'autre.**

Pour utiliser une fonctionnalité de la bibliothèque standard, il faut dans un premier temps le spécifier au compilateur, en utilisant la directive de pré-processeur ''#include''. L'une des syntaxes de cette directive est la suivante (il en existe d'autres, mais qui ne seront pas utilisée avec la bibliothèque standard) :

<code cpp>
#include <nom_fichier>
</code>

<note info>**Les directives de pré-processeur**

Une directive de pré-processeur permet de paramétrer le comportement du pré-processeur lors de la compilation. Il existe différentes directives, vous en verrez plusieurs dans ce cours. Une directive s'écrit toujours avec un dièse suivi de la directive et d'éventuels paramètres optionnels.

Il n'est pas possible d'expliquer le fonctionnement de la directive ''#include'' sans expliquer avant le fonctionnement en détail du pré-processeur. Cela sera vu dans un chapitre dédié à la compilation en profondeur.</note>

Pour afficher un message, on utilise un objet particulier de la bibliothèque standard, nommé ''std::cout''. Si vous regardez dans la [[http://en.cppreference.com/w/cpp/io/cout|documentation]], vous voyez au début de la page qu'il est écrit : "Defined in header <iostream>".

{{ :cout.png |}}

Cela vous indique quel fichier il faut inclure pour utiliser ''std::cout'' : le fichier ''iostream'' :

<code cpp>
#include <iostream>
</code>

"iostream" correspond à //**I**nput/**O**utput stream//, ce qui signifie "flux d'entrée et sortie". "Entrée" et "Sortie" doivent être compris du point de vue du programme : "entrée" d'information depuis l'extérieur vers l'intérieur du programme (par exemple saisie d'un texte par l'utilisateur ou la lecture d'un fichier) et "sortie" d'information depuis le programme vers l'extérieur (par exemple afficher un message à l'écran ou enregistrer dans un fichier). Vous verrez juste en dessous pourquoi on parle de "flux".

Lorsque vous utiliserez une fonctionnalité de la bibliothèque standard que vous ne connaissez pas, vous pourrez de la même manière aller rechercher dans la documentation quel fichier inclure. 

===== L'espace de nom std =====

En C++, chaque chose doit avoir un nom unique, pour permettre au compilateur de les identifier correctement. Donner un nom n'est pas très compliqué, vous verrez par la suite les quelques règles à respecter. Lorsque l'on a un petit programme de quelques centaines ou milliers de ligne, cela pose pas trop de problème pour trouver des noms uniques. Mais dans le cas d'un programme de plus grande taille ou utilisant différentes bibliothèques, cela peut devenir très compliqué.

Pour éviter cette contrainte, le C++ permet de regrouper les noms dans un espace dédié : les espaces de noms (//namespace//). En créant un espace de noms, vous évitez les conflits entre les noms, ce qui peut simplifier vos codes. La bibliothèque standard utilise un espace de noms appelé ''std''. Vous apprendrez par la suite à créer des espaces de noms, mais pour l'instant, voyons comment utiliser l'espace de noms de la bibliothèque standard.

Pour utiliser l'objet ''cout'' de la bibliothèque standard, il faut donc préciser que celui-ci provient de l'espace de noms ''std''. Plusieurs solutions sont possibles, selon le contexte. Premièrement, vous pouvez déclarer l'espace de noms ''std'' à chaque utilisation d'une fonctionnalité de la bibliothèque standard, en utilisant l'opérateur ''::'' (comme vous l'avez vu dans les codes précédents) :

<code cpp main.cpp>
#include <iostream>

int main() {
    std::cout << "Hello, world!" << std::endl;
}
</code>

Dans ce cas, il faut faire précéder chaque utilisation de ''cout'' et de ''endl'' avec l'espace de noms.

La deuxième solution est de déclarer que vous allez utiliser une fonctionnalité d'un espace de noms en utilisant le mot-clé ''using''. Lorsque le compilateur rencontre ensuite ''cout'', il saura qu'il faut utiliser l'objet ''cout'' :

<code cpp main.cpp>
#include <iostream>
using std::cout;

int main() {
    cout << "Hello, world!" << std::endl;
}
</code>

Vous pouvez remarquer ici que seul l'objet ''cout'' est déclaré en utilisant ''using''. ''endl'' n'étant pas déclaré de cette manière, il faut l'écrire en utilisant la première syntaxe.

Pour terminer, il est possible d'activer un espace de noms globalement, en utilisant ''using namespace''. 

<code cpp main.cpp>
#include <iostream>
using namespace std;

int main() {
    cout << "Hello, world!" << endl;
}
</code>

Vous remarquez ici qu'il n'est plus nécessaire d'écrire ''std::'' devant ''cout'' et ''endl'' (ou n'importe quelle autre fonctionnalités de la bibliothèque standard).

Cette syntaxe semble intéressante, puisque cela fait gagner du temps. Cependant, cela signifie que l'on perd l'intérêt des espaces de noms : si deux espaces de noms proposent le même identifiant, il y aura un conflit. Le message d'erreur généré par le compilateur ne sera pas forcement explicite, puisqu'il ne détectera pas le conflit d'espace de noms. Les erreurs générés seront du type "déclaration ambiguë" ou "déclaration multiple".

Il est possible de limiter la portée de ''using'' en le déclarant à l'intérieur de la fonction :

<code cpp main.cpp>
#include <iostream>

int main() {
    using std::cout;
    cout << "Hello, world!" << std::endl;
}
</code>

et :

<code cpp main.cpp>
#include <iostream>

int main() {
    using namespace std;
    cout << "Hello, world!" << endl;
}
</code>

Il est préférable de limiter l'utilisation de la syntaxe avec ''using namespace'' et d'utiliser l'un des deux premières déclaration.

===== Les flux standards =====

Si vous avez regardé un peu la documentation de ''std::cout'', vous avez peut-être remarqué qu'il existe d'autres flux de sortie :

  * ''cout'' et ''wcout'' pour les messages standard ;
  * ''cerr'' et ''wcerr'' pour les messages d'erreur ;
  * ''clog'' et ''wclog'' pour les messages de log.

Par défaut, ces flux s'affichent tous dans le terminal, vous pouvez utiliser n'importe lequel. Le programme suivant :

<code cpp main.cpp>
#include <iostream>

int main() {
    std::cout << "le flux cout" << std::endl;
    std::wcout << "le flux wcout" << std::endl;
    std::cerr << "le flux cerr" << std::endl;
    std::wcerr << "le flux wcerr" << std::endl;
    std::clog << "le flux clog" << std::endl;
    std::wclog << "le flux wclog" << std::endl;
}
</code>

affiche :

<code>
le flux cout
le flux wcout
le flux cerr
le flux wcerr
le flux clog
le flux wclog
</code>

Il est possible de faire en sorte de récupérer spécifiquement un flux, par exemple pour l'enregistrer dans un fichier. Certains éditeur de code récupèrent par exemple les messages affichés à l'aide de ''std::cerr'' pour afficher les messages d'erreur.

Même si utiliser n'importe quel flux ne change rien à votre programme (si les flux ne sont pas spécifiquement récupérés), il est préférable de respecter le rôle de chaque flux et d'utiliser ''std::cerr'' pour les messages d'erreur, ''std::clog'' pour les messages d'information et ''std::cout'' pour les messages standards.

<note>**Internationalisation**

Le ''w'' signifie que le flux prend en charge les caractères étendus ("w" pour //wide//), c'est-à-dire les caractères avec accent ou provenant d'un alphabet différent de l'anglais. La gestion de l’internationalisation est un peu complexe en C++, en particulier à cause de la multiplicité des normes de codage et la prise en charge très variable selon le système d'exploitation. Cela fera l'objet d'un chapitre dédié.

Si vous faites le test avec Clang dans Coliru, cela affichera les accents correctement, mais ça ne sera pas toujours le cas (en particulier sous Windows).

<code cpp main.cpp>
#include <iostream>

int main() {
    std::cout << "àâäéèêëîïôöùû" << std::endl;
}
</code></note>

Comment fonctionne un flux ? Imaginer un employé de bureau qui reçoit des dossiers. Il a une grande pile de dossiers, il prend le plus ancien, le traite, puis passe au suivant. Peut importe si les dossiers arrivent un par un ou en paquet, il prend toujours un par un.

Les flux standards fonctionne sur le même principe : il reçoivent des données (les caractères à afficher), ils prennent le premier arrivé, l'affiche puis passent au suivant. L'opérateur permettant d'envoyer des données à un flux est l'opérateur ''<<'' :

<code cpp main.cpp>
#include <iostream>

int main() {
    std::cout << "hello";
}
</code>

Ce code ne doit pas être compris comme signifiant "afficher 'hello'", mais comme "envoyer les caractères 'h', 'e', 'l', 'l' et 'o' dans le flux standard 'std::cout'".

Il est possible d'envoyer plusieurs valeurs en série de données dans un flux, en les séparant par plusieurs opérateurs ''<<'' :

<code cpp main.cpp>
#include <iostream>

int main() {
    std::cout << "hello" << "world";
}
</code>

Ce code signifie "envoyer 'hello' et 'world' dans 'std::cout'", ce qui peut être développé en "envoyer les caractères 'h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd' dans 'std::cout'". (Remarquez l'absence d'espace entre "hello" et "world").

Il revient au même d'envoyer les données sur plusieurs lignes :

<code cpp main.cpp>
#include <iostream>

int main() {
    std::cout << "Hello";
    std::cout << "world";
}
</code>

Voire même d'envoyer les caractères un par un :

<code cpp main.cpp>
#include <iostream>

int main() {
    std::cout << 'h';
    std::cout << 'e';
    std::cout << 'l';
    std::cout << 'l';
    std::cout << 'o';
    std::cout << 'w';
    std::cout << 'o';
    std::cout << 'r';
    std::cout << 'l';
    std::cout << 'd';
}
</code>

Tous les codes précédent affichent :

<code>
helloworld
</code>

===== Les chaînes de caractères =====

Comme vous pouvez remarquer, on distingue en C++ les caractères uniques et les chaînes de caractères (un ensemble de caractères). Un caractère unique sera écrit avec un guillemet simple droit, une chaîne de caractères sera écrite avec des guillemets double droits :

<code cpp main.cpp>
#include <iostream>

int main() {
    std::cout << "hello";  // une chaîne
    std::cout << 'h';      // un caractère
}
</code>

Si vous essayer de mettre plusieurs caractères entre guillemets droits, vous obtiendrez généralement un message d'avertissement. Par exemple, avec Clang dans Coliru :

<code cpp main.cpp>
#include <iostream>

int main() {
    std::cout << 'hello, world!' << std::endl;
}
</code>

affichera :

<code>
main.cpp:4:18: warning: character constant too long for its type
     std::cout << 'hello, world!' << std::endl;
                  ^
1919706145
</code>

Remarquez bien que cela provoque un avertissement (//warning//) et non une erreur : le programme s'exécute quand même. La chaîne est interprétée comme un nombre, qui est affiché en dessous de l'avertissement (''1919706145'' dans l'exemple précédent). Les avertissements signifient que le compilateur ne sait pas si le code contient une erreur ou si c'est intentionnel de la part du développeur.

**Vous ne devez jamais ignorer les avertissements. Dans ce cours, un programme qui affiche des avertissements ne sera pas considéré comme correct.**

Les chaînes de caractères ne sont qu'une suite de caractères, sans aucun sens particulier pour le C++. Cela implique que ce que vous mettez dedans ne sera pas évalué. Si vous écrivez par exemple :

<code cpp main.cpp>
#include <iostream>

int main() {
    std::cout << "std::endl" << std::endl;  // code dans une chaîne
    std::cout << std::endl << std::endl;    // code hors d'une chaîne
    
    std::cout << "1+2" << std::endl;        // expression dans une chaîne
    std::cout << 1+2 << std::endl;          // expression hors d'une chaîne
}
</code>

affiche :

<code>
std::endl


1+2
3
</code>

On voit dans cet exemple simple que les chaînes "std::endl" et "1+2" s'affichent exactement tel quel, alors que le même code en dehors de la chaîne est évalué.

===== Les caractères spéciaux =====

Si vous vous êtes amusé à tester différents messages à afficher, vous avez peut être essayé d'afficher une barre oblique inversée ''\'' (//backslash//) ou des guillemets ''"''. Si ce n'est pas le cas, essayez maintenant :

<code cpp main.cpp>
#include <iostream>

int main() {
  std::cout << "hello " world" << std::endl;
}
</code>

Le compilateur ne va pas du tout aimer ce code et produira des erreurs et avertissements :

<code>
main.cpp:4:30: warning: missing terminating " character
   std::cout << "hello " world" << std::endl;
                              ^
main.cpp:4:3: error: missing terminating " character
   std::cout << "hello " world" << std::endl;
   ^
main.cpp: In function 'int main()':
main.cpp:4:25: error: expected ';' before 'world'
   std::cout << "hello " world" << std::endl;
                         ^

</code>

L'erreur est simple à comprendre avec un peu de logique. En C++, une chaîne de caractères est délimité par des guillemets. Le compilateur va rencontrer le premier guillemet et va l'interprété comme le début d'une chaîne (et donc tout ce qui suit sera considéré comme des caractères faisant partie de la chaîne).

<code>
"hello " world"
^      ^      ^
1      2      3
</code>

Le compilateur continue de parcourir le code et va arriver au second guillemet. Le problème est qu'il ne sait pas qu'il y a encore un guillemet ensuite, il va considérer que ce guillemet est la fin de la chaîne. Tout ce qui suit sera donc considéré comme du code C++ et non comme des caractères à afficher. Or, comme la suite n'est pas du code C++ valide, le compilateur produit une erreur.

Pour résoudre ce problème, il faut pouvoir dire au compilateur que l'on souhaite utiliser le caractère guillemet et non indiquer la fin de la chaîne. Pour cela, il faut utiliser un caractère spécial, le caractère d'échappement ''\''. Ce caractère sera interprété de la façon suivante par le compilateur lorsqu'il est rencontré dans une chaîne : "attention, le caractère suivant est un caractère spécial".

En particulier, le caractère ''\"'' est interprété comme étant le caractère guillemet et non la fin d'une chaîne. Avec cette correction, le code devient :

<code cpp main.cpp>
#include <iostream>

int main() {
  std::cout << "hello \" world" << std::endl;
}
</code>

affiche :

<code>
hello " world
</code>

Remarquez que l'ensemble des deux caractères ''\'' et ''"'' est interprété comme étant un seul caractère.

Un autre problème se présente. Puisque le caractère ''\'' est considéré comme étant le caractère d'échappement, comment afficher le caractère ''\'' dans une chaîne ? La solution est simple, il suffit d'utiliser le caractère '\\'.

Encore une fois, il s'agit bien d'une séquence d'échappement, qui correspond à un seul caractère dans la chaîne et qui est constitué du caractère d'échappement ''\'' puis de l'identifiant ''\''.


<code cpp main.cpp>
#include <iostream>

int main() {
  std::cout << "hello \\ world" << std::endl;
}
</code>

affiche :

<code>
hello \ world
</code>

La liste des séquences d'échappement est donné dans la documentation : [[http://en.cppreference.com/w/cpp/language/escape|Escape sequences]].

===== Les chaînes de caractères brutes =====

Dans certains cas, une chaîne va contenir de nombreux caractères spéciaux (par exemple, le chemin d'un fichier sous Windows, qui peut contenir plusieurs ''\'' ou des expressions régulières). Dans ce cas, il devient fastidieux (c'est pas faux !) de devoir ajouter systématiquement le caractère d'échappement ''\'' devant chaque caractère spécial.

Pour éviter cela, il est possible d'utiliser une chaîne brute, dans laquelle les caractères spéciaux sont ignorés. Une chaîne brute doit commencer (par défaut) par ''R("'' et se terminer par ''")'', tout ce qui trouve entre deux sera interprété comme des caractères à afficher.

<code cpp main.cpp>
#include <iostream>

int main() {
  std::cout << R"(Je fais des " tests pour \ apprendre le C++ !)" << std::endl;
}
</code>

affiche :

<code>
Je fais des " tests pour \ apprendre le C++ !
</code>

Remarquez bien que les parenthèses en début et fin de chaînes (celles correspondantes à ''R("'' et ''")'') ne font pas partie de la chaîne et ne sont pas affichées.

Si vous êtes attentif (et que vous cherchez un peu les problèmes...), vous avez peut être testé un code similaire au suivant :

<code cpp main.cpp>
#include <iostream>

int main() {
  std::cout << R"(Un autre )" test pour apprendre le C++ ! )" << std::endl;
}
</code>

On retrouve le problème précédent, à savoir que l'on a une séquence de caractères dans la chaîne qui est similaire à la séquence de caractères utilisée pour indiquer la fin de la chaîne. Ce code retourne, comme on peut s'y attendre, des erreurs :

<code>
main.cpp:4:30: error: expected ';' after expression
  std::cout << R"(Un autre )" test pour apprendre le C++ ! )" << std::endl;
                             ^
                             ;
main.cpp:4:31: error: unknown type name 'test'
  std::cout << R"(Un autre )" test pour apprendre le C++ ! )" << std::endl;
                              ^
main.cpp:4:40: error: expected ';' at end of declaration
  std::cout << R"(Un autre )" test pour apprendre le C++ ! )" << std::endl;
                                       ^
                                       ;
main.cpp:4:61: warning: missing terminating '"' character [-Winvalid-pp-token]
  std::cout << R"(Un autre )" test pour apprendre le C++ ! )" << std::endl;
                                                            ^
1 warning and 3 errors generated.
</code>

Heureusement, il existe une solution : il est possible d'ajouter une séquence de caractères quelconque dans les guillemets et les parenthèses délimitant la chaîne. Cette séquence de caractères permet de spécifier des délimiteurs différents de n'importe quelle séquence contenu dans la chaîne et donc d'éviter les ambiguïtés. Par exemple :

<code cpp main.cpp>
#include <iostream>

int main() {
  std::cout << R"*(Un autre )" test pour apprendre le C++ ! )*" << std::endl;
}
</code>

affiche le résultat attendu :

<code>
Un autre )" test pour apprendre le C++ ! 
</code>

Ici, la chaîne brute est délimitée par les séquences ''R(*"'' et ''"*)''.

===== Exercices =====

Modifier le code suivant pour afficher les messages demandés. [[http://coliru.stacked-crooked.com/a/e22719dacabeceda|Faire l'exercice]]

<code cpp main.cpp>
#include <iostream>

int main() {
    // Modifier la ligne suivante pour afficher "Bienvenue tout le monde !"
    std::cout << "Hello, world!" << std::endl;
    
    // Ajouter UNE ligne pour afficher "Bienvenue !" et "Tout le monde !" sur DEUX lignes
    std::cout << @@@@
    
    // Ajouter DEUX lignes pour afficher "Bienvenue !" et "Tout le monde !" sur UNE ligne
    std::cout << @@@@
    std::cout << @@@@
    
    return 0;
}
</code>

**Exos** : include, recherche quel include pour utiliser vector ? array ? etc

**Exos** : utiliser tabulation pour afficher un tableau

**Exos** : donner des chaînes à afficher et écrire le code correspondant

**Exos : Afficher un tableau avec bordures**

<code cpp main.cpp>
#include <iostream>

int main() {
  std::cout << "┌────┬────┬────┐" << std::endl;
  std::cout << "│ 12 │ 34 │ 56 │" << std::endl;
  std::cout << "├────┼────┼────┤" << std::endl;
  std::cout << "│ ab │ cd │ ef │" << std::endl;
  std::cout << "└────┴────┴────┘" << std::endl;
}
</code>

affiche :

<code>
┌────┬────┬────┐
│ 12 │ 34 │ 56 │
├────┼────┼────┤
│ ab │ cd │ ef │
└────┴────┴────┘
</code>

Faire pareil, avec double bordure.

**Exos : ASCII art**

===== Aller plus loin =====

^ [[programme_minimal|Chapitre précédent]] ^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ [[histoire|Chapitre suivant]] ^

{{tag> Cours C++}}
C++, Qt, OpenGL, CUDA

Outils d'utilisateurs

Outils du Site

Outils de la Page
