Topic outline

  • General

  • Introduction

    • Ce cours est destiné à vous faire acquérir les notions  essentielles du langage de programmation C++, c'est-à- dire à  vous apprendre comment écrire un programme en  C++ de façon claire pour résoudre un problème donné.

    • Plan de ce cours :
           

    -Introduction.

    -Premier programme en C++.

    -Les types fondamentaux.

    - Les variables.

    -Les opérateurs.

    -Les structures de contrôle.

    -Conclusion.
                  

          

    • Organisation :

          Les cours : 4 séances de 2h00.

          Les travaux pratiques : 4 séances de TP de 3 heures.

    • Le langage C++ est un des langages les plus célèbres au monde. Très utilisé, notamment dans le secteur des jeux vidéo qui apprécie ses performances et ses possibilités, le C++ est désormais incontournable pour les développeurs.
    • Le C++ est le descendant du langage C. Ces deux langages, bien que semblables au premier abord, sont néanmoins différents. Le C++ propose de nouvelles fonctionnalités, comme la programmation orientée objet (POO). Elles en font un langage très puissant qui permet de programmer avec une approche différente du langage C.


    • Premier programme en C++

                   En langage C++, un programme consiste en l'exécution d'une suite d'instructions inserées dans le bloc principal :

      void main()
      {
      }


      Ce bloc d'instructions doit être sauvegardé dans un fichier portant l'extension ".cpp". Pour exécuter le programme, il faut tout d'abord le compiler afin de générer un fichier ".exe" (la compilation est une opération consistant à transformer le texte du programme en code machine). Le programme est alors exécuté en lançant le fichier ".exe" (sous Windows, cliquer deux fois sur l'icône du fichier).
      Pour tester le compilateur, écrivez le programme suivant qui doit afficher sur une fenêtre console "Ceci est mon premier programme en langage C++".

      #include <iostream>
      using namespace std;
      void main()
      {
      cout << "Ceci est mon premier programme en langage C++";
      }


      Toutes les instructions se termine par un ";".  Les instructions peuvent être écrites sur plusieurs lignes. On peut écrire plusieurs instructions par ligne. Le nombre d'espaces entre les mots est sans importance.
      Des commentaires peuvent être insérés dans un programme :

      // Ceci est un commentaire sur une seule ligne
      /*
      Ceci est un commentaire
      sur plusieurs lignes
      */



    • Les types fondamentaux

                 Les données traitées en langage C/C++ sont stockées dans des variables. Selon la nature des données, ces variables sont de différents types.

      3.1 Les types entiers : Les principaux types entiers sont short, int et long. On distingue aussi les types unsigned short, unsigned int et unsigned long qui ne présentent pas d'intérêt en analyse numérique.

      3.2 Les types flottants : Il n'y a que 2 types pour stocker les nombres réel (nombres en virgule flottante)  float et double.

      3.3 Le type caractère : Il s'agit du type char qui permet de stocker un caractère. Il existe 256 caractères différents : toutes les lettres de l'alphabet ('a', 'b', 'c', . . ., 'A', 'B', 'C', . . .), les caractères numériques ('0', '1', . . .), les signes de ponctuation (',', ' ;', . . .), en bref tous les caractères que l'on retrouve sur le clavier. Bien noter que les caractères représentés sont toujours placés entre apostrophes.

      Il y a aussi les caractères dits spéciaux. Les plus importants sont le tabulateur ('\ t'), le retour à la ligne ('\ n') et le caractère nul ('\ 0') (à ne pas confondre avec le caractère zéro '0'). Il y a enfin 4 caractères avec une syntaxe particulière : les caractères '\\ ', '\ '', '\ "' et '\ ?' qui représentent respectivement les signes \ , ', " et ?.

      3.4 Le type booléen : Le type booléen bool permet de stocker les grandeurs logiques true et false. Les booléens sont stockés en mémoire sur 1 octet.

    • Les variables

      4.1. Déclaration :

               Les données d'un programme sont stockées dans des variables (espace mémoire). Ces dernières doivent être déclarées (= donnée d'un nom et d'un type à la variable). Le nom d'une variable commence toujours par une lettre ou le caractère , puis contient n'importe quelle succession de lettres, de chiffres ou de caractères . Attention, les majuscules et minuscules sont des lettres différentes. ad1 et aD1 sont des noms de variables différents. 

      Syntaxe de déclaration des variables :

      type nom var1 [, nom var2, ...] ;. Par exemple, on peut écrire dans le bloc main() :




      void main() {
      short i; // déclare 1 variable de type short nommée i
      int j; // 1 int j
      int m, n; // 2 int m et n
      double d; // 1 double d
      char c; // 1 char c
      bool b; // 1 bool b
      }


      Attention, déclarer une variable ne fait que réserver l'emplacement en mémoire (en mémoire RAM) pour stocker une donnée. La valeur de la variable est indéfinie aprés la déclaration (c'est-à-dire elle peut être n'importe quoi et cela peut être source de bugs dans un programme). Il est donc important de prévoir l'initialisation de ses variables avant de les utiliser.
      On initialise une variable soit dans la déclaration :

      short i = 0;
      double d = 1.;
      char c = 'u';
      int j, k = 1; // attention, ici seul k est initialisé à 1
      int j = 1, k = 1; // ici j et k sont initialisés à 1



      (noter bien le . aprés le 1 qui a toute son importance dans la déclaration de la variable double : 1. désigne un nombre en virgule fllottante (donc un type décimal), 1 désigne un entier), soit aprés la déclaration, par une opération d'affectation.

      4.2 Les constantes :

      bool b;
      b = true;


      Une variable peut être déclarée constante en ajoutant le mot const avant le type de la variable :

      const double pi = 3.14;


      Dans ce cas, la variable ne peut plus être changée par la suite. Il devient interdit d'écrire une opération d'affectation après une telle déclaration :

      const double pi = 3.14;

      pi = 5 ;  Erreur !! Le compilateur refusera de compiler le programme

        Habituellement, les constantes sont représentées par des noms en majuscules.

    • Les opérateurs

                Un opérateur agit sur une ou deux variables (ou directement des données) et donne un résultat. Chaque opérateur n'agit que sur des données d'un certain type et donne un résultat également d'un certain type.

      5.1. Les opérateurs arithmétiques :

      Les opérateurs arithmétiques sont les opérateurs " +, -, *, / et %" (modulo). Les 4 premiers agissent sur des types entiers ou flottants et donnent pour résultat un type entier ou fottant respectivement. Leur signification est explicite. Attention, si la division / agit sur 2 entiers, le résultat est l'entier qui représente la partie entière de la fraction. L'opérateur % (modulo) agit sur des données de type entier et donne pour résultat le reste de la division entière.
      Exemples d'utilisation de ces opérateurs :

            double a, b = 2.;
      int i = 1, j;
      a = b * 5.; // b est multiplié par 5. et le résultat (10.) est placé dans a
      a = a / 4.; // a est divisé par 4. et le résultat (2.5) est replacé dans a
      j = i + 2; // i est incrémenté de 2 et le résultat (3) est placé dans j
      j = 5 / 2; // j vaut 2 (division entiµere)
      j = 5 % 2; // j vaut 1 (reste de la division entière)      

      Il faut toujours travailler avec des données de même type. Au besoin, procéder à une conversion de type (voir ci plus loin) :

      a = b / (double)j;

      Si la conversion de type n'est pas écrite explicitement, le compilateur le fait implicitement (à votre place). La conversion implicite (par le compilateur) est souvent source de confusion et de bugs et n'est pas à recommander.

      5.2 Les opérateurs d'affectation :


      Les opérateurs d'affectation sont les opérateurs " =, +=, -=, *=, /=, %=, ++, -- ". Ils sont responsables de l'affectation d'une valeur à une variable. L'opérateur d'affectation principal est l'opérateur = qui affecte directement une valeur à une variable (par exemple, au terme de l'instruction i = 1 ;, la variable i possµede la valeur 1).
      On peut aussi utiliser les opérateurs d'affectation combinés " +=, -=, *=, /= et %= ". La signification du premier opérateur est la suivante : j += 2 ; est équivalent à j = j + 2 ;. Au terme de cette instruction, le contenu de la variable j a été incrémenté de 2 et replacé dans la variable j. Les autres opérateurs fonctionnent de manière analogue. Il y a aussi les opérateurs " ++ et -- " qui signifient respectivement " +=1 et -=1 ". On écrit simplement i++ ; pour incrémenter i de 1 ou i-- ; pour le décrémenter de 1. On peut aussi écrire ++i ; et --i ;.

      5.3 Les opérateurs de comparaison :


      Les opérateurs de comparaison sont les opérateurs " > (plus grand), < (plus petit), >= (plus grand ou égal), <= (plus petit ou égal), == (égal), != (différent de) ". Ces opérateurs comparent des données de même type (2 nombres, 2 caractères, . . .) et donne pour résultat une valeur booléenne (true ou false).
      Nous pouvons par exemple écrire :

      bool b;
      int i = 1;
      b = (i > 0); // ici b sera true



      5.4 Les opérateurs logiques :


      Les opérateurs logiques sont les opérateurs " && (et), || (ou) et ! (not) ". Les 2 premiers agissent sur 2 booléens et rendent un booléen. Le dernier n'agit que sur 1 booléen et rend également un booléen. Voici un exemple de leur utilisation : 

      int i = 1;
      bool b;
      bool c = true;
      b = (i > 0)&&(i < 1); // ici b sera false
      b = (i > 0)||(i < 1); // ici b sera true
      b = !c; // ici b sera false
      b = !(i > 1); // ici b sera true



    • Les structures de contrôle

      6.1 L'instruction if :

      L'instruction if exécute de manière conditionnelle une instruction ou un bloc d'instructions. La condition est déterminée par la valeur d'une expression booléenne (par exemple : (i > 1)). Si une seule instruction dépend de la condition, on écrit : if (condition) instruction; // exécuté si condition est true ou if (condition) { instruction; // exécuté si condition est true } Si plusieurs instructions dépendent de la condition, on écrit : if (condition) { instruction1; // exécuté si condition est true instruction2; // ... }

      6.2 L'instruction if ... else :

      L'instruction if ... else exécute de manière conditionnelle une instruction ou un bloc d'instructions. Si la condition n'est pas remplie une autre instruction ou bloc d'instructions est exécuté. La condition est une expression booléenne.
      Si une seule instruction dépend de la condition, la syntaxe est la suivante :

      if (condition)
      instruction; // ou {instruction;} // exécuté si condition est true
      else
      instruction; // ou {instruction;} // exécuté si condition est false
      Si plusieurs instructions dépendent de la condition, on écrit :
      if (condition)
      {
      instructions; // exécuté si condition est true
      }
      else
      {
      instructions; // exécuté si condition est false
      }



                         

                

      6.3 L'instruction switch :
      Illustrons sur un exemple le fonctionnement de l'instruction switch :

      int i;
      switch (i)
      {
      case 0:
      instructions; // instructions à exécuter si i = 0 (noter qu'il n'y a pas de { })
      break; // Attention, important, bien écrire cette instruction
      case 1:
      instructions; // instructions à éxécuter si i = 1
      break;
      case 2:
      case 3:
      case 4:
      instructions; // instructions à éxécuter si i = 2, 3 ou 4
      break;
      default:
      instructions; // instructions à éxécuter si i est différent de 0, 1, 2, 3 et 4
      break; // le bloc default n'est pas obligatoire
      }

      6.4 Les boucles:


                      

          6.4.1 L'instruction while :

      while (expression booléenne)
      instruction; // ou {instruction;} ou {instructions;}



      signifie tant que l'expression booléenne est vraie, exécuter l'instruction ou le bloc d'instructions.

          6.4.2 L'instruction do ... while :

      do
      instruction; // ou {instruction;} ou {instructions;}
      while (expression booléenne);



      signifie exécuter l'instruction ou le bloc d'instructions, tant que l'expression booléenne est
      vraie.
      Par rapport au while, l'instruction ou le bloc d'instructions est exécuté au moins une fois
      avec le do.

           6.4.3 L'instruction for :

      for (init_instruction; condition; reinit_instruction)
      instruction; // ou {instruction;} ou {instructions;}



      L'instruction for fonctionne comme suit :
      - l'instruction init instruction est exécutée 

      - la condition (expression booléenne) condition est vérifiée

      - si la condition est vraie, le bloc d'instructions est exécuté, sinon la boucle s'arrête
      - l'instruction reinit instruction est exécutée
      - la condition condition est vérifiée
      { si la condition est vraie, . . .
      Dans l'exemple suivant :

      for (i = 0; i < 10; i++)
      instruction; // ou {instruction;} ou {instructions;}



      le bloc d'instructions est exécuté 10 fois. La premiµere fois, i vaut 0, puis 1, . . . jusque 9.


    • Conclusion

          

      Le choix de C++, pour une introduction à la conception objets, est du au fait que c’est aujourd’hui LE langage de développement orienté objets. Des langages antérieurs, comme SmallTalk, sont trop peu répandus pour justifier un investissement. D’autres, comme le récent langage Java, sont plus spécialisés et prennent donc tout leur intérêt dans des environnements bien particuliers (Internet). En tout état de cause, il est fortement déconseillé d’utiliser des extensions par trop
      spécifiques à une plateforme. Des fichiers source C, toto.c, et C++, toto.C, valides sur une plateforme Unix vont provoquer des collisions de noms en cas de migration vers un système qui ne distingue pas la casse des noms de fichiers (VMS, MS-DOS) !.  Le compilateur GNU est un compilateur mixte C/C++. On pourra compiler des sources C++ en utilisant l’une ou l’autre des commandes gcc ou g++.