Structure d’un programme dans C++
Le meilleur moyen d’apprendre un langage de programmation consiste à écrire des programmes. Typiquement, le premier programme que les débutants écrivent est un programme appelé « Hello World », qui affiche simplement « Hello World » sur l’écran de votre ordinateur. Bien que très simple, il contient tous les composants fondamentaux des programmes C ++:
// Mon premier programme en C++
#include <iostream>
int main()
{
std::cout << "Hello World!";
}Examinons ce programme ligne par ligne:
Ligne 1: // Mon premier programme en C ++
Deux barres obliques indiquent que le reste de la ligne est un commentaire inséré par le programmeur mais qui n’a aucun effet sur le comportement du programme. Les programmeurs les utilisent pour inclure de brèves explications ou observations concernant le code ou le programme. Dans ce cas, il s’agit d’une brève description introductive du programme.
Ligne 2: #include <iostream>
Les lignes commençant par un signe dièse (#) sont des directives lues et interprétées par ce que l’on appelle le préprocesseur. Ce sont des lignes spéciales interprétées avant la compilation du programme lui-même. Dans ce cas, la directive #include <iostream> demande au préprocesseur d’inclure une section de code C ++ standard, appelée en-tête iostream, qui permet d’effectuer des opérations d’entrée et de sortie standard, telles que l’écriture de la sortie de ce programme (Hello World). ) à l’écran.
Ligne 3: int main ()
Cette ligne lance la déclaration d’une fonction. Essentiellement, une fonction est un groupe d’instructions de code ayant un nom: dans ce cas, cela donne le nom « main » au groupe d’instructions de code qui suit. Les fonctions seront discutées en détail dans un chapitre ultérieur, mais leur définition est introduite par une succession de type (int), un nom (main) et une paire de parenthèses (()), éventuellement avec des paramètres.
La fonction nommée main est une fonction spéciale de tous les programmes C ++. c’est la fonction appelée lors de l’exécution du programme. L’exécution de tous les programmes C ++ commence par la fonction principale, quel que soit son emplacement réel dans le code.
Lignes 4 et 6: {et}
L’accolade ouverte ({) à la ligne 5 indique le début de la définition de la fonction main, et l’accolade de fermeture (}) à la ligne 7, indique sa fin. Tout ce qui se trouve entre ces accolades est le corps de la fonction qui définit ce qui se produit lorsque l’on appelle main. Toutes les fonctions utilisent des accolades pour indiquer le début et la fin de leurs définitions.
Ligne 5: std :: cout << « Hello World! »;
Cette ligne est une instruction C ++. Une déclaration est une expression qui peut réellement produire un effet. C’est la viande d’un programme, spécifiant son comportement réel. Les instructions sont exécutées dans le même ordre où elles apparaissent dans le corps d’une fonction.
Cette déclaration comporte trois parties: Premièrement, std :: cout, qui identifie le périphérique de sortie de caractères standard (généralement, l’écran de l’ordinateur). Deuxièmement, l’opérateur d’insertion (<<), qui indique que ce qui suit est inséré dans std :: cout. Enfin, une phrase entre guillemets (« Hello world! ») Est le contenu inséré dans la sortie standard.
Notez que l’instruction se termine par un point-virgule (;). Ce caractère marque la fin de la déclaration, tout comme le point termine une phrase en français. Toutes les instructions C ++ doivent se terminer par un point-virgule. L’une des erreurs de syntaxe les plus courantes en C ++ consiste à oublier de terminer une instruction par un point-virgule.
Vous avez peut-être remarqué que toutes les lignes de ce programme n’effectuent pas d’actions lorsque le code est exécuté. Il y a une ligne contenant un commentaire (commençant par //). Il y a une ligne avec une directive pour le préprocesseur (commençant par #). Il y a une ligne qui définit une fonction (dans ce cas, la fonction main). Et, enfin, une ligne avec une instruction se terminant par un point-virgule (l’insertion dans cout), qui se trouvait dans le bloc délimité par les accolades ({}) de la fonction principale.
Le programme a été structuré en différentes lignes et correctement mis en retrait, afin de le rendre plus facile à comprendre pour les humains qui le lisent. Mais C ++ n’a pas de règles strictes sur l’indentation ou la division des instructions en différentes lignes. Par exemple, au lieu de
int main ()
{
std::cout << " Hello World!";
}Nous aurions pu écrire:
int main () { std::cout << "Hello World!"; }tout en une seule ligne, et cela aurait eu exactement la même signification que le code précédent.
En C ++, la séparation entre les instructions est spécifiée par un point-virgule de fin (;), la séparation en différentes lignes n’ayant aucune importance à cet effet. Plusieurs instructions peuvent être écrites sur une seule ligne ou chaque instruction peut être dans sa propre ligne. La division du code en différentes lignes ne sert qu’à le rendre plus lisible et plus schématique pour les humains qui peuvent le lire, mais n’a aucun effet sur le comportement réel du programme.
Ajoutons maintenant une déclaration supplémentaire à notre premier programme:
// mon deuxième programme en C ++
#include <iostream>
int main ()
{
std :: cout << "Hello World!";
std :: cout << "Je suis un programme C ++";
}Dans ce cas, le programme a effectué deux insertions dans std :: cout dans deux instructions différentes. Une fois encore, la séparation dans différentes lignes de code donne simplement une plus grande lisibilité au programme, car main aurait pu être parfaitement valide ainsi défini:
int main () { std::cout << " Hello World! "; std::cout << " Je suis un programme C ++ "; }Le code source aurait également pu être divisé en plusieurs lignes de code:
int main ()
{
std::cout <<
"Hello World!";
std::cout
<< "Je suis un programme C ++";
}Et le résultat aurait encore été exactement le même que dans les exemples précédents.
Les directives de préprocesseur (celles commençant par #) ne font pas partie de cette règle générale car elles ne sont pas des instructions. Ce sont des lignes lues et traitées par le préprocesseur avant que la compilation appropriée ne commence. Les directives de préprocesseur doivent être spécifiées dans leur propre ligne et, comme elles ne sont pas des instructions, ne doivent pas nécessairement se terminer par un point-virgule (;).
Les commentaires
Comme indiqué ci-dessus, les commentaires n’affectent pas le fonctionnement du programme; Cependant, ils fournissent un outil important pour documenter directement dans le code source ce que le programme fait et comment il fonctionne.
C ++ prend en charge deux manières de commenter le code:
// line comment
/* block comment */
Le premier d’entre eux, appelé commentaire de ligne, supprime tout depuis l’endroit où se trouve la paire de signes de barre oblique (//) jusqu’à la fin de cette même ligne. Le second, appelé commentaire de bloc, supprime tout ce qui se trouve entre les caractères / * et la première apparition des caractères * /, avec la possibilité d’inclure plusieurs lignes.
Ajoutons des commentaires à notre deuxième programme:
/* mon deuxieme programme en C++
avec plus de commentaire */
#include <iostream>
int main ()
{
std::cout << "Hello World! "; // écrire Hello World!
std::cout << "Je suis un programme C++"; // écrire Je suis un programme C++
}Si les commentaires sont inclus dans le code source d’un programme sans utiliser les combinaisons de caractères //, / * ou * /, le compilateur les prend comme s’il s’agissait d’expressions C ++, entraînant probablement l’échec de la compilation avec un ou plusieurs, messages d’erreur.
