Déroulement des séances en Licence L3 de physique, 2017-2018

• Suivre le didacticiel Partie I “Bases du langage C++” I, en binome ou seul.
  • Lire l'introduction 1, puis passer à la partie I, I.
  • Faire tous les exercices demandés. Pour les exercices marqués par (*). Par exemple “tabulation” (*), écrire un programme tabulation.cc et le montrer à l'enseignant (ou montrer plusieurs exercices à la fois).
  • On peut seulement lire rapidement les parties appelées “suppléments”.
  • Ce didacticiel se termine par la réalisation d'un microprojet en Section 9. Choisir parmi la liste proposée. Rédiger un compte rendu de 2 ou 3 pages avec lyx, avec des images et des formules. Exporter en pdf et en xhtml et le montrer à l'enseignant, avec un oral de 5mn-10mn.
  • Optionellement, suivre le didacticiel Partie II “Compléments du langage C++” II.
• Choisir un projet d'expérimentation numérique. Voir la page projets.
  • A la dernière séance, chaque étudiant (ou binome) présente son projet sur vidéo projecteur, pendant 15 à 20 mn, à l'ensemble de la classe.
  • Cette présentation devra être préparée avec Lyx (qui permet de créer des documents scientifiques) et exportée en html (avec LyxHtml) ou en pdf.
  • Pour apprendre Lyx, voici un document en pdf qui sert d'exemple et d'exercice. Voici le même document en html, qui vous servira éventuellement pour copier/coller.

Chapitre 1 Introduction

• Ce didacticiel vous permettra d'appréhender le langage de programmation C++ (version C++11) et ses avantages. Dans ce didacticiel, les exercices marqués par (*) seront vérifiés par l'enseignant pendant les séances. Il y a de nombreux “liens html” qui renvoie vers plus d'informations.
• Le grand avantage du langage C++ par rapport au langage C est la programmation objet. On peut utiliser des objets appartenant à des classes déjà existantes ou à des classes que l'on a fabriqué soi-même. Par exemple, il existe la classe des nombres complexes. Les objets appartenant à cette classe sont des nombres complexes. Il nous suffira de déclarer trois objets a, b et c comme appartenant à la classe des nombres complexes, et l'on pourra directement écrire a=b+c ou n'importe quelle autre expression mathématique. Comme autre exemple, il y a la classe de “matrice complexe”: on peut déclarer trois objets A, B et C appartenant à cette classe et écrire A=B+C ou n'importe quelle autre expression mathématique matricielle.
• Pourquoi enseigner le C++ à l'université, dans la filière physique? d'une part c'est un langage qui est très bien adapté pour la simulation ou l'analyse de problèmes physiques et de façon plus générale pour le travail scientifique. Dans les laboratoires il a remplacé peu à peu le langage fortran. Le langage python est un autre langage qui utilise aussi des classes et est aussi très utilisé dans le domaine scientifique. Un programme en python est peut être plus simple à mettre en oeuvre qu'un programme en C++, c'est une histoire de goût et d'habitude, mais il est aussi beaucoup plus lent à l'exécution. Un avantage du langage python est qu'il est “interprété”: on peut exécuter un programme ligne après ligne alors que le langage C++ est “compilé”: un programme appelé compilateur le transforme en langage machine (fichier exécutable) avant qu'il ne soit exécuté et cela le rend rapide. La dernière version C++11 fait du C++ un langage aussi conviviale et simple d'utilisation que le langage python (et plus rapide!).
• Nouvelles version du C++:les récentes versions C++11 puis C++14, C++17, C++20 ont pour vocation de rendre le C++ plus facile à apprendre et toujours performant.
• Références:
  
  • Sur le web:
    
    • voici un site très utile: http://www.cplusplus.com/. Il contient un tutorial de très bonne qualité, où les exemples peuvent être essayé en ligne (avec la petite icône “edit & run” à droite de example, essayez par exemple sur setprecision)!. Il contient aussi une documentation complète au langage C++.
    • Un autre site en français:cppreference.com ou en anglais: cppreference.com.
    • Une façon pratique de se documenter sur une fonction précise est d'utiliser le moteur de recherche de google. Par exemple pour afficher un nombre avec une certaine précision numérique, si vous ne savez pas comment faire, tapez quelques mots clef comme “affichage precision c++” dans la fenêtre de recherche de google, qui vous amènera sur une page de forum avec un exemple. Vous y verrez que la fonction à utiliser est setprecision. Ensuite pour avoir une bonne documentation sur cette fonction et des exemples que l'on peut copier/coller, tapez toujours dans google “cplusplus setprecision” ce qui vous amène à une page de documentation.
    • Signalons le cours en ligne en francais sur le C++ de Coursera sur : ce sont des vidéos courtes, ou Cours de C++ de OpenClassRoom en français.
    • La page web de Bjarne Stroustrup, auteur du langage C++, et en particulier la FAQ sur le C++11
    • Un MOOC sur Linux. Un MOOC sur le C++. Un autre MOOC sur le C++.
    • Sur ce site on peut ecrire, compiler et executer un programme C++ en ligne.
  • Livre pour le langage C++:
    
    • Stroustrup-A Tour of C++-Addison-Wesley (2018)
    • Programmer en C++ de Claude Delannoy, éditions Eyrolles
    • The C++ programming langage de Bjarne Stroustroup, 4eme édition.
  • Livre pour le langage C: Le langage C de B.W. Kernighan et D.M. Ritchie edition Masson.

1.1 Choix du système d'exploitation

• Root.
• Armadillo.

1.1.1 Installer Xubuntu et l'environnement de programmation c++ sur son ordinateur

• Si ubuntu (linux) est déjà installé sur votre ordinateur, il faut installer les librairies requises pour ce didacticiel. Pour cela, ouvrir un terminal et écrire, l'une après l'autre les lignes suivantes:

  sudo apt-get install -y root-system # librairie Root du Cern

  sudo apt-get install -y emacs emacs-goodies-el global clang auto-complete-el cscope-el # logiciel pour recherche de fonctions etc

  sudo apt-get install -y libarmadillo-dev # C++ linear algebra library

  sudo apt-get install -y libboost-dev

  sudo apt-get install -y libboost-all-dev

• Autre info:.

1.1.2 Installation sur Mac Os

• Installer HomeBrew

 

brew install armadillo

brew install root

brew install emacs-clang-complete-async

brew cask install emacs

brew install boost

brew install xfig

brew install fig2dev

• Installer:
  • MacTex et Lyx
  • emacs
• Pour de-installer Brew

1.1.3 Installation sur windows

• Voir Install Linux on Windows, WSL
• Si votre ordinateur marche avec windows, vous pouvez installer rajouter ubuntu (linux) soit avec une machine virtuelle virtualbox ou installer Ubuntu en double boot (Suivre les instructions sur installer Ubuntu.) ou installer directement ubuntu sous windows et doc sur WSL ou reprenez-le-controle-a-l-aide-de-linux

1.2 Environnement de programmation

1. écrire le code d'un programme en C++
2. le compiler, c'est à dire que l'ordinateur traduit le programme C++ en un programme “exécutable” (en langage machine) qu'il pourra exécuter ensuite.
3. exécuter le programme
4. éventuellement de le “débugger” (cela signifie recherche d'erreurs): si le programme ne fonctionne pas comme on le désire, on l'exécute instruction après instruction afin de suivre ce qu'il fait pas à pas, dans le but de trouver un “bug” (= une “erreur”).

1.2.1 Utilisation de commandes dans un terminal

1.2.1.1 Les répertoires

• Pour connaître le répertoire de votre fenêtre de commande (le répertoire courant): pwd
  sur la figure suivante par exemple, le répertoire courant est /home/faure

• Pour afficher la liste des fichiers et des sous répertoires du répertoire courant: ls ou ls -als (pour avoir plus de détails)
• Pour changer de répertoire:
  
  • pour aller dans le sous répertoire appelé rep: cd rep
  • pour aller dans le répertoire parent: cd ..
  • pour revenir à votre répertoire d'origine: cd ou cd ~
• Pour créer un sous répertoire appelé rep: mkdir rep
• Pour détruire un sous répertoire appelé rep: rm -r rep

1.2.1.2 Exercices sur les répertoires

1. Placez vous dans votre répertoire d'origine: cd
2. Vérifiez que vous y êtes bien: pwd
3. Regardez la liste des fichiers par: ls , puis avec: ls -als
4. Créer un répertoire du nom: essai Vérifier son existence (avec ls).
5. Aller dans ce répertoire: cd essai Vérifier que vous y êtes (avec pwd).
6. Revenir dans le répertoire d'origine par cd .. Vérifiez que vous y etes. Détruire le répertoire essai

1.2.1.3 Les fichiers (en exercice)

• Créer un nouveau fichier avec l'éditeur emacs: emacs fichier.txt &
  écrire le texte: salut
  Menu: File/Save
  Menu: File/Quit
  On vérifie le contenu du fichier dans la fenêtre de commandes: more fichier.txt
• Pour changer le nom du fichier.txt en fichier2.txt: mv fichier.txt fichier2.txt
• Pour déplacer le fichier2.txt dans le sous répertoire rep:
  mkdir rep
  mv fichier2.txt rep/fichier3.txt
• Pour copier le fichier3.txt dans le répertoire parent:
  cd rep
  cp fichier3.txt ../fichier1.txt
• Pour détruire le(s) fichiers:
  rm fichier3.txt
  cd ..
  rm fichier1.txt
  rm -r rep

1.2.1.4 La documentation sur les commandes unix

• Pour avoir la documentation sur la commande ls par exemple, taper dans une fenetre de commande: man ls
• Voici une documentation sur les commandes possibles bash pour la fenêtre terminal.

1.2.2 Programmer avec l'éditeur emacs et une fenêtre de commandes

1. Dans ubuntu, ouvrir une fenêtre de commandes (ou terminal). Se placer dans le bon répertoire de travail. Pour cela comme expliqué dans la section précédente, utiliser les commandes pwd (qui dit dans quel dossier on est situé), ls (qui liste les fichiers et dossiers) , cd dossier (: qui passe au dossier indiqué), cd .. (qui passe au dossier parent), cd . (qui reste dans le même dossier, c'est inutile), cd (qui revient au dossier de départ),
2. Ecrire la commande emacs & qui lance l'éditeur. Le signe & signifie que le terminal reste utilisable. Dans emacs, une fois pour toutes, cocher dans le menu Options/UseCUAKeys et Options/SaveOptions qui vous permettra d'utiliser les raccourcis clavier C-c C-v pour “copier/coller”.
3. Dans emacs, ouvrir un nouveau fichier projet1.cc qui sera vide la première fois (pour faire cela: Menu/File/Visit New File et ecrire projet1.cc , Valider). Le suffixe .cc signifie qu'il contiendra du code C++ (ou peut aussi choisir le suffixe .cpp). Dans ce fichier, Copier/coller le code suivant:
   

   #include <iostream>

   using namespace std;

   int main()

   {

   cout << "Bonjour!" << endl;

   }

   et sauvegarder ce fichier qui contient le code C++ de votre programme. (Observer les raccourcis clavier proposés par emacs dans ses menus pour toutes ces commandes: par exemple “Save : C-x C-s” signifie que les touches Ctrl avec x puis Ctrl avec s. “Shell Command M-!” signifie les touches Alt avec !).

4. Dans emacs ouvrir un nouveau fichier Makefile qui sera vide la première fois. Dans ce fichierCopier/coller le code de compilation suivant:

   all:

   $$g++ projet1.cc -o projet1 -std=c++11 -O3 -Wall -lm $$\begin{array}{cc}& (1)\end{array}$$

   et sauvegarder ce fichier qui contient les instructions pour compiler votre programme. Attention: au début de la deuxième ligne rajouter un espace de tabulation avant g++. Remarque: on peut basculer d'un fichier à l'autre dans emacs par le menu “Buffers” ou par le clavier avec C-x C-$\to$.

5. Compiler le programme par la commande du menu: Tools/Compile.. qui fait apparaitre en bas de page: make -k que l'on remplace par make all (puis faire entrée). Si tout se passe bien le dernier message est “compilation finished”.
6. Remarques: cela a pour effet d'exécuter la commande de compilation qui se trouve dans le fichier Makefile: elle dit qu'il faut utiliser le compilateur g++ et qu'à partir du fichier projet1.cc il faut créer en sortie (-o = “output”) un fichier exécutable appelé projet1. On a rajouté en option (inutiles dans cet exemple) -std=c++11 qui signifie que on utilise la syntaxe du c++11 et -lm qui signifie que on l'on souhaite utiliser la librairie mathématique. L'option -Wall signifie que le compilateur montrera “all the Warnings” , c'est à dire toutes les imperfections dans la syntaxe.
7. Dans le terminal, placez vous dans le répertoire qui contient votre projet, vérifiez avec la commande ls qu'il contient le fichier exécutable projet1 , et exécutez ce fichier en écrivant: ./projet1
   (remarque: ./ signifie le répertoire présent)

• En haut du fichier .cc rajouter la ligne suivante:
  // -*- mode:C++ ; compile-command: "make all" -*-
  Cela a pour effet de préciser la commande de compilation lorsque l'on fait Menu/Tools/Compile
  On peut aussi remplacer "make all" par "make all; projet1;" ce qui a pour effet de compiler et de lancer l'exécutable projet1
• Dans le fichier ~/.emacs rajouter la ligne:
  (global-set-key (kbd "<f9>") 'compile)
  Ainsi il suffira dans emacs d'utiliser la touche f9 pour lancer la commande de compilation.
• Autres options, voir developper en c++ sous emacs. Raccourcis claviers sous emacs. Manuel de Emacs

Partie I Bases du langage C++

2.2 Lire le clavier

#include <iostream>

using namespace std;

 

int main()

{

int a,b; // déclaration des objets a et b de la classe int

cout <<"Quelle est la valeur de a ? "<<flush;

cin >> a; // lire a au clavier, attendre return

cout <<"Quelle est la valeur de b? "<<flush;

cin >> b; // entrer b au clavier puis return

int c; // déclaration de la objet c de la classe int

c = a + b; // affectation: c prend la valeur a+b

 

// affichage à l'écran:

cout <<"la somme de "<<a<<" et "<<b<<" vaut "<<c<<endl ;

}

Chapitre 3 Déclaration et affectation des objets

3.1 Objets de base

3.1.1 Les déclarations d'objets de base

3.1.2 Initialisation d'un objet de base

#include <iostream>

using namespace std;

 

main ()

{

int i = 0;

double x = 1.23;

double x1(3.4),x2(6); // equivalent a x1=3.4

double y(x1), y2 = x2;

char Mon_caractere_prefere = 'X';

const char * texte = "que dire de plus?";

char c = texte[0]; // premier caractere

auto z = x + 2;

{

double x=5;

}

}

3.1.2.1 Remarques

1. i est un int qui vaut 0, x un float qui vaut 1.23, x1 est un double qui vaut 3.4, etc..
2. Le terme auto signifie que le compilateur devine lui même la classe de l'objet, ici z est un double.
3. Dans le nom des objets, le langage C++ fait la différence entre les majuscules et les minuscules. On peut choisir ce que l'on veut et utiliser même des chiffres et le caractère _.
4. On peut initialiser un objet avec des paranthèses comme x1(3.4). C'est équivalent que d'écrire x1=3.4. On peut initialiser un objet avec un objet déjà existant comme y(x1) ou y2 = x2.
5. Un caractère est entre le signe ', comme 'X'.
6. Un texte (chaîne de caractère) est entre le signe ". Ici l'objet texte est du type const char * qui signifie que c'est une “chaine de caractères” (ou tableau de caractères) constante. Les indices du tableau commencent à 0. C'est pourquoi texte[0] extrait le premier caractère qui est q. On expliquera plus tard que texte est en fait un pointeur sur charactères.
7. A la dernière ligne on déclare $x=5$ dans un bloc d'accolades ou bloc d'instructions {..}. Cela est possible et signifie que dans ce bloc x est une nouvelle variable locale (qui masque la valeur de x précédente).
8. On pourra bien sûr modifier ces valeurs dans la suite du programme.

3.1.3 Affichage des nombres avec une précision donnée

#include <iostream>

using namespace std;

#include <math.h>

#include <iomanip>

 

//..................

main ()

{

double c = M_PI;

cout<<setprecision(3)<<c<<endl;

}

Résultat:

3.14

3.1.4 Attention à la division Euclidienne

#include <iostream>

using namespace std;

//......

main ()

{

 int a=7, b=2;

 double c=7.;

 cout<<"7/2 = "<<a/b<<" = "<<7/2<<endl;

 cout<<"7./2 = "<<c/b<<" = "<<7./2<<" = "<<(double)a/b<<endl;

 cout<<"Le quotient de 7/2 = "<<7/2<<" Le reste de 7/2 est r= "<<7%2<<endl;

}

Résultat:

 

7/2 = 3 = 3

7./2 = 3.5 = 3.5 = 3.5

Le quotient de 7/2 = 3 Le reste de 7/2 est r= 1

Remarques:

• L'exemple précédent montre que l'écriture 7/2 signifie le quotient de la division euclidenne qui est bien 3 car 7=2*3+1. Le reste 1 euclidien est obtenu par l'opération 7%2 qui signifie 7 modulo 2.
• Pour effectuer la division parmi les nombres réels (à virgule) il faut utiliser le type double.
• L'instruction (double)a permet de convertir la variable a qui est de classe int en une variable de classe double. Ce changement de classe est appelé “cast”.
• Attention, cette convention que 7/2 est la division euclidienne en langage C et C++ est souvent source d'erreur.

3.1.5 Pour générer un nombre entier p aléatoire

3.1.6 Fonctions mathématiques

• Numeric/math
• Special functions

• Special functions
• Bessel functions with complex variables

3.2 Objets plus élaborés de la classe standard

3.2.1 Chaines de caractères (string)

#include <iostream>

#include <string>

using namespace std;

main ()

{

string texte1 = "J'aime le café";

cout << texte1<<endl;

string texte2 = texte1 + " sans sucre";

cout << texte2<<endl;

cout<<"Le premier caractère est du texte précédent est: "<<texte2[0]<<endl;

}

Résultat:

J'aime le café

J'aime le café sans sucre

Le premier caractère du texte précédent est:J

 

J'aime le café sans sucre

Le troisième caractère du texte précédent est:a

3.2.1.1 Conversion de chiffres en chaine de caractère et inversement. Solution simple.

#include <iostream>

using namespace std;

#include <string>

#include <sstream>

 

//.....

main ()

{

//..... Conversion number to string.

int d=7; // chiffre

string S = to_string(d);

cout<<"d="<<d<<" S="<<S<<endl;

 

//..... Conversion string to number.

string s5 = "3"; // chaine contenant des chiffres

int i5 = stoi(s5);

string s6 = "3.14"; // chaine contenant des chiffres

double d6 = stod(s6);

cout<<"i5="<<i5<<" d6="<<d6<<endl;

}

Résultat:

3.2.2 Nombres complexes

 

#include <iostream>

using namespace std;

#include <complex>

typedef complex<double> Complex;

 

main ()

{

Complex I(0,1); // on définit le nombre I

cout<<"I.I="<<I*I<<endl;

Complex a=2.+I*4., b=3.-2.*I;

Complex c=a+b, d=a*b;

cout<<" a="<<a<<" b="<<b<<endl;

cout<<" a+b="<<c<<" a*b="<<d<<endl;

cout<<" real(a)="<<a.real()<<" norme(a)="<<abs(a)<<endl;

}

I.I=(-1,0)

a=(2,4) b=(3,-2)

a+b=(5,2) a*b=(14,8)

real(a)=2 norme(a)=4.47214

• L'écriture 2. est équivalente à 2.0 ou à 2. Ainsi a=2.+I*4. est équivalente à a=2+4*I
• typedef complex<double> Complex; signifie que le mot Complex est un raccourci pour le type complex<double> qui est un nombre complexe avec double en partie réelle et imaginaire.

3.2.3 Liste d'objets (ou tableau de dimension 1): vector

 

#include <iostream>

using namespace std;

#include <vector>

 

main ()

{

vector<int> L; // liste vide qui contiendra des objets de type int

L.push_back(2); //rajoute l'element 2 a la fin de la liste

L.push_back(3); // rajoute 3 a la fin de la liste

L.push_back(5);

cout<<"La liste a la taille :"<<L.size()<<endl;

cout<<"Ses elements sont: "<<L[0]<<" , "<<L[1]<<" , "<<L[2]<<endl;

}

Autre exemple:

 

#include <iostream>

using namespace std;

#include <vector>

#include <algorithm>

 

main ()

{

 

//--- recherche la position de l'element maximal de la liste

vector<int> L={5,7,3,12,34,6}; // on initialise une liste d'entiers

cout<<"Le premier élément de la liste est "<<L[0]<<endl;

int p = max_element(L.begin(),L.end())-L.begin(); //renvoit la position du maximum dans l'ordre (0,1,2..)

cout<<"L'élement le plus grand est "<<L[p]<<endl;

cout<<"Il est à la position "<<p<<endl;

 

//--- cherche la premiere/derniere position d'un element avec find() / rfind()

int e = 6;

int p2 = find(L.begin(), L.end(), e) - L.begin(); // cherche la position de l'element e

if(p2<L.size())

cout<<"Le "<<e<<" est à la position "<<p2<<endl;

else

cout<<"Le "<<e<<" n'est pas dans la liste."<<endl;

}

Résultat:

 

Le premier élément de la liste est 5

L'élement le plus grand est 34

Il est à la position 4

Le 6 est à la position 5

 

3.2.3.1 Poser un objet sans copier:

3.3 Vecteurs et matrices pour l'algèbre linéaire avec la librairie Armadillo

Commande de compilation:

Exemple:

#include <iostream>

using namespace std;

#include <armadillo>

using namespace arma;

 

main ()

{

 Col<int> V("1 2 3"); // vecteur colonne d'entiers

 cout<<"V="<<endl<<V<<endl;

 Mat<int> M("3 2 1; 4 5 0");// matrice d'entiers

 cout<<"M="<<endl<<M<<endl;

 Col<int> W = M * V; // calcule le produit

 cout<<"M*V="<<endl<<W<<endl;

 cout<<"element de matrice M(0,0)="<<M(0,0)<<endl;

}

V= 1

   2

   3

 

M= 3 2 1

   4 5 0

 

M*V= 10

     14

 

element de matrice M(0,0)=3

 

    A = 1 1

        0 1

 

B = 1 0

    1 1

 

A*B = 2 1

      1 1

3.3.1 Quelques fonctions utiles sur les vecteurs et matrices

#include <iostream>

using namespace std;

#include <armadillo>

using namespace arma;

 

main ()

{

//---- initialisations

 

//... vec est equivalent a Col<double>

vec V1 = randu<vec>(5); // vecteur colonne de 10 composantes aleatoires unif. dans [0,1]

cout<<"V1="<<endl<<V1<<endl;

 

//... mat est equivalent a Mat<double>

mat M1;

M1.zeros(3,3); // matrice 3*3 remplie de zeros

cout<<"M1="<<endl<<M1<<endl;

 

//----- conversions de types

vector<double> V2 = conv_to<vector<double>>::from(V1); // V1 -> V2

cout<<"V2[0]="<<V2[0]<<endl;

}

Résultat

3.4 Objets graphiques avec la librairie Root

• de faire du graphisme évolué (dessiner des axes, des courbes, des surfaces, des objets en 3D,..), mais aussi du graphisme simple (lignes, points, ronds,..)
• de traiter des données pour faire des statistiques; cela est très utile au CERN pour étudier les milliards de résultats issus d'une expérience de collisions entre particules.
• de faire des interfaces graphiques pour un programme (gestion de la souris, menus déroulants, boites de dialogues avec boutons, ...)
• et beaucoup d'autres choses. Voir la page web de presentation.
• Sur le réseau il y a une documentation complète. Il y a aussi Documentation générale. On peut aussi accéder à la liste des classes. Il y a une mailling list d'utilisateurs qui s'entraident. Quand on a un problème, il suffit d'envoyer un mail, la réponse nous revient quelques minutes ou heures plus tard. Le plus simple est souvent d'écrire dans le moteur de recherche de google des mots clefs comme “root cern ellipse” pour trouver comment dessiner une ellipse avec root.
• Si “root” n'est pas installé sur votre ordinateur, pour l'installer sous (X)Ubuntu, il faut écrire dans un terminal:

  sudo apt-get install -y xorg-dev

  sudo apt-get install x-dev

  sudo apt-get install root-system

3.4.1 Commande de compilation

• Si vous utilisez un Makefile, il faut rajouter à la ligne de compilation (1), à la suite de -lm, les instructions suivantes:

-I/usr/include/root `root-config --cflags` `root-config --libs` `root-config --glibs`

• Si vous utilisez l'éditeur codeblocks
  
  • Dans Settings/Compiler/Compiler_Settings/Other_Options, rajouter:

  -I/usr/include/root

  • Dans Settings/Compiler/Linker_Settings/Other_linker_Options, rajouter:

  `root-config --cflags` `root-config --libs` `root-config --glibs`

3.4.2 Exemple de départ qui dessine un cercle

 

#include <TApplication.h> // (A)

#include <TCanvas.h> //(B)

#include <TEllipse.h> // (C)

 

//------ fonction main (A) --------------------

int main()

{

 TApplication theApp("App", nullptr, nullptr); // (A)

 

 TCanvas c("c","fenetre",400,400); // (B) objet fenetre graphique. Taille en pixels

 

 c.Range(0,0,5,5); // coordonnees de la fenetre c: x:0-5, y:0-5 (optionnel, par defaut ce sera 0-1)

 

//------ dessin d'une ellipse dans la fenetre c (C) -------

 TEllipse e(2,3,1); // on precise le centre (x=2,y=3) et le rayon=1

 e.Draw(); // dessine l'ellipse

 c.Update(); //(B) Montre le dessin

 

 theApp.Run(); // (A) garde la fenetre ouverte et permet a l'utilisateur d'interagir.

}

Résultat du programme:

Remarque 3.4.2. Le programme précédent est découpé en trois types de blocs:

(A): dans tout programme utilisant Root, ces parties doivent toujours être réécrites. Il y a l'objet theApp de la classe TApplication.

(B): c'est le code qu'il faut pour créer la fenetre graphique (objet c de la Classe TCanvas). Si votre programme fait du graphisme, il faut toujours créer une fenêtre graphique qui contiendra votre dessin.

(C): c'est le code qu'il faut pour créer le cercle (objet e de la Classe TEllipse).

 

e.SetFillColor(kBlue);

e.SetFillStyle(3025); // motif en carreaux

3.4.3 Quelques objets graphiques

#include <TApplication.h>

#include <TCanvas.h>

#include <TLine.h>

#include <TEllipse.h>

#include <TMarker.h>

#include <TBox.h>

#include <TText.h>

 

int main()

{

 TApplication theApp("App", nullptr, nullptr);

 

//.. La fenetre

 TCanvas c("titre","titre",10,10,400,400); //position x,y sur l'ecran et taille X,Y en pixels

 c.Range(0,0,1,1); // xmin,ymin,xmax,ymax, systeme de coordonnees

 

//.. une ligne bleue

 TLine l(0.1,0.5,0.3,0.9); // x1,y1,x2,y2.

 l.SetLineColor(kBlue); // bleu

 l.Draw();

 

//.. Une Ellipse (ou cercle)

 TEllipse e(0.2,0.3,0.1); // (centre (x,y) et rayon r

e.Draw();

 

//.. Un point

 TMarker m(0.3,0.4,8); // (x,y) et 6 ou 8: forme du Marker

 m.SetMarkerColor(kPink);

 m.Draw();

 

//.. Un rectangle vert

 TBox p(0.15,0.6,0.25,0.7); // on precise les coins bas-gauche (x1,y1) et haut droit (x2,y2) :

 p.SetFillColor(kGreen);

 p.Draw();

 

//.. Du texte

 TText texte(0.2,0.2,"un petit texte"); // position x,y

 texte.Draw();

 

 c.Update(); // Montre le dessin

 theApp.Run(); // garde la fenetre ouverte et permet a l'utilisateur d'interagir.

}

3.5 Suppléments

3.5.1 Continuer une ligne de c++ à la ligne suivante avec \

 

#include <iostream>

using namespace std;

 

main ()

{

cout<<”abcdefghij”<<endl;

 

cout<<”abc\

def\

ghij”\

<<endl;

}

résultat:

 

abcdefghij

abcdefghij

3.5.2 Sur les types

3.5.2.1 Renommage

3.5.2.2 Connaitre le type

#include <iostream>

using namespace std;

#include <typeinfo>

 

main ()

{

auto a='A';

cout << typeid(a).name() <<endl;

auto x=3.14;

cout << typeid(x).name() <<endl;

auto s="ABC";

cout << typeid(s).name() <<endl;

}

c

d

PKc

3.5.3 Quelques opérations élémentaires

 

#include <iostream>

using namespace std;

 

main ()

{

 int b=1;

 cout<<" b="<<b<<endl;

 b++; // equivalent a b=b+1

 cout<<" b="<<b<<endl;

 b-- ; // equivalent a b=b-1

 cout<<" b="<<b<<endl;

}

résultat

3.5.4 Sur les chaines de caractères

3.5.4.1 Manipulations. Recherche dans une chaine, extraction ...

 

#include <iostream>

using namespace std;

#include <string>

int main()

{

//----- find() ---------

string s1 = "ab&-e&-f";

cout<<"chaine s1="<<s1<<endl;

auto pos1 = s1.find("&-"); // recherche premiere occurence de "&-" dans s1

if(pos1!=string::npos)

cout<<"Dans la chaine s1, \"&-\" se trouve a la position pos1 = "<<pos1<<endl;

auto pos2 = s1.find("toto");

if(pos2==string::npos)

cout<<"Dans la chaine s1, \"toto\" n'a pas été trouvé"<<endl;

//----- substr() ---------

string s2 = s1.substr(0, s1.find("&-")); // extrait sous chaine entre le debut (indice 0) la premiere occurence de "&-"

string s3 = s1.substr(0, s1.rfind("&-")); // extrait sous chaine entre le debut (indice 0) et la derniere occurence de "&-"

string s7 = s1.substr(s1.find("&-")); // extrait sous chaine entre la premiere occurence de "&-" et la fin

string s4 = s1; // copie

s4.erase(0,2); // a la position 0, enleve 2 caracteres

string s5 = s1; // copie

s5.erase(s1.size()-2,2); // enleve les 2 caracteres de la fin

string s6 = s1; // copie

int p;

while(((p=s6.find("-"))>=0) && (p<=s6.size()))

s6.replace(p,1,"*"); // remplace tous les "-" par "*"

cout<<"s2="<<s2<<endl

<<"s3="<<s3<<endl

<<"s7="<<s7<<endl

<<"s4="<<s4<<endl

<<"s5="<<s5<<endl

<<"s6="<<s6<<endl;

}

Résultat:

 

chaine s1=ab&-e&-f

Dans la chaine s1, "&-" se trouve a la position pos1 = 2

Dans la chaine s1, "toto" n'a pas été trouvé

s2=ab

s3=ab&-e

s7=&-e&-f

s4=&-e&-f

s5=ab&-e&

s6=ab&*e&*f

3.5.4.2 Conversion de chiffres en chaine de caractère et inversement. Solution sophistiquée (permet des mélanges de type)

#include <iostream>

using namespace std;

#include <string>

#include <sstream>

 

//.....

main ()

{

//..... Conversion chiffre -> string.

int c=7; // chiffre

ostringstream os;

os<<"resultat :"<<c; // on concatene du texte et le chiffre

string s = os.str(); // convertit os en string

cout<<"s= "<<s<<endl; // affichage pour verifier

 

//..... Conversion string -> chiffres.

string s2 = "3 4"; // chaine contenant des chiffres

istringstream is;

is.str(s2); // convertit chaine s2 en is

int a,b;

is>>a; // extrait le premier chiffre trouve dans is

is>>b; // extrait chiffre de is

cout<<"s2="<<s2<<endl;

cout<<"a="<<a<<" b="<<b<<endl; // affichage pour verifier

}

Résultat:

3.5.4.3 Conversion nombre <-> chaine de caractere qui représente le nombre en base 2

#include <iostream>

using namespace std;

#include <string>

#include <bitset>

//.....

main ()

{

 

//... Conversion entier -> string (base 2)

int n4=117;

string s4 = bitset<8>(n4).to_string(); // nombre -> string (base 2)

cout<<"n4="<<n4<<" s4="<<s4<<endl;

 

//.. Conversion string (nombre en base 2) -> entier

string s5="10011";

unsigned long n5 = bitset<8>(s5).to_ulong();

cout<<"s5="<<s5<<" n5="<<n5<<endl;

}

Resultat:

 

n4=117 s4=01110101

s5=10011 n5=19

3.5.4.4 Conversion de string vers char*

3.5.5 Quelques opérations en base 2 (binaire, les bits) et en base 16 (hexadecimale)

 

#include <iostream>

using namespace std;

#include <bitset>

main ()

{

//... Declaration et Affichage en base deux:

int A=0b1001; // declaration en base 2 (prefixe 0b)

cout<<" A="<<A<<" en binaire = "<<bitset<8>(A)<<endl;

cout<<" Nombre de bits non nuls de A="<< bitset<8>(A).count()<<endl;

 

//.. decalages de bits

int b= A<<4; // equivalent: b= A * pow(2,4)

cout<<" b ="<<b<<" = "<< bitset<8>(b)<<endl;

int c = b>>3; // equivalent: c= b / pow(2,3)

cout<<" c ="<<c<<" = "<< bitset<8>(c)<<endl;

 

//.. operations bits a bits

int B = 0b1;

int d = A | B; // ou inclusif bit a bit cad 1|1 donne 1

int e = A ^ B; // ou exclusif bit a bit cad 1^1 donne 0

int f = A & B; // et bit a bit

int g = ~A; // non A, inversion des bits

 

cout<<" B="<<B<<" = "<<bitset<4>(B)<<endl;

cout<<" A|B = "<<d<<" = "<<bitset<4>(d)<<endl;

cout<<" A^B = "<<e<<" = "<<bitset<4>(e)<<endl;

cout<<" A&B = "<<f<<" = "<<bitset<4>(f)<<endl;

cout<<" ~A = "<<g<<" = "<<bitset<8>(g)<<endl;

}

Resultat:

3.5.6 tuple : ensemble d'objets divers

 

#include <iostream>

using namespace std;

#include <tuple>

main ()

{

//... construction

tuple<int,char> o1(10,'x'); // creation d'un objet constitué d'un entier 10 et un caractère x

auto o2 = make_tuple ("test", 3.1, 14, 'y'); // construction sans preciser les types

 

//... lecture des elements

int a = get<0>(o1); // on extrait le premier element (position 0)

cout<<"a="<<a<<endl;

 

int b; char c;

tie (b,c) = o1; // extraits les elements de o1

cout<<"b="<<b<<" c="<<c<<endl;

int d;

tie (ignore, ignore, d, ignore) = o2; // extrait certains elements de o2

cout<<"d="<<d<<endl;

 

//..... ecriture d'elements

get<0>(o1) = 100; // on remplace l'element 0 de o1

cout<<"o1[0]="<<get<0>(o1)<<endl;

//.. concatenation de tuples

auto o3 = tuple_cat(o1,o2);

cout<<"o3[5]="<<get<5>(o3)<<endl;

}

Résultat:

 

a=10

b=10 c=x

d=14

o1[0]=100

o3[5]=y

3.5.7 Vecteurs et matrices avec la librairie armadillo

3.5.7.1 Diagonalisation d'une matrice symétrique réelle

#include <iostream>

using namespace std;

#include <armadillo>

using namespace arma;

main ()

{

int N=3;

mat M = randu<mat>(N,N); // elements au hasard

M= 0.5*(M + trans(M)); // la rend symetrique

vec val_p;

mat vec_p;

eig_sym( val_p, vec_p, M);

cout<<"Matrice symetrique M="<<endl<<M<<endl;

cout<<"valeurs propres="<<endl<<val_p<<endl;

cout<<"vecteurs propres en colonnes="<<endl<<vec_p<<endl;

cout<<"Verification M v0-l0 *v0 = 0 ? on trouve: "<<endl<<M*vec_p.col(0) - val_p(0) *vec_p.col(0) <<endl;

}

Résultat:

3.5.7.2 Diagonalisation d'une matrice hermitienne complexe

#include <iostream>

using namespace std;

#include <armadillo>

using namespace arma;

main ()

{

int N=3;

cx_mat M = randu<cx_mat>(N,N); // elements au hasard

M= 0.5*(M + trans(M)); // la rend symetrique

vec val_p;

cx_mat vec_p;

eig_sym( val_p, vec_p, M);

cout<<"Matrice symetrique M="<<endl<<M<<endl;

cout<<"valeurs propres="<<endl<<val_p<<endl;

cout<<"vecteurs propres en colonnes="<<endl<<vec_p<<endl;

cout<<"Verification M v0-l0 *v0 = 0 ? on trouve: "<<endl<<M*vec_p.col(0) - val_p(0) *vec_p.col(0) <<endl;

}

Résultat:

3.5.7.3 Diagonalisation d'une matrice complexe quelconque

#include <iostream>

using namespace std;

#include <armadillo>

using namespace arma;

main ()

{

int N=3;

cx_mat M = randu<cx_mat>(N,N); // elements au hasard

cx_vec val_p;

cx_mat vec_p;

 

eig_gen( val_p, vec_p, M); // diagonalise

 

//... ordonne les valeurs propres (et vect p) par module decroissant

uvec indices = sort_index(abs(val_p),"descend"); // liste des indices, "ascend" or "descend"

val_p=val_p(indices); // vecteur ordonné

vect_p=vect_p.cols(indices); // vecteur ordonné

 

cout<<"Matrice complexe M="<<endl<<M<<endl;

cout<<"valeurs propres="<<endl<<val_p<<endl;

cout<<"vecteurs propres en colonnes="<<endl<<vec_p<<endl;

cout<<"Verification: M v0-l0 *v0 = 0 ? on trouve: "<<endl<<M*vec_p.col(0) - val_p(0) *vec_p.col(0) <<endl;

}

3.5.7.4 Matrices creuses

#include <iostream>

using namespace std;

#include <armadillo>

using namespace arma;

 

main ()

{

int N=10;

 

//---- creation de matrice sparse

sp_mat A = sprandu<sp_mat>(N, N, 0.1); // matrice sparse N*N aleatoire avec une densite 0.1 d'elements non nuls

sp_mat B(N,N);

B(1,2)=1;

cout<<"Matrice B="<<endl<<B<<endl; // affiche que les elements non nuls

sp_mat M = A.t()*A;

M(1,1)=1;

cout<<"Matrice symetrique M="<<endl<<M<<endl; // affiche que les elements non nuls

 

//---------- diagonalisation

vec val_p;

mat vec_p;

int n=5;

eigs_sym(val_p, vec_p, M, n, "lm"); // chercher les n premieres eigenvalues/eigenvectors avec option: "lm": les + grandes (default), ou "sm": les + petites.

cout<<"valeurs propres="<<endl<<val_p<<endl;

cout<<"vecteurs propres en colonnes="<<endl<<vec_p<<endl;

cout<<"Verification M v0-l0 *v0 = 0 ? on trouve: "<<endl<<M*vec_p.col(0) - val_p(0) *vec_p.col(0) <<endl;

}

Chapitre 4 Les instructions de base

4.1 La boucle "for"

 

#include <iostream>

using namespace std;

 

int main()

{

for(int i=2; i<=8; i=i+2)

{

 int j=i*i;

 cout <<i << "\t "<<j <<endl;

}

   }

résultat:

résultat:

6,8,4,13,

#include <iostream>

using namespace std;

int main()

{

for(int i=2; i<=8; i=i+2)

   cout<<"i="<<i<<endl; // pas d'accolades

 

for(int i=2; i<=8; i=i+2)

  {   // accolade de debut de bloc

  int j=i*i;

  cout<<"i="<<i << "\t "<<"j="<<j <<endl;

  }  //accolade de fin

 

}

résultat:

 

i=2

i=4

i=6

i=8

i=2 j=4

i=4 j=16

i=6 j=36

i=8 j=64

4.2 Ecrire une condition

4.2.1 Les opérateurs de comparaison:

Attention à la confusion possible entre == et =:

4.2.2 Les opérateurs logiques

 

#include <iostream>

using namespace std;

 

main ()

{

int a=1, b=2, c=3;

if( ((a <= b ) || (b >=c) ) && (a<c) )

  cout<<"Yes"<<endl;

else

  cout<<"No"<<endl;

}

4.2.3 Remarque

4.3 La boucle “do {..} while (..);”

#include<iostream>

using namespace std;

 

main( )

{

int MAX(11);

int i(1),j;

do

 {

  j=i*i;

  cout<<i<<"\t "<<j<<endl;

  i=i+1; // Ne pas oublier l'incrémentation

 }

while(i<MAX); //condition

}

résultat:

4.4 La boucle “while (..) {..} ;”

#include <iostream>

using namespace std;

 

main ( )

{

int max=11;

int i=1, j;

while(i<max) // condition

 {

  j=i*i;

  cout<<i<<"\t"<<j<<endl;

  i=i+1; // ne pas oublier l'incrémentation

 }; // ne pas oublier le point virgule

    }

Résultat:

4.5 L'instruction “if”

 

#include<iostream>

using namespace std;

 

int main()

{

for(int i=1; i<=10; i=i+1)

 {

   if (i==4)

     cout<<"i= "<<i<<endl;

 }

}

Résultat

Exemple plus général:

#include<iostream>

using namespace std;

int main()

{

for(int i=1; i<=10; i=i+1)

{

if (i == 4)

 cout<<"i="<<i<<endl;

else if(i==5)

 cout<<"2*i= "<<2*i<<endl;

else

 cout<<"."<<endl;

}

}

Résultat:

4.6 break : pour sortir de la boucle. continue: pour sauter l'instruction.

#include <iostream>

using namespace std;

int main()

{

for(int i=2;i<=10;i=i+2)

{

if (i==4)

continue; // on passe au suivant.

    if (i==8)

break; // on sort de la boucle

    int j=i*i;

cout<<i << "\t "<<j <<endl;

}

   }

Chapitre 5 Les fonctions

5.1 Exemple de fonction qui renvoit un objet

 

#include<iostream>

using namespace std;

 

//======declaration de la fonction carre ===================================

double carre(int i)

{

 double j=i*i;

 return j; //on renvoie le résultat au programme principal

}

 

//===declaration de la fonction principale =====

int main()

{

 int x;

 cout<<"entrer x "<<endl;

 cin>>x;

 double y=carre(x); // appel de la fonction carre

 cout<<"Le carré de "<<x<<" est "<<y<<endl;

}

résultat:

 

entrer x

2

le carré de 2 est 4

5.2 Exemple de fonction qui ne renvoit rien

 

#include <iostream>

using namespace std;

 

//!========declaration de la fonction carre=============

void carre(int i)

{

 int j=i*i; // declaration d'un objet local

 cout<<"le carré de "<<i<<" est "<<j<<endl;

}

 

//!====declaration de la fonction principale =====================

int main()

{

 int x;

 cout<<" entrer x "<<endl;

 cin>>x;

 carre(x); // appel de la fonction carre

}

résultat:

 

entrer x

2

le carré de 2 est 4

5.3 Paramètres des fonctions par référence

#include<iostream>

using namespace std;

 

//====== fonction permute ==================

void permute(int& i,int& j) // passage des parametres par reference

{

int t=i; // stockage temporaire

i=j;

j=t;

}

//======== fonction main ===================

int main()

{

int a=10, b=5;

cout<<a<<" "<<b<<endl;

permute(a,b);

cout<<a<<" "<<b<<endl;

}

résultat:

 

10 5

5 10

5.4 La surcharge des fonctions.

5.4.1 Exemple:

 

#include<iostream>

using namespace std;

 

//-------------------------------------------

void f(int i)

{

 cout<<"fonction 1 appelée"<<endl;

 cout<<" paramètre = "<<i<<endl;

}

 

//-------------------------------------------

void f(char *s,int i)

{

 cout<<"fonction 2 appelée"<<endl;

 cout<<" paramètre = "<< s <<endl;

 cout<<" paramètre = "<< i <<endl;

}

 

//---------------------------------------------

int main()

{

 f(10);

 f("Chaîne ",4);

}

Renvoit

afin qu'il affiche comme résultat:

a= 5 a!=120

Chapitre 6 Les pointeurs

6.1 Déclaration et affectation d'un pointeur

La notion de pointeur est importante dans le langage C et C++. Elle est réputée comme étant difficile et technique; nous espérons que vous aurez néanmoins les idées claires après la lecture de cette section.

Nous introduisons rapidement la notion de pointeur, et montrons comme exemple, son intérêt pour créer des tableaux de taille variable au cours du programme.

Rappellons déjà ce qu'est un objet. Par exemple:

int i;

Cette instruction a pour effet de réserver un ”objet” en mémoire de l'ordinateur, permettant de stocker un nombre entier. Cet objet s'appelle 'i' son type (ou sa classe) est int.

Bien sûr, cet objet se trouve quelque part dans la mémoire de l'ordinateur. Il a un certain emplacement, caractérisé par son “adresse mémoire”, appellée son pointeur.

Il faut donc retenir que pointeur d'un objet signifie adresse d'un objet dans la mémoire de l'ordinateur.

On peut avoir accès à l'adresse de l'objet i en faisant &i:

int i=2; // déclare l'objet i et affecte la valeur 2

int *p; // déclaration du pointeur p

p=&i; // p devient l'adresse de i

Grâce au signe *, la deuxième ligne déclare p comme étant un pointeur sur entier (c'est à dire une adresse d'un objet contenant un entier).

 

• Le signe &i signifie l'adresse de l'objet i.
• (*p) signifie l'objet situé à l'adresse du pointeur p.
• Si fonction() est une fonction appartenant à une classe et si p est un pointeur d'un objet de cette classe, alors
  l'instruction p->fonction(); est équivalente à (*p).fonction();

 

Schéma qui résume ce que l'on vient d'expliquer:

Conséquences:

pour afficher le contenu de l'objet i on a maintenant deux possibilités qui sont équivalentes:

cout<<i;

ou:

cout<<(*p);

Pour modifier le contenu de l'objet i on a maintenant deux possibilités qui sont équivalentes:

i=5;

ou:

(*p)=5;

Remarque 6.1.1. Attention: avant d'effectuer l'opération d'écriture: (*p)=5; il faut être sur que l'adresse du pointeur correspond à un objet existant. Vous avez donc compris que avant d'écrire, il faut prendre le soin de réserver de la place mémoire. On parle d'allocation de la mémoire.

On comprends l'écriture int *p; comme la déclaration que *p est un objet de type int, donc p est un pointeur sur un objet de type int.

6.1.1 Paramètres de la fonction main()

Jusqu'à présent, nous avons écrit la fonction principale du programme par la déclaration int main() {...}

En fait cette fonction peut prendre des paramètres et renvoyer un entier. Cela peut être utile pour passer des paramètres à un programme et obtenir des paramètres en retour. Voici un exemple que l'on commente ensuite:

#include <iostream>

using namespace std;

 

int main(int argc, char *argv[])

{

cout<<"nombres de parametres argc ="<<argc<<endl;

cout<<" Ce sont:"<<endl;

 

for(int i=0;i<argc; i++)

{

  cout<<"argv["<<i<<"] = "<<argv[i]<<endl;

}

return 0; // renvoit l'entier 0 (signifie habituellement 0K)

}

Exécution

 

./test 2 toto 5

Résultat:

 

nombres de parametres argc =4

Ce sont:

argv[0] = ./test

argv[1] = 2

argv[2] = toto

argv[3] = 5

Commentaires

On a lancé le programme par la commande ./test 2 toto 5 qui contient en effet 4 paramètres, le premier étant le nom du programme lui même. Cet exemple montre que au début du programme main(..) , la variable argc contient le nombre de paramètres et argv est un tableau de chaines de caractères pour chacun de ces paramètres.

6.2 Allocation dynamique de la mémoire

On peut réserver en mémoire de l'ordinateur une suite de n objets de type double par l'instruction:

p=new double[n];

Après cela, p pointe sur le premier objet réservé.

Remarque 6.2.1. De façon similaire p=new string[13]; réserve en mémoire une suite de 13 objets de type string

Cela s'appelle une allocation dynamique de la mémoire, car elle se fait au cours de l'éxécution du programme.

Il y a n objets, numérotés de 0 à n-1.

on peut écrire dans la case du premier objet par l'instruction:

(*p)=1;

ou (ce qui est équivalent)

p[0]=1;

On peut de même écrire dans la case suivante par:

*(p+1)=2;

ou

p[1]=2;

etc... jusqu'à p[n-1].

A la fin de l'utilisation, n'oubliez pas de libérer l'emplacement mémoire par l'instruction:

delete [ ] p; // on libere les cases mémoire

Exemple:

 

#include<iostream>

using namespace std;

int main()

{

int n;

cout <<"entrez nbre d'objets n >=0 ?"<< flush;

cin >> n;

double *p; //on déclare le pointeur p

p=new double[n]; // on réserve n cases mémoire de la classe double

 

//--- remplissage des cases memoires

for(int i=0; i<n; i++)

p[i]=2*i;

 

//---- affichage

for(int i=0; i<n; i++)

cout<<" p["<<i<<"]="<<p[i]<<endl;

 

delete [ ] p; // on libere les cases mémoire

}

Résultat:

entrez nbre d'objets n >=0 ?3

p[0]=0

p[1]=2

p[2]=4

 

6.2.0.1 Remarques

1. On peut réserver un nombre fixe de cases en mémoire par l'instruction:
   

   double p[6]; // creation de 6 cases mémoires de type double, numérotées de 0 à 5.

   p[1] = 3.14; // on écrit dans la case 1.

   Il s'agit d'une allocation de mémoire dite statique (non dynamique) car le nombre de case est fixé à la compilation, et ne peut être variable. On peut aussi déclarer et initialiser en même temps:

   double p[6] = {1, 3.14, 3., 0.};

2. Si l'on veut ne réserver qu'une seule case mémoire au lieu d'un tableau, il suffit de faire:
   

   int *p;

   p=new int; // on réserve une case mémoire de classe int.

   (*p)=1;

   delete p; // pour libérer la place mémoire

3. Un tableau de caractères est aussi appelé une chaîne de caractères. Pour ce cas il y a une initialisation spéciale:
   

   char *chaine = “toto”;

qui déclare chaine comme étant un pointeur sur caractère, pointant sur les 4 caractères toto.

Exercice 6.2.2. “pointeurs” (*) Ecrire un petit programme qui demande à l'utilisateur un entier n compris entre 1 et 5, puis alloue de façon dynamique un tableau p de taille n de la classe string. Ensuite dans une bloucle on demande à l'utilisateur le contenu de chaque case du tableau. A la fin, on affiche le contenu du tableau. L'execution du programme doit donner cela (par exemple):

 

entrez n? 3

entrez p[0] ? un

entrez p[1] ? petit

entrez p[2] ? programme

p[0] =un

p[1] =petit

p[2] =programme

6.3 Utilisation des pointeurs avec la librairie graphique ROOT

6.3.1 Utiliser une liste d'ellipses

#include <TApplication.h>

#include <TEllipse.h>

#include <TCanvas.h>

#include <vector>

using namespace std;

 

int main()

{

 TApplication theApp("App", nullptr, nullptr);

 

 TCanvas c( "c","fenetre",400,400); // on precise la taille en pixels

c.Range(-2,-2,8,2); // coordonnees de la fenetre

 

//-------------

vector<TEllipse> tab_e(3); // liste de 3 ellipses

 

for (int i=0; i<3; i++)

{

 tab_e[i].SetX1(3*i); // coord x du centre

 tab_e[i].SetY1(0); //coord y du centre

 tab_e[i].SetR1(1); // rayon selon x

 tab_e[i].SetR2(1); // rayon selon y

 tab_e[i].SetFillColor(kWhite);

 tab_e[i].Draw(); // dessin

}

     //-------------

  c.Update();

 theApp.Run();

}

6.3.1.1 Remarques:

• Rappel: dans l'instruction “for”, l'instruction i++ est équivalente à i = i+1. De même i-- est équivalente à i = i-1
• Pour enlever l'ellipse numéro 1 de la liste, il faut utiliser la fonction erase() de la classe vector:

tab_e.erase(tab_e.begin()+1);
Rajouter cette ligne au bon endroit, dans le programme précédent et observer le résultat.

6.3.2 Utiliser un pointeur sur l'ellipse

#include <TApplication.h>

#include <TEllipse.h>

#include <TCanvas.h>

#include <vector>

using namespace std;

 

int main()

{

 TApplication theApp("App", nullptr, nullptr);

 

 TCanvas c( "c","fenetre",400,400); // on precise la taille en pixels

c.Range(-2,-2,8,2); // coordonnees de la fenetre

 

//-------------

TEllipse *pe; // crée un pointeur sur TEllipse

for (int i=0;i<3;i++)

{

pe= new TEllipse(3*i,0,1); // pe pointe sur une ellipse crée en position x=3*i, y=0, rayon 1

pe->Draw(); // dessin

   }

     //-------------

  c.Update();

 theApp.Run();

}

6.3.2.1 Remarques:

Chapitre 7 Création d'une classe

7.1 Exemple (étape1)

7.2 Exemple (étape2)

//====== Programme principal =======================

int main()

{

Vect *w = new Vect(); // declaration

w->x=0; w->y=3; w->z=4;

cout << "Norme de w = " << w->Norme() << endl;

}

Résultat:

Commentaires

• La déclaration Vect *w signifie que w est un pointeur (c'est à dire une adresse) sur un objet de la classe Vect. le code w = new Vect(); a pour effet de créer un objet à cette adresse.
• A la deuxième ligne le code w->x=0; met la valeur 0 dans la variable membre x de l'objet pointé par w. De façon générale pointeur->variable est la façon de désigner une variable associée à un objet qui est pointé par le pointeur.
• A la troisième ligne du programme principal, le code w->Norme() appèle la fonction Norme() qui est déclarée dans la classe. De façon générale pointeur->fonction() est la façon d'appeler une fonction membre associée à un objet pointé par le pointeur pointeur.

Chapitre 8 Les fichiers

8.1 Ecriture de données dans un fichier

#include <iostream>

using namespace std;

#include <fstream> // utilisation des fichiers

 

int main()

{

 ofstream f("hector.txt"); // ouvre le fichier hector.txt pour y ecrire. On lui associe l'objet: f

 f<<3.1514<<endl; // permet d'ecrire dans le fichier.

 f.close(); // fermeture du fichier f

}

8.1.0.1 Remarque:

1. On a choisit de terminer le nom du fichier hector.txt par le suffixe .txt. Ce n'est pas une obligation, mais une convention: txt signifie texte, et précise que ce fichier peut se lire comme un texte (même si il y a des chiffres). De la même façon le fichier qui contient votre programme se termine par .cc pour signifier que c'est le texte d'un programme C++.
2. Pour écrire dans le fichier, on a utilisé un objet intermédiaire de la classe ofstream (abréviation de output-file-stream).Cet objet a été initialisé avec le nom du fichier, et pour écrire dans le fichier on utilise la même syntaxe que pour écrire à l'écran (avec f à la place de cout).
3. L'ouverture du fichier se fait par l'initialisation de l'objet f avec le nom du fichier donné sous la forme d'une chaine de caractères. On peut donc passer un objet intermédiaire (chaine de caractères) de la façon suivante:
   string nom=”hector.txt”
   ofstream f(nom);
4. Lorsque l'on a effectué l'opération f.close(), f est un objet de la classe ofstream et close() est une fonction de cette classe. On parle de fonction membre. Remarquez la syntaxe: l'objet et la fonction membre sont reliés par un point.
5. Attention, la commande ofstream f("hector.txt"); ouvre le fichier mais efface les données existantes si il y en avait. Pour rajouter des données à un fichier existant (ou non existant) il faut l'ouvrir avec l'instruction ofstream f("hector.txt",ios::app); (“app” signifie “append”, “ajouter”)

8.1.0.2 Exercice

8.2 Lecture de données depuis un fichier

#include<iostream>

using namespace std;

#include<fstream> // utilisation des fichiers

 

int main()

{

ifstream g("hector.txt");// ouvre un nouveau fichier en lecture. On lui associe l'objet: g

double x;

g>>x; //on lit ce qu'il y a au début du fichier, et on le copie dans l'objet x

cout<<x<<endl; // on écrit à l'écran le contenu de x

g.close(); // fermeture du fichier g

}

8.2.0.1 Remarques:

1. Si le début du fichier n'avait pas contenu de chiffre (mais des lettres ou rien du tout) le programme n'aurait rien mit dans l'objet x.
2. On peut de la même façon écrire ou lire plusieurs données à la suite dans un fichier: il est important de savoir que le programme est au départ positionné au début du fichier, puis après avoir lu (ou écrit) une donnée, il se trouve positionné juste après cette donnée, prêt à lire la donnée suivante.
3. La lecture g>>x depuis le fichier est similaire à la syntaxe de lecture cin>>x depuis le clavier.
4. A la place de cout<<x<<endl; on peut écrire les instructions:

if(g.good())

cout<<x<<endl;
 
En effet g.good() renvoit true si la lecture précédente s'est bien faite.

8.3 Suppléments sur les fichiers

#include <iostream>

using namespace std;

#include <string>

#include <fstream>

int main()

{

//... ecrit des lignes de texte dans un fichier

ofstream f("test.txt");

f<<"ligne1: abc"<<endl;

f<<"ligne2: def"<<endl;

f.close();

//... ouvre le fichier en lecture

ifstream g("test.txt");

string l;

while(g.good())

{

getline(g, l);// -> l. copie la ligne dans l (sans le code retour a la ligne)

cout<<l<<endl; // affiche ligne l

}

g.clear(); // remet les indicateurs à zero pour continuer la recherche.

//....

g.seekg(0, g.beg); // se place au debut du fichier (begining + 0)

int p;

p=g.tellg(); // -> position p dans le fichier

cout<<"p="<<p<<endl;

char c;

for(int i=0; i<=5; i++)

{

g.get(c); // -> c. Lit caractere

cout<<c;

}

cout<<endl;

p=g.tellg();

cout<<"p="<<p<<endl;

}

résultat

 

ligne1: abc

ligne2: def

p=0

ligne1

p=6

Chapitre 9 Micro-projets 1

9.1 Que faire avant de programmer?

1. Définir clairement l'objectif du programme (surtout s'il y a plusieurs personnes à y collaborer).
2. Définir l'ensemble des tâches qui doivent être accomplies dans un ordre logique pour atteindre cet objectif. Pour un projet scientifique il faut que toutes les formules mathématiques soient bien écrites.
3. Tracer sur un papier un organigramme illustrant le fonctionnement de votre programme. Vérifiez que l'ordre d'exécution des diverses tâches va effectivement faire ce que vous attendez.
   
   En fait, votre organigramme se traduira directement dans la partie principale de votre programme (fonction int main()). A chaque tâche correspondra l'appel d'une sous partie (une fonction).
4. Déterminez la méthode (algorithme) permettant de remplir chaque tâche. Il est possible qu'une sous-tâche soit commune à plusieurs fonctions. Dans ce cas, faites-en une nouvelle fonction. Cependant, pour éviter une multiplication de ces fonctions, ne le faites que pour celles faisant plusieurs lignes de programme. L'art de la programmation consiste à trouver un compromis entre la simplicité, la longueur, et la rapidité d'éxécution de votre programme.
5. Si le programme effectue des taches complexes et “imprévisibles”, imaginer des situations simples où l'on connait la solution et qui permettront de tester le programme.

9.1.1 Quelques notions de qualité en informatique

• modulaire: chaque fonction devrait être indépendante en vue d'être éventuellement utilisée dans un autre programme. Dans ce but n'hésitez pas à créer une nouvelle classe dès que le besoin se fait sentir.
• utilisable par autrui : chaque fonction (et classe) devrait avoir en entête des commentaires indiquant,
  
  1. son objectif,
  2. l'algorithme ou méthode utilisée,
  3. la liste des objets d'entrée,
  4. la liste des objets de sortie,
  5. (éventuellement) des instructions sur la manière de l'appeler et un exemple d'utilisation.
  Cet ensemble d'informations correspond à une sorte de cahier des charges d'une fonction. Lors d'un travail en équipe, il appartient à chacun de travailler sur des fonctions différentes. Il faut donc se mettre d'accord au préalable sur la manière dont chaque fonction va dialoguer avec les autres.
• lisible : tant que possible, utiliser des noms évocateurs pour les objets (mais pas trop longs) et les fonctions.
• fiable : éviter au maximum l'utilisation d'objets globaux, sauf si ils permettent un véritable gain en lisibilité (passage d'arguments moins fréquents). Dans ce cas, indiquer dans un commentaire le (ou les) objet(s) global(aux) qu'une fonction attend.

9.2 Suite de Syracuse

9.3 Pendule simple

Equations physiques:

Méthode de résolution numérique

Structure du programme

9.4 La fractale du dragon

9.5 Images subliminales

9.6 Equation de la chaleur

9.7 Le jeu puissance 4

• Faire un programme qui permet de jouer à deux personnes au jeu de puissance 4, et affiche le résultat sur le terminal (avec cout). Stocker l'état du jeu dans une matrice d'entiers.
• En option, on peut jouer contre l'ordinateur. Développer une stratégie par recherche arborescente.

9.8 Le jeu de la vie

9.9 Algorithme de Monte-Carlo pour le modèle d'Ising

Figure 9.1: Résultat de l'algorithme de Monte-Carlo pour le modèle d'aimantation de Ising, aux températures $\beta =1/\left(k_{b}T\right)=0.3$ (désordre), $0.4$ (transition de phase) et $0.5$ (ordre magnétique).

9.9.1 Algorithme de Monte-Carlo

1. A l'instant $n=0$, on part d'une configuration $f$ choisie au hasard.
2. On choisit un site $X_0$ au hasard, et on note $f\text{'}$ la configuration identique à $f$ sauf au site $X_0$ où le spin est opposé: $f{\text{'}}_{X_0}=-f_{X_0}$ (spin opposé).
3. Choix de la configuration à l'instant $n+1$,
   
   1. Si $E\left(f\text{'}\right)<E\left(f\right)$ on choisit la configuration $f\text{'}$.
   2. Si $E\left(f\text{'}\right)\ge E\left(f\right)$ on choisit la configuration $f\text{'}$ avec la probabilité $P_{f\to f\text{'}}=exp\left(-\beta \mathrm{.}\left(E\left(f\text{'}\right)-E\left(f\right)\right)\right)$ (et on choisit $f$ avec la probabilité complémentaire).
4. On revient en (2) pour poursuivre l'évolution du champ de spins.

Remarque 9.9.2. Cet algorithme correspond à une matrice stochastique réversible pour la mesure de Boltzmann:$$u\left(f\right)=\frac{1}{Z}exp\left(-\beta E\left(f\right)\right)$$

9.10 Zeros d'un polynome aléatoire

sls

Partie II Compléments sur le langage C++