\documentclass{article}
\usepackage[latin1]{inputenc}
\usepackage[T1]{fontenc}
\usepackage{amsmath,amsfonts,amssymb}
\usepackage[francais]{babel}
\usepackage{times}
\usepackage{xspace}
\usepackage{makeidx}
\usepackage{ifpdf}
\ifpdf
 \usepackage[colorlinks,pdftex]{hyperref}
\fi
\begin{document}
\date{juin 2000 environ}
\title{Initiation \`a la programmation pour les sciences.}
\author{Sous licence FDL\footnote{Ce manuscrit contient des contributions
de Ren\'ee de Graeve, 
Fr\'ed\'eric Faure, 
Jonathan Ferreira, 
Bernard Parisse, 
Philippe Peyla
G\'erard Vinel, 
}~: 
{\tt http://www.gnu.org/copyleft/fdl.html} }
\maketitle

\tableofcontents


\section{G\'en\'eralit\'es.} \label{sec:generalites}

\subsection{M\'emoire, formats de donn\'ees.} \label{sec:dataprog}
Lorsqu'on utilise un ordinateur, on utilise en fait des programmes
qui manipulent des donn\'ees. Le programme est
ex\'ecut\'e par le microprocesseur (en anglais {\em CPU}\/ 
i.e. Central Processing Unit) de l'ordinateur. Pour que le
microprocesseur puisse acc\'eder aux donn\'ees \`a manipuler par un
programme, ces donn\'ees doivent \^etre plac\'ees dans la m\'emoire
de l'ordinateur. La m\'emoire est constitu\'e de transistors toutes identiques
qui peuvent avoir deux valeurs 0 ou 1. On les regroupe souvent par 8
en formant un {\em octet\/} (en anglais {\em byte}\/), qui peut
prendre $2^8=256$ valeurs. Chaque octet poss\`ede un num\'ero ce qui permet 
au microprocesseur de les distinguer, ce num\'ero s'appelle l'adresse 
m\'emoire. Par exemple, notre serveur \'etudiant dispose d'un giga-octet
(1 GO), c'est-\`a-dire $2^{30}$ soit environ un milliard d'octets.
Cette m\'emoire est appel\'ee RAM: random access memory, ce qui signifie
que l'on peut acc\'eder \`a n'importe quelle cellule m\'emoire (contrairement
\`a une bande magn\'etique par exemple o\`u il faut d'abord se d\'eplacer
au bon endroit).

Lorsque l'ex\'ecution d'un programme est termin\'ee,
les donn\'ees manipul\'ees par ce programme n'ont plus besoin d'\^etre 
en m\'emoire, on les stocke alors dans un disque dur, sur un CD-ROM ou 
sur une disquette et on lib\`ere la place pour d'autres programmes
et donn\'ees.


La m\'emoire permet donc de stocker facilement des entiers compris
entre 0 et 255. Mais on souhaite pouvoir manipuler des donn\'ees 
d'un type diff\'erent, par exemple des lettres (pour pouvoir
\'ecrire un e-mail par exemple), des images, des listes, des tableaux, ...
Il est alors n\'ecessaire d'\'etablir une correspondance entre
ce type de donn\'ees et un ou plusieurs entiers compris entre 0 et 255.
Par exemple on pourrait d\'ecider de repr\'esenter la lettre A par
l'entier 0, la lettre B par l'entier 1, ..., la lettre Z par l'entier
26. Dans la r\'ealit\'e les ordinateurs utilisent plut\^ot le codage
ASCII qui repr\'esente A par 65, B par 66, etc.. Pour repr\'esenter
un texte on utilisera alors une suite cons\'ecutive d'entiers de
la m\'emoire. De plus, on peut
souhaiter enrichir la mise en page en utilisant des tailles de
caract\`eres diff\'erents ou des caract\`eres en gras ou en italique
ce qui complique la repr\'esentation des donn\'ees.
Pour une image, on peut repr\'esenter chaque pixel par une
suite de 3 entiers repr\'esentant l'intensit\'e de la couleur
rouge, bleue, verte de ce pixel. A chaque type de donn\'ee correspond
donc un format de num\'erisation permettant de stocker cette donn\'ee
en m\'emoire \`a l'aide d'un ou plusieurs entiers compris entre 0 et 255.
Pour un programmeur il est essentiel de toujours savoir quel
est le type des donn\'ees que l'on manipule \`a un instant
donn\'e (une lettre, une suite de lettres,
un entier, un nombre r\'eel, etc.)

\subsection{Programme, langage et compilateur.} \label{sec:lang}
Un programme est constitu\'e par une suite d'instructions chacune 
tr\`es simples (par exemple additionner deux entiers compris entre
0 et 255). Les instructions sont ex\'ecut\'ees les unes \`a la suite des
autres, certaines instructions permettent de rompre ce flot
d'ex\'ecution (branchements, boucles, appel de sous-programmes). La dur\'ee
d'une instruction se mesure en nombre de cycles de l'horloge interne
du microprocesseur, la vitesse de cette horloge se mesure en hertz,
par exemple un processeur cadence a 1GHz ex\'ecute 1 milliard
de cycles d'horloge par seconde.

Les instructions du microprocesseur sont cod\'ees par un ou plusieurs 
nombres entiers afin de pouvoir stocker en m\'emoire un programme pour
pouvoir l'ex\'ecuter. Ce codage est le jeu d'instructions du microprocesseur.
Chaque microprocesseur poss\`ede son propre jeu d'instructions.
Pour l'ordinateur, un programme est une suite d'instructions donc une 
suite d'entiers codant ces instructions appel\'e {\em code compil\'e\/}. 
Un programme est donc une donn\'ee, mais d'un type tr\`es particulier (appel\'e
ex\'ecutable) puisque les donn\'ees doivent correspondre \`a des instructions 
du microprocesseur dans un ordre qui correspond \`a un but pr\'ecis, 
l'ex\'ecution du programme.\footnote{On
peut ici faire un parall\`ele avec le code g\'en\'etique. Le role
du code ex\'ecutable est jou\'e par le code ADN, le r\^ole du
microprocesseur est jou\'e par le ribosome qui synth\'etise une
prot\'eine \`a partir du code ADN.}

Pour le concepteur d'un programme, \'ecrire les nombres correspondant
aux instructions du microprocesseur pr\'esente de nombreux d\'esavantages:
\begin{itemize}
\item une action simple (par exemple lire un caract\`ere frapp\'e au
clavier ou afficher un caract\`ere \`a l'\'ecran) n\'ecessite plusieurs
dizaines voir plusieurs centaines ou millers d'instructions du 
microprocesseur, \'ecrire un programme simple de cette mani\`ere est
fastidieux,
\item pour un m\^eme programme, il faut r\'e\'ecrire une suite d'entiers
diff\'erente pour chaque processeur 
\item \'ecrire une suite de nombres comme 1, 255,34, 35, 240, 17, 125, ...
n'a pas de sens direct pour un humain alors qu'\'ecrire ``affiche le
carat\`ere A'' a un sens, le risque d'erreur est donc tr\`es important
\end{itemize}
On utilise donc un langage interm\'ediaire pour d\'ecrire les
instructions d'un programme appel\'e langage de programmation. Ce
langage est facile \`a lire et \`a modifier par l'\^etre humain. Le
programmeur \'ecrit une suite d'instructions dans ce langage, on
appelle cette suite d'instructions le {\em source}\/
du programme. 

Le source d'un programme se pr\'esente comme un fichier texte sans 
effets de mise en page, caract\`eres gras ou autres. Pour le
cr\'eer on utilise un logiciel appel\'e {\em \'editeur de texte\/}
(\`a ne pas confondre avec un logiciel de {\em traitement de texte\/},
il ne faut jamais utiliser un logiciel de traitement de texte pour
\'ecrire un fichier source). Le texte source contiendra par
exemple la phrase ``affiche le caract\`ere A'' traduite dans le langage, 
en C++, cette instruction se traduirait par:\\
\verb|  cout << 'A' ;|)\\
Puis un autre logiciel, le {\em compilateur\/},
va traduire le langage de programmation en une suite d'instructions
directement compr\'ehensible par l'ordinateur.\footnote{Si on continue le parall\`ele avec le code g\'en\'etique, on peut dire que d\'ecoder le g\'enome
correspond \`a inventer un langage permettant de comprendre
facilement le r\^ole biologique de tel ou tel morceau de chromosome, 
ce langage ``compil\'e'' \'etant le code ADN.}

\subsection{Syst\`eme d'exploitation et syst\`eme de fichiers.} 
\label{sec:fichiers}
On a vu dans les sections pr\'ec\'edentes que la cr\'eation d'un
programme n\'ecessite plusieurs \'etapes:
\begin{itemize}
\item \'ecrire le texte source du programme
\item le compiler avec un compilateur
\item ex\'ecuter le programme
\end{itemize}
La r\'ealisation de chacune de ces \'etapes n\'ecessite de pouvoir 
ex\'ecuter un logiciel d\'edi\'e \`a cet usage et de pouvoir manipuler 
les donn\'ees correspondantes sur le disque dur ou sur une
disquette (le texte source du programme et le programme compil\'e). 
C'est le r\^ole du syst\`eme d'exploitation d'un ordinateur et
des syst\`emes de fichiers pour les donn\'ees qu'il stocke.

\subsubsection{Syst\`eme de fichiers.} \label{sec:file}
Avant d'\^etre stock\'ees par exemple sur le disque dur, les donn\'ees 
sont regroup\'ees en un ensemble appel\'e fichier (en anglais {\em file}\/). 
Chaque fichier porte un nom.
Les fichiers sont eux-m\^emes organis\'es en ensembles appel\'es
r\'epertoires (en anglais {\em directory}\/)
selon une structure arborescente.
Chaque noeud de l'arborescence est un r\'epertoire dans lequel on
trouve des fichiers ou d'autres r\'epertoires.
Dans les syst\`emes de fichiers Unix, les noms des r\'epertoires ``noeuds'' de
l'arborescence sont s\'epar\'es par le signe \verb|/|.
Par exemple \texttt{/h/moore/u4/phyliphrec/aaal/toto.cc} 
signifie que le fichier \texttt{toto.cc} se trouve dans le r\'epertoire 
\texttt{aaal} qui se trouve lui-m\^eme dans le r\'epertoire 
\texttt{phyliphrec}, qui se trouve lui m\^eme dans ...

Les noms de fichiers sont souvent compos\'es d'un premier mot suivi
d'un point et d'une ``extension'' de 1 \`a 3 lettres qui donne
une indication sur le format de num\'erisation ou l'usage du fichier.
Par exemple le nom \verb|toto.cc| est compos\'e du mot \verb|toto| et
de l'extension \verb|cc| qui signifie que le fichier est un programme
\'ecrit en C++. 

\subsubsection{Syst\`emes d'exploitation.} \label{sec:shell}
Il s'agit du logiciel qui permet en particulier d'acc\'eder au syst\`eme
de fichiers et de lancer des programmes. L'interaction
entre l'\^etre humain et le syst\`eme d'exploitation peut se faire
de plusieurs mani\`eres: par l'interm\'ediaire d'une interface 
graphique\footnote{On parlera ici d'interface graphique lorsque l'interaction entre le logiciel et l'ordinateur ne se limite pas \`a \'echanger des donn\'ees alphanum\'eriques. Par exemple, lorsqu'on utilise une souris.}
ou par l'interm\'ediaire de commandes interpr\'et\'ees par un logiciel
appel\'e {\em interpr\'eteur de commandes}\/ ou {\em shell\/}. 
Les interfaces graphiques sont souvent plus simples \`a manipuler 
par un utilisateur d\'ebutant,
mais elles pr\'esentent un inconv\'enient majeur: l'effet correspondant
\`a une action donn\'ee (par exemple un click avec le bouton du milieu
de la souris) d\'epend de l'interface graphique car l'action en
elle-m\^eme n'a pas de sens intrins\`eque, l'effet d'une telle action 
\'evolue parfois avec les versions successives d'une m\^eme interface
graphique. 
Les interpr\'eteurs de
commandes sont plus difficiles \`a manipuler au premier abord, mais
les effets correspondent \`a l'utilisation de {\em noms} des commandes, ils
ne changent pas au cours du temps et sont utilisables sur des ordinateurs 
diff\'erents (par exemple les commandes Unix fonctionnent sous GNU/Linux, 
Mac OS X, Solaris, HP-UX, FreeBSD, etc... mais \'egalement sous Windows 
avec les outils \verb|cygwin| qu'on peut r\'ecup\'erer gratuitement sur 
\verb|http://sources.redhat.com/cygwin|).

\subsection{\'Echange de donn\'ees et r\'eseau.} \label{sec:echange}
On a vu que chaque logiciel doit num\'eriser les donn\'ees qu'il manipule 
pour les stocker en m\'emoire, en utilisant un {\em format de donn\'ees}\/. 
Pour que les logiciels puissent communiquer entre eux, ils doivent 
utiliser des formats de donn\'ees communs. Par exemple les caract\`eres 
alphanum\'eriques
sont souvent num\'eris\'es selon le format standard ASCII selon la r\`egle 
suivante: 0 correspond au code 48, 1 \`a 49, etc., A correspond au code 65, 
B \`a 66, etc..

L'\'echange de donn\'ees entre des logiciels situ\'es sur des ordinateurs 
diff\'erents se fait en \'etablissant une connexion entre les
ordinateurs, on cr\'ee ainsi un r\'eseau d'ordinateurs, par
exemple le r\'eseau Internet. Sur le r\'eseau Internet, chaque ordinateur
re\c{c}oit un nom compos\'e de deux parties s\'epar\'ees par un point
(\verb|.|): le nom de la machine (par exemple \verb|pcm2|) et
le nom de domaine (par exemple \verb|e.ujf-grenoble.fr|). 
Sur Internet, les \'echanges 
entre ordinateurs se font selon des r\`egles appel\'ees protocoles qui
correspondent \`a l'usage que l'on fait des donn\'ees
(par exemple \verb|HTTP| pour le web, \verb|SMTP| pour la messagerie,
\verb|FTP| pour l'\'echange de fichiers, etc.).
Pour \'echanger des fichiers entre deux ordinateurs, il faut donc
utiliser un m\^eme protocole pour communiquer physiquement les
donn\'ees et utiliser des formats de donn\'ees compatibles pour que les
logiciels sachent interpr\'eter les donn\'ees transmises (cela parait
\'evident, mais pensez-y lorsque vous envoyez par courrier \'electronique
un fichier attach\'e: par exemple si vous envoyez un fichier au format
Word, il est possible que le destinataire ne poss\`ede pas de logiciel
permettant de lire ce format).

\subsection{Aspects l\'egaux.} \label{sec:legal}
Les logiciels et les donn\'ees num\'eris\'ees ne sont pas des biens
mat\'eriels: on n'ach\`ete jamais un logiciel, on ach\`ete un droit
d'utilisation appel\'e licence, c'est un contrat entre le d\'etenteur
des droits d'auteur et l'utilisateur final. La copie de donn\'ees ou 
de logiciels est donc interdite sans autorisation explicite de 
l'auteur (sous peine d'amende d'un montant pouvant atteindre
300 000 euros ou/et de peines d'emprisonnement).
Certains auteurs de logiciels et/ou documents donnent le droit d'utiliser 
et modifier leurs oeuvres en utilisant des licences pr\'evues \`a cet
effet, comme la FDL (Free Documentation Licence) utilis\'ee pour
ce document, ou la GPL (General Public License: cf. \verb|www.gnu.org|)
utilis\'ee par de nombreux logiciels.
Les logiciels plac\'es sous des licences de ce type sont appel\'es
logiciels libres et peuvent \^etre l\'egalement copi\'es. 
Dans ce module on utilisera chaque fois que cela est possible
des logiciels libres, c'est le cas en particulier du syst\`eme
d'exploitation de notre serveur (GNU/Linux), du compilateur (g++), etc.


\subsection{Exercices.} \label{sec:exos_generalites}
Donner des exemples de logiciels et de formats de donn\'ees correspondants.
Savez-vous dans quelles conditions vous avez le droit d'utiliser 
ces logiciels?

Comment repr\'esenter de mani\`ere simple le code
g\'en\'etique et les 20 prot\'eines? 
Le g\'enome humain comporte environ un milliard de bases A/C/G ou T.
Combien de disquettes (capacit\'e 1.44Mo)
faudrait-il pour sauvegarder votre g\'enome? Combien de CD (capacit\'e
650Mo)?

Comment repr\'esenter une date? le pourcentage d'humidit\'e dans l'air?
Comment repr\'esenter une coordonn\'ee g\'eographique?
Comment repr\'esenter la liste des \'etudiants de ce module?


\section{TP 1} \label{sec:tp1}

\subsection{Quelques commandes Unix.} \label{sec:exos}

Si vous n'avez pas d'interpr\'eteur de commande, il faut utiliser
l'interface graphique pour en lancer une:
\begin{itemize}
\item Si vous \^etes loggu\'e sur une machine CARISM, en
appuyant sur le bouton droit de la souris sur le fond de l'\'ecran, et
selectionner ``\textbf{xterm}''.
\item Si vous \^etes sur un PC Linux avec KDE, en cliquant sur l'icone 
repr\'esentant une fen\^etre terminal ou en cliquant avec le
bouton droit, puis \verb|Executer une commande| puis tapez \verb|xterm|
puis \verb|Entree|
\item Sous Windows, installez \verb|cygwin| si ce n'est pas fait,
dans le menu d\'emarrer choisissez alors CYGWIN ou cliquez sur
l'icone de Cygwin.
\end{itemize}
Attention, les conventions des interfaces graphiques Unix peuvent
diff\'erer des interfaces que vous connaissez~: par exemple, on utilise
le click avec le bouton du milieu (ou click simultan\'e sur les boutons
droits et gauche) pour ins\'erer le contenu du ``presse-papier''.

\subsubsection{Les r\'epertoires:}
\begin{itemize}
\item \verb|pwd|:
afficher le nom du r\'epertoire o\`u vous \^etes (le r\'epertoire courant).
\item \verb|~| : d\'esigne votre r\'epertoire d'origine.\\
\verb|~miasn1| : d\'esigne le r\'epertoire d'origine de l'utilisateur 
dont le nom de login est \verb|miasn1|
\item \verb|ls|: afficher la liste des fichiers et des sous r\'epertoires du 
r\'epertoire courant. Pour avoir plus de d\'etails, \verb|ls -l|.
\item \verb|cd|: changer de r\'epertoire.\\
\verb|cd rep |: pour aller dans le sous r\'epertoire appel\'e \verb|rep|;\\
\verb|cd | ou \verb|cd ~ |: pour aller dans votre r\'epertoire d'origine.\\
\verb|cd ~miasn1 |: pour aller dans le r\'epertoire d'origine de
l'utilisateur \verb|miasn1|.\\
\verb|cd .. |: pour aller dans le r\'epertoire parent. \\
\verb|cd /usr/local |: pour aller dans le r\'epertoire \verb|/usr/local|
\item \verb|mkdir|: Pour cr\'eer un sous r\'epertoire, par exemple\\
\verb|mkdir rep | cr\'ee un sous-r\'epertoire appel\'e \verb|rep|
\item \verb|rmdir|: effacer un r\'epertoire vide, par exemple \verb|rmdir rep|.
\end{itemize}

{\bf Exercice:\\}
A l'aide des commandes expliqu\'ees ci-dessus: 
\begin{enumerate}
\item Placez vous dans votre r\'epertoire d'origine: \textbf{cd}. V\'erifiez 
que vous y \^etes bien: \textbf{pwd}. Regardez la liste des fichiers 
par: \textbf{ls} , puis avec: \textbf{ls -al}
\item En utilisant la commande {\bf mkdir}, cr\'eer un r\'epertoire de 
nom: \textbf{essai} V\'erifier son existence 
(avec {\bf ls}).
\item Aller dans ce r\'epertoire: \textbf{cd essai} 
V\'erifier que vous y \^etes (avec {\bf pwd}).
\item Revenir dans le r\'epertoire d'origine par \textbf{cd .. } V\'erifiez 
que vous y etes. D\'etruire (\verb|rmdir|) le r\'epertoire \textbf{essai.}
\end{enumerate}

\subsubsection{Les fichiers}

\begin{itemize}
\item \verb|cp|: Copier un fichier:\\
\verb|cp essai.cc test.cc |: cr\'ee une copie du fichier 
\verb|essai.cc| nomm\'ee \verb|test.cc| (dans le r\'epertoire courant)\\
\verb|cp fichier1.cc .. |: copie le fichier1.cc dans le 
r\'epertoire parent (situ\'e juste avant le r\'epertoire courant).
\item \verb|mv|: D\'eplace ou/et renomme un fichier.\\
\verb|mv fichier1.cc fichier2.cc |: renomme le fichier \verb|fichier1.cc|\\
Si \verb|rep| est un r\'epertoire, \verb|mv fichier1.cc rep| d\'eplace 
le fichier1.cc dans le sous r\'epertoire \verb|rep|.
\item \verb|rm|: effacer un fichier\\
\verb|rm fichier.cc |: efface le fichier \verb|fichier.cc|.\\
\verb|rm -r rep |: efface le r\'epertoire \verb|rep| et tous ses 
sous-r\'epertoires
\item \verb|emacs|: \'editer un fichier texte\\
\verb|emacs fichier.cc & |: ouvre le fichier \verb|fichier.cc| (le cr\'ee
s'il n'existe pas).
\item \verb|mcopy| (en local uniquement, cf. remarque ci-dessous): 
permet de copier des fichiers sur une disquette, par exemple:\\
\verb|mcopy Programmes/essai.cc a:|\\
recopie le fichier \verb|essai.cc| du r\'epertoire \verb|Programmes|
sur la disquette. Inversement:\\
\verb|mcopy a:essai.cc Programmes|\\
recopie le fichier \verb|essai.cc| de la disquette vers le r\'epertoire
\verb|Programmes|.
\item \verb|mdir a:| (en local): 
liste les fichiers contenus sur la disquette
\end{itemize}

Remarques:
\begin{enumerate}
\item Notez que l'appui sur la touche de tabulation (\`a gauche
de la touche A sur un clavier fran\c{c}ais) est un raccourci clavier
qui permet de compl\'eter automatiquement le d\'ebut d'un nom de fichier
ou d'afficher les diff\'erentes possibilit\'es de compl\'etion.
\item Le caract\`ere \verb|&| plac\'e \`a la fin d'une commande
permet de l'ex\'ecuter en t\^ache de fonds.
\item La lettre \verb|*| \`a une signification sp\'eciale: elle permet
de remplacer n'importe quel morceau de chaine de caract\`eres, par exemple
\verb|ls m*.cc| listera tous les fichiers dont le nom commence par \verb|m|
et se termine par \verb|.cc|
\item Pour avoir plus de d\'etails sur une commande Unix, vous pouvez utiliser
la commande \verb|man|, par exemple, taper dans une fenetre de commande: \\
\verb|man ls|\\
pour en savoir plus sur la commande \verb|ls|.
\item Les commandes de copie sur disquette se lancent en local uniquement.
Pour se logguer en local, taper simultan\'ement sur les touches
\verb|Ctrl| \verb|Alt| et \verb|F1|, entrez votre login et mot de passe
et faites les manipulations sur disquettes, d\'elogguez-vous
en tapant simultan\'ement sur les touches \verb|Ctrl| et \verb|d|.
Pour revenir \`a votre session, tapez simultan\'ement sur les touches
\verb|Ctrl| \verb|Alt| et \verb|F7|.
\end{enumerate}

{\bf Exercice:\\}
Cr\'eez un fichier appel\'e \verb|essai| contenant quelques lignes. 
D\'econnectez-vous et laissez votre binome se connecter. Recopiez le
fichier \verb|essai| de votre binome dans votre r\'epertoire. Renommez-le
\verb|essai.de.mon.binome|. Allez dans la salle 11 et recopiez le
fichier \verb|essai| sur une disquette.

\subsection{Noms et fonction de quelques logiciels.} \label{sec:commandes}
Ces noms de commande vous permettront de lancer les logiciels correspondants
depuis n'importe quel interpr\'eteur de commande (ce qui permet de les 
lancer ind\'ependemment de l'environnement, il suffit de connaitre leur 
nom et non pas dans quel menu ils se trouvent).
\begin{itemize}
\item \verb|emacs|: \'editeur de texte.
\item \verb|firefox|: navigateur Internet. Pour utiliser
le courrier \'electronique avec netscape, il vous faudra configurer 
votre adresse \'electronique. 
Permet \'egalement de lire des fichiers \verb|.html|
\item \verb|abiword|: traitement de texte non scientifique
\item \verb|texmacs| ou \verb|lyx|: traitement de texte scientifique 
particuli\`erement adapt\'e \`a la saisie d'\'equations.
Attention \`a ne pas confondre \'editeur de texte et traitement de texte 
on n'utilise pas \verb|lyx| pour \'ecrire un programme en C++ (cf.
section \ref{sec:emacs}).
%Pour faire des figures \`a l'int\'erieur d'un document \verb|lyx| on utilise souvent le logiciel \verb|xfig|.
\item \verb|gnumeric| (GNU/Linux): tableur, permet par exemple
de lire des fichiers \verb|.xls|
\item \verb|xpdf| ou \verb|acroread|: pour lire des fichiers PDF
(d'extension \verb|.pdf|)
\item \verb|xdvi|: visualiser des fichiers DVI (d'extension \verb|.dvi|)
\item \verb|gv| ou \verb|ghostview|: 
visualiser des fichiers Postscript (d'extension \verb|.ps|)
\item \verb|gimp| (GNU/Linux): traitement d'images par exemple de fichiers
d'extension \verb|.gif|, \verb|.png|
%\item \verb|xv|: visualisation d'images, 
\item \verb|lp| ou \verb|lpr|: imprime un fichier.
\item \verb|zip/unzip| (GNU/Linux): utilitaires de compression/d\'ecompression
d'archives au format zip, tr\`es r\'epandu sur les machines Windows.
%\item \verb|blast|: logiciel de s\'equencage
\item \verb|scilab|: logiciels de calcul num\'erique
\item \verb|xcas|: logiciel de calcul formel et g\'eom\'etrie interactive
\item etc.
\end{itemize}

\section{Les logiciels n\'ecessaires pour programmer.} \label{sec:log_prog}
Rappelons que pour l'ordinateur, un programme est une suite de nombres
en m\'emoire et interpr\'et\'es par le microprocesseur, c'est le
code ex\'ecutable. Ce codage n'est \'evidemment pas adapt\'e \`a l'\^etre
humain. La suite des instructions \`a faire ex\'ecuter
par la machine est donc \'ecrite sous forme d'un texte respectant
des r\`egles de syntaxe d'un langage, ici le C++, cette suite d'instructions
constitue le code source du programme. La traduction du code source
en code ex\'ecutable est r\'ealis\'e par le compilateur.
La r\'ealisation d'un programme se fait donc en trois temps: \'ecrire
le texte constituant le code source, le compiler, puis le tester.

\subsection{\'Ecrire le code source avec emacs.} \label{sec:emacs}
\verb|emacs| est un logiciels appel\'e 
\emph{\'editeur de texte}, car il permet de cr\'eer ou modifier
un fichier qui contient du texte.
Vous connaissez peut \^etre d\'ej\`a d'autres \'editeurs de texte
par exemple: \verb|notepad| ou \verb|wordpad| sous 
Windows; \verb|nedit|, \verb|vi| sous Unix, ...
Ces \'editeurs vont nous servir \`a \'ecrire le code source 
(en C++) des programmes.


\subsubsection{Lancer emacs} \label{sec:lancer_emacs}
Dans une fen\^etre Terminal (\emph{xterm}), taper:
\begin{quotation}
\textbf{emacs bonjour.cc \&}
\end{quotation}
On rappelle que~: 
\begin{itemize}
\item \verb|bonjour.cc| est le nom du fichier C++
\item le signe \textbf{\&} permet de laisser la fen\^etre \emph{xterm} 
disponible pour d'autres commandes UNIX. (Si vous avez oubli\'e le signe
\verb|&|, tapez simultan\'ement sur les touches \verb|Ctrl| et \verb|Z|
puis tapez \verb|bg|).
\end{itemize}
Pour faciliter l'utilisation d'emacs, vous pouvez d\'efinir
des raccourcis claviers, pour cela t\'el\'echargez le fichier\\
\verb|www-fourier.ujf-grenoble.fr/~parisse/.emacs|\\
et sauvegardez-le dans votre r\'epertoire ``home'' ou
ouvrez le fichier \verb|~/.emacs| et ajoutez-y les lignes suivantes~:
\begin{verbatim}
(setq inhibit-splash-screen t) ; pas d'ecran d'accueil 
(show-paren-mode t) ; correspondances de parentheses
(require 'saveplace)
(setq-default save-place t); sauvegarde position du curseur
(global-set-key "\C-g" 'goto-line)
(global-set-key "\C-z" 'advertised-undo)
(global-set-key "\C-v" 'yank)
(global-set-key "\C-c" 'kill-ring-save)
(global-set-key [f1] 'info)
(global-set-key [f2] 'save-buffer)
(global-set-key [f3] 'find-file)
(global-set-key [f9] 'compile)
\end{verbatim}


\subsubsection{Quelques commandes d'\'edition utiles.} \label{sec:edition}
Pensez \`a sauvegardez votre texte de temps en temps en utilisant 
la commande \verb|Save Buffer| du menu \verb|Files| (raccourci clavier
\verb|Ctrl-X Ctrl-S| ou \verb|F2|).

Remarque: si vous souhaitez sauvegarder votre fichier source sous un
autre nom, vous pouvez utiliser la commande \verb|Save Buffer As| du 
menu \verb|Files|.

Pour marquer une s\'election: cliquer avec le bouton gauche de la
souris au d\'ebut, avec le bouton droit \`a la fin. Un double-click
avec le bouton droit supprime la s\'election. Le bouton du milieu
permet d'ins\'erer la s\'election \`a la position de la souris. Si votre
souris ne poss\`ede que deux boutons, cliquez sur les deux boutons
simultan\'ement pour ins\'erer la s\'election.

L'appui simultan\'e sur les touches \verb|Ctrl| et \verb|Z|
permet d'annuler la commande d'\'edition
pr\'ec\'edente. L'appui simultan\'e sur \verb|Ctrl| et \verb|G|
permet d'interrompre une commande en cours.

L'appui sur la touche de tabulation \`a gauche de la touche A
permet d'indenter le texte source ce qui facilite sa lecture.

Entrez maintenant le texte suivant:
\begin{verbatim}
#include <iostream>
using namespace std;

int main(){
  cout << "Bonjour! Ca va?" << endl;
}
\end{verbatim}

\subsection{Compiler votre programme.} \label{sec:compilation}
Dans la fen\^etre de l'interpr\'eteur de commande, tapez:\\
\verb|g++ bonjour.cc|\\
Si vous n'avez pas fait d'erreurs le programme sera compil\'e, c'est-\`a-dire
qu'un fichier ex\'ecutable nomm\'e \verb|a.out| sera cr\'e\'e dans le
r\'epertoire courant. V\'erifiez avec la commande \verb|ls|.
Vous pouvez ex\'ecuter votre programme en tapant:\\
\verb|./a.out|\\
dans la fen\^etre de l'interpr\'eteur de commandes.


\subsubsection{Quelques options du compilateur g++} \label{sec:options}
Comme pour les autres programme GNU, l'aide en ligne de \verb|g++| est
accesible en tapant l'une des commandes:\\
\verb|man g++|\\
\verb|info g++|\\
ou \`a l'int\'erieur d'\verb|emacs| en tapant \verb|F1|
(ou simultan\'ement sur
les touches \verb|Ctrl| et \verb|H| puis en tapant sur \verb|I|).
Voici les options les plus utiles:
\begin{itemize}
\item 
L'option \verb|-g| inclut les informations utiles pour la mise
au point du programme (avec le deboggueur \verb|gdb|).
\item Lorsque votre programme est au point, l'option \verb|-O2|
permet d'optimiser votre programme (le rendre plus rapide)
\item L'option \verb|-o| suivi d'un nom de fichier permet de donner 
un nom au programme compil\'e diff\'erent de \verb|a.out|.
\end{itemize}

\subsubsection{Faire compiler emacs.} \label{sec:emacscompile}
\verb|emacs| est un \'editeur de texte adapt\'e pour faire de la
programmation: il affiche par exemple les {\em mots-clefs}\/ du
langage dans une couleur diff\'erente, indique la parenth\`ese ouvrante
correspondant \`a une parenth\`ese fermante, etc.
On peut aussi lancer la commande compilation du texte source dans
\verb|emacs|. Pour cela il faut indiquer \`a \verb|emacs| dans la
premi\`ere ligne du texte source la commande de compilation que
l'on ex\'ecute habituellement dans la fen\^etre de l'interpr\'eteur
de commande, par exemple~:
\verb|// -*- compile-command: "g++ -g  bonjour.cc" -*-|\\
Tapez cette ligne dans votre texte source.\\
Attention, \verb|emacs| n'interpr\`ete cette ligne que lorsqu'il
ouvre le fichier source. Quittez \verb|emacs| puis relancez \verb|emacs|
en tapant:\\
\verb|emacs bonjour.cc &|

Vous pouvez maintenant lancer la compilation en choisissant \verb|Compile|
du menu \verb|Tools| ou en tapant sur la touche 
\verb|F9| puis validez en
tapant la touche \verb|Entree|. La fen\^etre \verb|emacs| se divise
alors en deux. La partie inf\'erieure indique au fur et \`a mesure 
l'\'evolution de la compilation et les erreurs rencontr\'ees. S'il n'y
a pas d'erreur, vous verrez un message ressemblant \`a:\\
\verb|Compilation finished at ...|\\

S'il y a des erreurs, cliquez avec le bouton du milieu sur la ligne de
l'erreur dans la fen\^etre de compilation, cela placera le curseur
au bon endroit dans la fen\^etre contenant le texte source. Modifiez
alors le texte source et recommencez pour chaque erreur rencontr\'ee.
Recompilez jusqu'\`a ce que tout se passe bien.

Remarques:
\begin{itemize}
\item  si votre fen\^etre \verb|emacs| est d\'ej\`a coup\'ee en
deux morceaux, veillez \`a taper sur \verb|F9| apr\`es avoir
s\'electionn\'e la demi-fen\^etre contenant le texte source. 
\item si vous avez modifi\'e le nom du texte source avec la
commande \\ \verb|Save Buffer As| du menu \verb|Files|, 
vous devez aussi modifier la premi\`ere ligne
du texte source pour refl\'eter ce changement, puis fermer et r\'eouvrir le
fichier pour rendre le changement effectif.\footnote{Vous pouvez \'egalement
changer la commande de compilation qui s'inscrit en bas de la fen\^etre
apr\`es avoir appuy\'e sur F9 et avant d'appuyer sur la touche Entr\'ee}
\item Si vous lancez la compilation depuis la ligne de commande,
dans \verb|emacs|, l'appui sur les touches \verb|Ctrl| et \verb|G| 
suivi d'un nombre permet de se d\'eplacer aux num\'eros de lignes 
d'erreur indiqu\'es par le compilateur.
\end{itemize}

\subsection{Ex\'ecuter votre programme.} \label{sec:exe}
Si la compilation s'est termin\'ee avec succ\`es, vous pouvez tester
le r\'esultat en tapant dans la fen\^etre \verb|xterm|:\\
\verb|./a.out|\\

Si votre programme donne des r\'esultats inattendus, vous devrez 
corriger le texte source et compiler \`a nouveau. Si tout va bien et
que vous souhaitez conserver votre ex\'ecutable, vous pouvez le renommer, 
par exemple, tapez dans la fen\^etre \verb|xterm| la commande:\\
\verb|mv a.out bonjour|

Remarque: pour diminuer la taille du fichier ex\'ecutable (pour
\'economiser l'espace occup\'e sur le disque dur), vous pouvez utiliser
la commande:\\
\verb|strip bonjour|


\subsection{Autres logiciels utiles} \label{sec:autres_outils}
\begin{itemize}
\item Pour corriger les erreurs un peu r\'ecalcitrantes, on utilise un
{\em debuggueur\/} (logiciel de mise au point), ici \verb|gdb|,
ce logiciel sera pr\'esent\'e ult\'erieurement.
\item Certaines erreurs d'allocation m\'emoire (souvent les plus difficiles
\`a d\'etecter car pouvant provoquer des erreurs de segmentation
bien apr\`es ) n\'ecessitent une
ex\'ecution sous contr\^ole d'outils d\'edi\'es, comme par exemple
\verb|valgrind|.
\item 
Enfin, pour am\'eliorer l'efficacit\'e d'un programme, on pourra utiliser un 
{\em profiler\/}, par exemple \verb|gprof|.
\end{itemize}

\subsection{Ce qu'il faut absolument retenir:} \label{sec:resume}
\begin{itemize}
\item les commandes Unix de base %(section \ref{sec:exos}) 
\verb|ls cp rm mv cd|,
\item les commandes d'\'edition les plus courantes d'\verb|emacs| (section
\ref{sec:edition})
\item l'enchainement pour cr\'eer un programme: \'edition du source,
compilation, ex\'ecution du programme compil\'e (section \ref{sec:log_prog}).
\end{itemize}

\section{En compl\'ement} \label{sec:doc}
Pour installer un compilateur C++ libre sur votre ordinateur:
\begin{itemize}
\item PC Windows: installez cygwin 
\verb|http://www.cygwin.com/|, 
\item PC Linux: installez les packages ou \'equivalents
\verb|gcc linux-libc-dev glibc-doc|, \verb|g++ libstdc++-dev|, 
\verb|emacs|, \verb|gdb|
\item Mac: installer Xcode, en principe fourni avec le syst\`eme Mac OS X.
\end{itemize}
Il existe aussi des compilateurs C++ commerciaux, l'environnement
de d\'eveloppement sera alors diff\'erent mais bien entendu le langage
est identique.

Pour de la documentation en ligne sur C++, un bon point de d\'epart est:\\
\verb|http://www.cplusplus.com/|.
Vous pouvez
aussi consulter des livres en biblioth\`eque, par exemple 
{\em Le langage C++\/} de Bjarne Stroustrup (le concepteur du langage).

Pour la documentation de la librairie C standard \verb|libc|, vous pouvez
utiliser l'aide d'\verb|emacs| (tapez la touche \verb|F1| dans la fen\^etre
\verb|emacs|), cherchez et cliquez sur \verb|libc|. Pour la documentation
de la librairie standard C++ (STL), cf.~:\\
\verb|http://www.sgi.com/tech/stl/|


\pagebreak

\section{Premiers pas en C++.} \label{sec:bases}

\subsection{Les donn\'ees.} \label{sec:data}
Tout logiciel manipule des donn\'ees, celles-ci peuvent \^etre de deux
types:
\begin{itemize}
\item les constantes, par exemple $\pi =3.1415...$
\item les variables, par exemple le solde d'un compte en banque.
\end{itemize}
On a vu que pour l'ordinateur ces donn\'ees \'etaient une suite de 
nombres plac\'ees  \`a des positions num\'erot\'ees dans la m\'emoire
appel\'ees {\em adresses}.
Il est peu commode de d\'esigner des donn\'ees par leur num\'ero de 
position en m\'emoire, les langages de programmation utilisent 
\`a la place un nom de {\em variable\/} ou de {\em constante\/}, 
c'est le compilateur 
qui se charge de traduire ce nom en une adresse. Par exemple
on pourrait donner \verb|demi| comme nom \`a la constante math\'ematique 
$0.5 $. Cette valeur ne changera pas, il s'agit d'une constante.
On peut choisir le nom \verb|solde| pour la valeur d'un compte en banque,
cette valeur change, il s'agit d'une variable.
D'autre part, un programme d'ordinateur manipule des donn\'ees non
num\'eriques, par exemple des chaines de caract\`eres en utilisant
un format de num\'erisation des donn\'ees. Ce format de
donn\'ee est dans le langage C++ le {\em type\/} de la variable 
ou de la constante consid\'er\'ee.
Il existe des standards de num\'erisation pour les donn\'ees manipul\'ees
couramment qui correspondent aux types pr\'ed\'efinis du langage,
par exemple~:
\begin{itemize}
\item \verb|int| pour un entier sign\'e (32 bits)
\item \verb|double| pour un nombre r\'eel (en double pr\'ecision)
\item \verb|char| pour un caract\`ere,
\item \verb|string| pour une chaine de caract\`ere,
\item \verb|vector<int>| pour une liste d'entiers,
\item \verb|vector<double>| pour une liste de r\'eels,
\item etc.
\end{itemize}
Lorsqu'on veut utiliser une donn\'ee dans un programme, on {\em d\'eclare}\/
une variable ou une constante d'un certain type, en indiquant le
type de la variable suivi par son nom, par exemple~:\\
\verb|const double hbar=6.626e-34;|\\
\verb|char c ;|\\
...\\
Pour distinguer les variables des constantes, on rajoute le mot-clef 
\verb|const| (ici on d\'eclare \verb|hbar| comme une constante).
On peut aussi {\em initialiser\/} une variable lors de sa d\'eclaration
ce qui indique sa valeur lors de sa cr\'eation. C'est indispensable
pour une constante.

On peut ensuite utiliser ce nom de variable ou de constante dans la suite
du texte source,
par exemple, si \verb|R| est une variable r\'eelle repr\'esentant
le rayon d'un cercle et si on veut d\'e\-ter\-mi\-ner la valeur de
la variable r\'eelle \verb|perimetre| repr\'esentant son p\'erim\`etre,
on pourra \'ecrire~:\\
\verb|perimetre=2*M_PI*R ;|\\
ce qui calcule le membre de gauche $2\pi R$ et place le r\'esultat
dans la variable \verb|perimetre|.


\subsection{Exercice} \label{sec:exo_premier_pas}
Voici un extrait de programme
\begin{verbatim}
int i,j=0;
k=i+j;
double l=1.7;
int m=2.3;
double n=2;
ch='A';
char ch;
const double alpha=1.3;
alpha=2.7;
\end{verbatim}
Quel est le type des variables \verb|i,j,k,l,m,n,ch|?
A-t-on d\'eclar\'e toutes les variables?
Quelles sont les variables initialis\'ees? Les initialisations vous
paraissent-elles correctes?

\subsection{Les instructions.} \label{sec:instructions}
Un programme est une suite d'instructions que l'ordinateur ex\'ecute
l'une apr\`es l'autre. 
Une instruction en C++ se termine par le signe \verb|;|\\
Un groupement d'instructions commence par le signe \verb|{| et
se termine par le signe \verb|}|

On peut intervenir sur l'ordre
d'ex\'ecution des instructions en utilisant des commandes de
contr\^ole de l'ex\'ecution:
\begin{itemize}
\item pour ex\'ecuter plusieurs fois le m\^eme groupe d'instructions 
en ex\'ecutant une {\em boucle\/} tant qu'une condition est v\'erifi\'ee
qui se traduit en C++ par un \verb|for (;;) { }|,
par exemple pour calculer la somme des entiers de 1 \`a 10~:\\
\verb|int i=1,somme=0;|\\
\verb|for (;i<=10;i=i+1){|\\
\verb|  somme=somme+i;|\\
\verb|}|\\
l'instruction ajouter \verb|i| \`a la variable \verb|somme| est ex\'ecut\'ee
tant que \verb|i| est inf\'erieur ou \'egal \`a 10 et \`a chaque ex\'ecution
de la boucle \verb|i| est augment\'e de 1.
\item pour n'ex\'ecuter une instruction que 
lorsqu'une condition est v\'erifi\'ee avec un test \verb|if () { } else { }|,
par exemple pour le calcul du p\'erim\`etre de la section pr\'ec\'edente,
on va tester que le rayon du cercle est positif et afficher un message
d'erreur si ce n'est pas le cas:\\
\verb|if (R<0){|\\
\verb|  cout << "Erreur: le rayon du cercle est negatif!" << endl;|\\
\verb|}|\\
\verb|else {|\\
\verb|  perimetre=2*M_PI*R;|\\
\verb|}|
\end{itemize} 

Lorsqu'on souhaite regrouper plusieurs instructions qui permettent de
d\'eterminer une donn\'ee en fonction d'autres donn\'ees, on utilise un autre
type de regroupement appel\'e \verb|fonction|. Par exemple, on peut
calculer le nombre de caract\`eres d'une chaine de caract\`eres.
Comme en math\'ematique, on parle d'argument(s) et de r\'esultat
ou valeur de retour
de la fonction, dans l'exemple, l'argument est la chaine de caract\`ere
et la valeur de retour est le nombre de caract\`eres. On donne alors un nom
de fonction (par exemple \verb|taille|) pour pouvoir utiliser 
cette fonction plus tard dans le texte source. 
On pr\'ecise le type des arguments et de la valeur de retour, dans 
l'exemple~:\\
\verb|int taille(string s){ ... }|\\

Autre exemple~:\\
\verb|double surface_du_cercle(double rayon){|\\
\verb|  double pi=3.14159;|\\
\verb|  return pi*rayon*rayon;|\\
\verb|}|\\
Ensuite on peut utiliser la fonction~:
\verb|double R=1.3;|\\
\verb|double S=surface_du_cercle(R);|

{\bf Exercice~:}\\
\'Ecrire une boucle qui calcule le produit des entiers pairs de 2 \`a 10.\\
\'Ecrire un test pour d\'eterminer le plus grand de deux entiers.
\'Ecrire un test pour v\'erifier qu'un caract\`ere peut repr\'esenter
une base du code ADN (pour tester une \'egalit\'e on utilise \verb|==|).\\
\'Ecrire une fonction qui calcule le volume du sph\`ere en fonction de son 
rayon. \'Ecrire une fonction qui renvoie le caract\`ere compl\'ementaire
d'une base d'ADN (appari\'es par A-T ou C-G).

\subsection{TP: Un programme plus complet.}


\subsubsection{Le programme} \label{sec:exo}
Avant tout nous allons cr\'eer un r\'epertoire de travail 
nomm\'e ``Programmes'';
il suffit pour ce faire d'utiliser la commande {\tt mkdir} 
(make directory) en tapant  {\tt mkdir Programmes}.
 
Dans une fen\^etre {\tt xterm} placez vous dans le r\'epertoire souhait\'e--- 
{\tt cd  Programmes}--- et   tapez la commande \\
{\tt emacs essai.cc \&}.

L'\'editeur de texte {\tt emacs} s'ouvre alors dans une fen\^etre et vous pouvez
commencer \`a taper votre texte {\bf en dessous} des lignes d\'ej\`a pr\'esentes. 

Recopiez le texte suivant en utilisant la touche de tabulation apr\`es 
chaque passage \`a la ligne (de fa\c{c}on \`a obtenir une indentation 
automatique).

\begin{verbatim}
// Fonction qui calcule le carre d'un entier
int carre(int n){
  return n*n;
}

int main(){
  int i;
  for (i=0; i<10; i=i+1){
    cout << carre(i) << endl;
  }
  return(0);
}
\end{verbatim}

Sauvegardez votre texte, tapez sur la touche {\tt F9} puis sur {\tt Entr\'ee}
pour lancer la compilation de votre programme. La fen\^etre se scinde en 
deux parties; l'une contient votre programme, l'autre vous montre l'\'evolution
 de la compilation et les erreurs \'eventuelles. En cas de succ\`es la 
compilation se termine par le message suivant \\
{\tt Compilation finished at ... }.\\
Vous avez obtenu un fichier ex\'ecutable, nomm\'e {\tt a.out}, dans votre 
r\'epertoire de travail. Revenez dans la fen\^etre initiale {\tt xterm} et 
lancez la commande  \\
{\tt a.out} .\\
Vous devriez voir appara\^itre la liste des carr\'es des entiers
de 0 \`a 9.


\subsubsection{Explications.} \label{sec:explication}
Rappelons que pour l'ordinateur, le programme est une suite d'instructions
qui manipulent des donn\'ees (par exemple des nombres, ou des 
caract\`eres) dont la valeur est stock\'ee en m\'emoire. Du point
de vue du programmeur, une donn\'ee stock\'ee en m\'emoire
est une variable ou une constante poss\`edant un type qui d\'ecrit 
le type de donn\'ees.

Notre programme ci-dessus utilise deux variables \verb|i| et \verb|n|
qui sont des nombres entiers, type appel\'e \verb|int| en langage C. 
Pour utiliser une variable dans un programme C, il faut la d\'eclarer, 
c'est-\`a-dire donner son type et le nom qu'on utilisera ult\'erieurement 
pour s'y r\'ef\'erer (ce nom s'appelle l'identificateur). Observez
les d\'eclarations des variables \verb|i| et \verb|n|: elle se fait
en commen\c{c}ant par le type \verb|int| puis l'identificateur
(le nom de la variable) puis le signe \verb|,|, le signe \verb|;|
ou le signe \verb|)|. 

Remarquez que les lignes \verb|int carre(int n){| et 
\verb|int main(){| ne sont pas des d\'eclarations de variables \verb|carre|
et \verb|main|, il y a bien le type \verb|int| et l'identificateur, 
mais il n'est pas suivi de \verb|;|, \verb|,| ou \verb|)|, 
il est suivi de \verb|(|. Il s'agit en fait d'une
d\'eclaration de {\em fonction}\/. Une fonction sert \`a regrouper
diff\'erentes instructions simples permettant d'effectuer une op\'eration
plus \'elabor\'ee. Ces instructions sont regroup\'ees \`a l'int\'erieur
d'un {\em bloc}\/ d\'elimit\'e par les signes $\{$ et $\}$.
Comme en math\'ematiques, une fonction C renvoie
un r\'esultat calcul\'e \`a partir d'une ou plusieurs variables, ce
sont les {\em arguments}\/ de la fonction. Le type
du r\'esultat est le type qui pr\'ec\`ede le nom de la fonction.

Notre programme contient deux fonctions: la fonction
\verb|carre| et la fonction \verb|main|, toutes les deux renvoient
un nombre entier (type \verb|int|). La fonction \verb|carre| sert
(comme son nom l'indique) \`a calculer le carr\'e d'un nombre entier
(c'est ce qu'explique la ligne\\
\verb|// Fonction qui calcule le carre d'un entier|\\
toute ligne qui commence par \verb|//| est un commentaire, c'est-\`a-dire
que le texte qui suit est l\`a pour rendre le texte source plus
facile \`a lire par un programmeur mais est ignor\`e par le
compilateur). 
La fonction \verb|carre| poss\`ede un argument de type \verb|int|, 
qui est l'entier dont il faut calculer le carr\'e. 
La d\'eclaration des arguments se fait entre
les parenth\`eses qui suivent l'identificateur de la fonction: on
indique d'abord le type puis le nom de la variable, s'il y a plusieurs
arguments, on les s\'epare par des virgules. Le nom
de variable donn\'e par cette d\'eclaration d'arguments pourra \^etre utilis\'e
\`a l'int\'erieur de la fonction et seulement \`a l'int\'erieur de la
fonction. Dans l'exemple de \verb|carre|, la variable \verb|n| n'a de sens 
qu'\`a l'int\'erieur du bloc d\'efinissant
\verb|carre| d\'elimit\'e par le signe $\{$ qui suit \verb|int carre(int n)|
et le signe $\}$ correspondant.

Une fonction doit renvoyer un r\'esultat, pour cela on utilise
l'instruction \verb|return| suivi du r\'esultat \`a renvoyer. Pour
la fonction \verb|carre| il s'agit de \verb|n*n|.

Pour utiliser une fonction dans une autre partie du programme, on
\'ecrit dans le texte source le nom de la fonction suivi entre parenth\`eses
par les noms de variables que l'on souhaite passer en argument (s'il y
a plusieurs arguments on les s\'epare par des virgules), par exemple ici
\verb|carre(i)| dans la fonction \verb|main| sert \`a calculer
le carr\'e de l'entier \verb|i|. Lors de l'ex\'ecution de
\verb|carre(i)| la valeur de \verb|i| est recopi\'ee
dans la variable \verb|n| de la fonction \verb|carre|, la fonction
\verb|carre| s'ex\'ecute et le r\'esultat est renvoy\'e pour
\^etre utilis\'e par \verb|cout << |.

Nous avons fait \`a peu pr\`es le tour de cet exemple, il ne reste
qu'\`a expliquer \verb|for (i=0;i<10;i=i+1)|. Il s'agit d'un
exemple de {\em boucle}\/, c'est-\`a-dire que la variable \verb|i|
est d'abord initialis\'ee \`a 0, le bloc d\'elimit\'e par $\{$ et $\}$
est ex\'ecut\'e avec \verb|i=0|, puis la valeur de \verb|i| est augment\'ee
de 1 (\verb|i=i+1|) et compar\'ee \`a 10 (\verb|i<10|), comme 1 est
inf\'erieur \`a 10, la boucle s'ex\'ecute \`a nouveau avec \verb|i=1|,
\verb|i| est \`a nouveau incr\'ement\'e de 1, etc. jusqu'\`a ce que
\verb|i| vaille 10, la condition \verb|i<10| n'est alors plus v\'erifi\'ee
et l'ex\'ecution de la boucle s'arr\^ete, le programme continue apr\`es
le bloc d\'efinissant le \verb|for|.

Remarques:
\begin{itemize}
\item 
La fonction \verb|main| est une fonction un peu sp\'eciale: c'est la
fonction qui est ex\'ecut\'ee lorsqu'on lance le programme en tapant
\verb|a.out| dans la fen\^etre \verb|xterm|. Par convention, elle renvoie un
r\'esultat de type \verb|int|, on renvoie 0 pour indiquer que
le programme s'est d\'eroul\'e normalement. Pour simplifier on supposera 
toujours que \verb|main| n'a pas d'arguments.
\item 
Une instruction C peut faire appel soit \`a des fonctions d\'efinies
plus haut dans le m\^eme programme, soit \`a des instructions
de base, par exemple les op\'erations sur les nombres entiers \verb|+|,
\verb|-|, \verb|*|, etc. 
\item 
La fonction \verb|cout << | permet d'afficher \`a l'\'ecran la valeur
de la variable qui suit \verb|<<|. 
Par exemple \verb|cout << carre(i)| affiche la valeur
du r\'esultat de \verb|carre(i)|. \verb|endl| permet d'afficher un saut
de ligne. \verb|cout| n'est pas 
une instruction de base, elle fait partie d'une biblioth\`eque de
fonctions appel\'ee \verb|iostream| (i pour input, entr\'ee en anglais,
o pour output, sortie en anglais, et stream signifie flux, cette
biblioth\`eque contient des fonctions pour lire des donn\'ees
au clavier et afficher des donn\'ees \`a l'\'ecran). Il faut indiquer 
au compilateur qu'on va utiliser cette 
biblioth\`eque de fonctions et c'est le r\^ole de la ligne:\\
\verb|#include <iostream>|\\
Il existe de nombreuses biblioth\`eques de fonctions pour diff\'erents
domaines d'application, par exemple \verb|string| pour manipuler
des chaines de caract\`eres, \verb|vector| pour manipuler des
vecteurs, pour les utiliser on place une ligne
analogue dans le texte source du programme.
\end{itemize}


\subsection{Exercices} \label{sec:exo_1}
\begin{itemize}
\item Modifiez le nom de l'argument de la fonction \verb|carre| (utilisez
par exemple \verb|m|)
\item Cr\'eez une fonction \verb|cube| qui calcule le cube d'un entier
et modifiez le programme pour qu'il calcule le cube des entiers de 0 \`a 9.
\item Modifiez le programme pour qu'il calcule les cubes des entiers
de 0 \`a 100. N'oubliez pas de rajouter un commentaire!
\item Rajoutez \verb|//| \`a la ligne \verb|#include <iostream>|
et observez le r\'esultat de la compilation.
\end{itemize}

\section{Correction des erreurs d\'etect\'ees \`a la compilation.} 
\label{sec:erreurs}
La premi\`ere condition pour pouvoir compiler correctement, c'est
d'appeler le compilateur!
La premi\`ere ligne de votre fichier doit ressembler \`a:\\
\verb|// -*- mode:C++; compile-command:"g++ essai.cc"|\\
Cette ligne permet \`a \verb|emacs| de savoir quoi faire lorsque vous
lancez la commande de compilation (en tapant sur la touche F9 ou
en choisissant \verb|Compile| du menu \verb|Tools|). 
En particulier, notez que le fichier
qui sera compil\'e est le nom de fichier source qui apparait sur 
cette ligne, il faut
donc toujours s'assurer que ce nom est bien le nom du fichier que vous
\'editez (ce nom apparait en inverse vid\'eo sur l'avant derni\`ere ligne
de la fen\^etre \verb|emacs|).
Mais il arrivera certainement un jour ou l'autre que ces deux noms diff\`erent
(vous devrez alors modifiez la premi\`ere ligne) ou qu'il n'y ait tout
simplement pas de premi\`ere ligne. Nous commencerons par d\'ecrire
avec un exemple ce qu'il faut faire dans ce cas. Une fois que
l'on a appel\'e correctement le compilateur, il faut aussi que le texte
source soit syntaxiquement correct pour que la compilation aboutisse.
Si ce n'est pas le cas, il faut interpr\'eter les messages d'erreur
de la compilation, corriger le texte source et essayer de compiler \`a
nouveau. Nous allons \'egalement voir comment faire.

Sans quitter Emacs, vous allez
maintenant \'editer votre second programme que nous appellerons 
\verb|faux.cc|~:
\`a l'aide de la souris s\'electionnez ``Open file...'' du menu ``File''.
Vous devez alors voir apparaitre \`a la derni\`ere ligne de la fen\^etre
emacs \verb|Find file:~/|,
tapez alors \verb|faux.cc|, le nom du fichier \`a ouvrir, dans cette ligne 
de commande. Notez que, puisque vous n'avez pas utilis\'e 
la commande \verb|editcc|, votre nouveau fichier est vide. 
Tapez alors le texte suivant:


%%
%% Creator: c++2latex -o faux.tex faux.cc
%% Date:    Sun May  9 20:50:04 1999
%%
\expandafter\ifx\csname indentation\endcsname\relax%
\newlength{\indentation}\fi
\setlength{\indentation}{0.5em}
\begin{flushleft}
{\bf int\/} carre ({\bf int\/} n)\{\mbox{}\\
\hspace*{2\indentation}{\bf return\/} n$\ast$n;\mbox{}\\
\}\mbox{}\\
\mbox{}\\
{\bf int\/} main()\{\mbox{}\\
\hspace*{2\indentation}{\bf for\/}({\bf int\/} p=0; p$<$10; p++)\{\mbox{}\\
\hspace*{4\indentation}cout $\ll$ carre(i)$\ll$endl\mbox{}\\
\hspace*{6\indentation}{\bf int\/} k;\mbox{}\\
\hspace*{4\indentation}5=k;\mbox{}\\
\hspace*{4\indentation}cout $\ll$ k;\mbox{}\\
\hspace*{2\indentation}\}\mbox{}\\
\}\mbox{}\\
\end{flushleft}



Lancez la compilation en tapant {\tt F9}. Le message suivant s'affiche~:\\
{\tt compile command : make -k}\\
Remplacez {\tt make -k } par~:\\
{\tt g++ faux.cc -lm }\\
pour lancer la compilation. Vous obtenez les messages~:\\
{\tt  faux.cc: In function `int main(...)':\\
faux.cc:8: `cout' undeclared (first use this function)\\
faux.cc:8: (Each undeclared identifier is reported only once\\
faux.cc:8: for each function it appears in.)\\
faux.cc:8: `i' undeclared (first use this function)\\
faux.cc:9: `endl' undeclared (first use this function)\\
faux.cc:10: parse error before `int'\\
faux.cc:10: non-lvalue in assignment\\
faux.cc:11: confused by earlier errors, bailing out\\
Compilation exited abnormally with code 1 at ....}

Si vous placez votre souris sur la ligne {\tt faux.cc:8} et que vous 
cliquez avec le bouton du milieu, le curseur se placera automatiquement 
sur la ligne correspondante du texte source ({\it i.e.} dans le fichier 
{\tt faux.cc}).    
La variable {\tt i} n'est pas {\bf d\'eclar\'ee}, nous nous sommes tromp\'es
de nom de variable, nous aurions du \'ecrire~:\\
{\tt carre(p);}\\
La fonction {\tt cout}\index{cout} n'est pas d\'efinie non plus,
sa d\'efinition est faite dans 
le fichier {\tt iostream}: nous devons donc ajouter la directive \\
{\tt $\#$include <iostream>}\\ \index{iostream} 
{\tt using namespace std;}\\
en d\'ebut de fichier (notez que si nous avions lanc\'e l'\'edition
de \verb|faux.cc| en tapant la commande {\tt editcc faux.cc}, cette
ligne serait automatiquement \'ecrite en d\'ebut de fichier).
L'erreur suivante provient de l'absence du point virgule apr\`es 
l'instruction {\tt cout $<<$ carre(i)} 
(remarquez \`a ce propos la mauvaise indentation de la ligne suivante).
Rajoutez le \verb|;| d\'eplacez vous sur la ligne suivante et tapez
sur la touche de tabulation \`a la gauche de la lettre \verb|A|, le
texte devrait \`a nouveau s'indenter correctement.
La derni\`ere erreur vient de ce que le signe ``='' est le signe 
d'affectation (il sert \`a copier la valeur du membre de droite vers
le membre de gauche donc ici il donne une valeur \`a une variable)
et non le signe utilis\'e pour tester une \'egalit\'e. 
On ne peut affecter la valeur de \verb|k| \`a 
une constante (5 ici): on dit que 5 n'est pas une valeur \`a gauche 
(left value).
  
Une fois les erreurs corrig\'ees la compilation se d\'eroule normalement.  
Notez alors qu'il y a toujours 
{\bf un seul}  fichier {\tt a.out} dans votre 
r\'epertoire de travail. Si vous voulez conserver des 
ex\'ecutables (ce n'est pas toujours une tr\`es bonne id\'ee car un ex\'ecutable
occupe beaucoup plus d'espace disponible qu'un fichier source sur 
le disque dur~: comparez la taille de \verb|a.out| et de \verb|faux.cc|
(utilisez pour ce faire la commande {\tt ls -l a.out}) ), 
il est n\'ecessaire de les renommer \`a l'aide de la commande 
{\tt mv} ---move--- 
({ \tt mv a.out carre} par exemple) avant de compiler un autre 
programme dans le m\^eme r\'epertoire.


\subsection{En r\'esum\'e} \label{sec:retenir}
Bien comprendre les termes suivants: variable, constante, type, d\'eclaration,
initialisation, boucle, test, fonction, argument, valeur de retour d'une 
fonction.

\pagebreak

\section{Composition d'un programme.}
Un texte source \'ecrit en C ou C++ se compose de:
\begin{itemize}
\item {\bf Directives du pr\'eprocesseur}\index{pr\'eprocesseur}:\\
Ce sont des directives pr\'ec\'ed\'ees du caract\`ere di\`ese $\#$ qui sont 
trait\'ees avant la compilation proprement dite. Le pr\'eprocesseur modifie 
le texte source qui sera envoy\'e au compilateur par exemple
en y incluant le contenu de fichiers n\'ecessaires pour utiliser
des fonctionnalit\'es d\'efinies dans des biblioth\`eques, ainsi~:\\
\verb|#include <iostream>|\\
est une directive du pr\'eprocesseur permettant d'utiliser la biblioth\`eque
pour lire des donn\'ees au clavier et \'ecrire des donn\'ees \`a l'\'ecran. 
Il existe d'autres type de directives, par exemple
pour compiler certaines parties du texte source uniquement 
dans certains cas, par exemple selon que 
le syst\`eme d'exploitation est GNU/Linux ou Windows.

\item {\bf D\'eclarations.}  Tout objet
(variable, fonction, ...) doit \^etre d\'eclar\'e avant d'\^etre utilis\'e.
Toute d\'eclaration se termine par un point-virgule.\index{d\'eclaration} 

La d\'eclaration des variables se fait en indiquant le type de la variable
puis le nom de la variable.

En C++, la d\'eclaration de variables peut \^etre faite n'importe o\`u
dans le texte source (mais, bien entendu, avant utilisation). Cela permet de
les d\'efinir aussi pr\`es que possible de l'endroit o\`u elles sont
utilis\'ees, ce qui permet plus facilement de relire, corriger ou 
modifier le code source.

\item {\bf Fonctions.} 
Lorsqu'on doit ex\'ecuter \`a diff\'erents endroits d'un programme
la m\^eme suite d'instructions, on regroupe ces instructions en une
{\bf fonction}. Une fonction agit sur des donn\'ees, qui sont appel\'ees
arguments de la fonction. Une fonction renvoie la plupart du temps un
r\'esultat. Par exemple la fonction maximum qui calcule le plus grand
entier parmi deux entiers $a$ et $b$ a deux arguments entiers $a$ et $b$
et renvoie un entier.

La d\'eclaration de la fonction est compos\'ee du type de la valeur
renvoy\'ee, du nom de la fonction, suivi entre parenth\`eses
du type et du nom des arguments de la fonction s\'epar\'es par des
virgules.
Le corps d'une fonction (la partie d\'elimit\'ee par
le $\{$ qui suit la liste des arguments et le $\}$ fermant correspondant)  
est constitu\'e d'instructions. Chaque instruction doit se terminer par un 
point-virgule.

Le programme doit contenir une fonction dont le 
nom est {\tt main}\index{main}, c'est cette fonction qui est ex\'ecut\'ee
lorsqu'on tape \verb|a.out| dans la fen\^etre \verb|xterm|.

Certaines fonctions sont rattach\'ees \`a un type d'objet, 
par exemple la longueur pour une 
chaine de caract\`eres ou le nombre d'\'el\'ements d'un vecteur, on peut
alors les voir comme une caract\'eristique de l'objet, on parle alors de 
{\bf m\'ethode}.

\item {\bf Commentaires.}\index{commentaires} Il est souvent 
n\'ecessaire d'inclure des commentaires pour expliquer \`a un lecteur 
\'eventuel (ou \`a l'auteur...) le fonctionnement du programme. 
Un commentaire sur plusieurs lignes
commence par le signe \verb|/*| et termine par \verb|*/|. 
On peut aussi commenter {\bf une} ligne en la faisant d\'ebuter par \verb|//|. 
\end{itemize} 
 
\noindent{\bf exemple:}
\begin{verbatim}
#include <iostream> // directive du preprocesseur
using namespace std;

// declaration et definition de la fonction max
int max(int a,int b){
  if (a>b)
    retun a;
  else
    return b;
}

// declaration et definition de la fonction main
int main(){
  int n,m; // declaration des variables n et m
  cout << "Donnez deux entiers: " ;
  cin >> n >> m ;
  cout << "Le plus grand des deux est: " << max(n,m) << endl;
}
\end{verbatim}

\section{Quelques types de variables.} 
 
\subsection{Les types simples}
Toutes les variables  ont un {\bf type} qui doit \^etre d\'eclar\'e sous la
\index{type} forme suivante: \\
{ \tt   type  nom-de-variable ;}   \\
On peut grouper la d\'eclaration de plusieurs variables de m\^eme type,
par exemple:\\
\verb|type 1er-nom-de-variable, 2eme-nom-de-variable;|

\vskip.2truein

Les principaux types sont:
\begin{enumerate}
\item 
[\bf char]\index{char}  caract\`ere, \\
Lorsqu'on veut utiliser un carat\`ere fix\'e, on l'\'ecrit entre apostrophes. 
Par exemple
si \verb|c| est une variable de type \verb|char|, on peut \'ecrire\\
{\tt c='A';}\\
pour donner \`a la variable \verb|c| la valeur \verb|'A'|.
Attention \`a ne pas confondre le nom de la variable (ici \verb|c|) et
sa valeur (qui est \verb|'A'|, ce pourrait \^etre le caract\`ere \verb|'c'|).
En r\'ealit\'e l'ordinateur stocke un entier compris entre 0 et 255
appel\'e code ASCII de la lettre. Par exemple le code ASCII de \verb|A|
est 65, celui de \verb|B| est 66, etc.
\item 
[\bf int]\index{int}   entier, options: 
{\it short, long, signed, unsigned}  \\
(Noter qu'il n'est pas n\'ecessaire de pr\'eciser {\tt int} 
si on indique {\tt short, long, unsigned}).
\item 
[\bf float]\index{float}  nombres \`a virgule flottante simple pr\'ecision \\
Il s'agit de nombres r\'eels, par exemple $3.1415$, contrairement aux
entiers ci-dessus. Remarquez que le nombre r\'eel $3.1415$ ne peut 
\^etre stock\'e dans une variable de type \verb|int|. Par contre,
un nombre entier comme par exemple $13$ peut \^etre stock\'e sous deux 
formats: \verb|int| bien sur, mais \'egalement \verb|float| (pour \'eviter les
confusions, on le note alors avec un point d\'ecimal \`a la fin \verb|13.|): 
dans ce cas il sera consid\'er\'e 
comme un nombre r\'eel ce qui peut changer le r\'esultat de certaines 
op\'erations (par exemple la division \verb|/| renvoie le quotient euclidien si
les arguments sont entiers et le quotient r\'eel sinon, ainsi \verb|13/2|
vaut \verb|6| alors que \verb|13./2.| vaut \verb|6.5|).
\item 
[\bf double]\index{double}  nombres \`a virgule flottante double pr\'ecision, option: {\it long}\\
Comme \verb|float| mais avec plus de chiffres significatifs.
\item 
[\bf bool]\index{bool}  une variable de ce type peut prendre 
deux valeurs: {\tt false} ou {\tt true}. Une valeur de type entier 
qui est nulle [respectivement non nulle] est consid\'er\'e comme {\tt false}
[respectivement {\tt true}].
\end{enumerate}  

{\bf Exercice:\\}
\'Ecrire un programme qui lit un r\'eel et affiche son carr\'e.

{\bf Remarque:\\}
Comme dit pr\'ec\'edemment un caract\`ere est cod\'e par son code ASCII, 
qui est un entier compris entre 0 et 255,
on peut donc \'ecrire:
%%
%% Creator: c++2latex -o char.tex char.cc
%% Date:    Mon Jul  6 11:25:24 1998
%%
\expandafter\ifx\csname indentation\endcsname\relax
\newlength{\indentation}\fi
\setlength{\indentation}{0.5em}
\begin{flushleft}
{\tt\#include} $<${\tt iostream}$>$\mbox{}\\
{\tt\#using namespace std;} \mbox{}\\
\mbox{}\\
{\bf int\/} main()\{\mbox{}\\
\hspace*{2\indentation}{\bf int\/} i=65;\mbox{}\\
\hspace*{2\indentation}{\bf char\/} ch=i;    \hfill{\em //\hspace*{1\indentation}65\hspace*{1\indentation}est\hspace*{1\indentation}le\hspace*{1\indentation}code\hspace*{1\indentation}ASCII\hspace*{1\indentation}du\hspace*{1\indentation}caract\`ere\hspace*{1\indentation}A}\mbox{}\\
\hspace*{2\indentation}cout $\ll$ ch $\ll$ {\tt "$=$ "} $\ll$ i $\ll$ endl;\mbox{}\\
\hspace*{2\indentation}ch= 'B';\mbox{}\\
\hspace*{2\indentation}i=ch;\mbox{}\\
\hspace*{2\indentation}cout $\ll$ ch $\ll$ {\tt "$=$ "} $\ll$ i $\ll$ endl;\mbox{}\\
\}\mbox{}\\
\end{flushleft}


\subsection{Conversion de type.}\index{conversion de type} 
Il est parfois n\'ecessaire de changer le type d'une variable 
on parle alors de ``casting''. Par exemple si $p$ et $q$ sont deux entiers, 
\verb|p/q| donne le quotient entier de $p$ par $q$. Si l'on veut 
au contraire une valeur d\'ecimale approch\'ee de $p/q$, on \'ecrira:\\
{\tt ((float) p)/q;} ou {\tt float(p)/q}.

%%
%% Creator: c++2latex -o cast.tex cast.cc
%% Date:    Mon Jul  6 11:21:43 1998
%%
\expandafter\ifx\csname indentation\endcsname\relax
\newlength{\indentation}\fi
\setlength{\indentation}{0.5em}
\begin{flushleft}
{\tt\#include} $<${\tt iostream}$>$\mbox{}\\
{\tt\#using namespace std;} \mbox{}\\
\mbox{}\\
{\bf void\/} main()\{\mbox{}\\
\hspace*{2\indentation}{\bf int\/} p,q;\mbox{}\\
\hspace*{2\indentation}p=1; q=3;\mbox{}\\
\hspace*{2\indentation}cout $\ll$ {\tt "comparez "} $\ll$ p$/$q $\ll$ {\tt " et "} $\ll$ ({\bf double\/}) p$/$q $\ll$ endl;\mbox{}\\
\hspace*{2\indentation}{\bf float\/} x=1.999999;\mbox{}\\
\hspace*{2\indentation}{\bf int\/} i= ({\bf int\/}) x; \hfill{\em //\hspace*{1\indentation}conversion\hspace*{1\indentation}d'un\hspace*{1\indentation}float\hspace*{1\indentation}en\hspace*{1\indentation}entier\hspace*{1\indentation}}\mbox{}\\
\hspace*{2\indentation}cout $\ll$ i $\ll$endl;\mbox{}\\
\hspace*{2\indentation}\mbox{}\\
\}\mbox{}\\
\end{flushleft}


Le r\'esultat est le suivant:\\
{\tt $>$  a.out\\
comparez 0 et 0.333333\\
1\\
}


\subsection{Les vecteurs} \label{sec:vector}
Ce type permet de repr\'esenter des tableaux dont la taille peut
varier. Ce type n'est pas un type de base, il faut donc \'ecrire au
d\'ebut de votre fichier source:\\
\verb|#include <vector>|

Dans la d\'eclaration d'un vecteur, il faut indiquer le type 
d'\'el\'ement du vecteur entre crochets, par exemple pour un vecteur
de nombres r\'eels~:\\
\verb|vector<double> v;|\\
Dans cet exemple on a d\'eclar\'e un vecteur qui est vide pour l'instant.
On peut aussi d\'eclarer un vecteur ayant $n$ \'el\'ements, par
exemple~:\\
\verb|vecteur<int> v(15);|\\
d\'eclare un vecteur contenant 15 entiers.
On peut enfin cr\'eer un vecteur contenant $n$ \'el\'ements ayant tous
la m\^eme valeur, par exemple~:\\
\verb|vecteur<double> v(10,1.2);|\\
cr\'ee un vecteur ayant 10 \'el\'ements, chaque \'el\'ement est initialis\'e
\`a la valeur \verb|1.2|.

La taille d'un vecteur est donn\'e par sa m\'ethode \verb|size()|, par 
exemple~:\\
\verb|int s=v.size();|\\
Les \'el\'ements d'un vecteur sont num\'erot\'es de 0 \`a $s-1$ o\`u $s$
est la taille du vecteur, on acc\`ede au $i$-i\`eme \'el\'ement du vecteur
par \verb|v[i]|.

On peut rajouter un \'el\'ement \`a la fin d'un vecteur en utilisant
la m\'ethode \verb|push_back|, par exemple si \verb|v| est un 
\verb|vector<int>|~:\\
\verb|v.push_back(13);|

On peut enlever le dernier \'el\'ement d'un vecteur en utilisant la m\'ethode 
\verb|pop_back()|.

{\bf Les matrices~:}\\
Pour d\'efinir une matrice, on utilise un vecteur de vecteurs, par exemple\\
\verb|vector< vector<double> >|\\
est le type d'une matrice de r\'eels. On peut
cr\'eer une matrice de taille fix\'ee, par exemple 10 lignes et 5 colonnes
initialis\'e \`a 0, de la mani\`ere suivante~:\\
\verb|vector< vector<double> > M(10,vector<double>(5));|\\
On acc\`ede ensuite \`a l'\'el\'ement ligne $i$, colonne $j$ de la matrice
par \verb|M[i][j]|. Attention, ne pas utiliser \verb|M[i,j]| 
qui d\'esigne la $j$-i\`eme ligne de la matrice et non l'\'el\'ement 
ligne $i$ colonne $j$.

{\bf Tri d'un vecteur~:}\\
On peut trier un vecteur par ordre croissant en utilisant la fonction
\verb|sort|. Mettre en d\'ebut de fichier \verb|#include <algorithm>|
puis taper dans le texte source~:\\
\verb|sort(v.begin(),v.end());|\\
pour trier le vecteur \verb|v|. Pour utiliser un autre crit\`ere de tri,
on d\'efinit une fonction prenant en argument deux variables du type
des \'elements du vecteur et renvoyant le type \verb|bool| et on rajoute
le nom de la fonction comme troisi\`eme argument de la fonction \verb|sort|.
Par exemple pour trier un \verb|vector<int>| par ordre d\'ecroissant~:
\verb|bool tri(int a,int b){ return a>=b; }|\\
\verb|sort(v.begin(),v.end(),tri);|

{\bf Exemple:}
\begin{verbatim}
#include<vector>
#include<iostream>
using namespace std;

int main(){
  vector<int> v(10,7); // vecteur a 10 elements valant tous 7
  v[9]=0; // dernier element mis a 0
  cout << "Entrez la valeur du premier element du vecteur: ";
  cin >> v[0] ;
  cout << "Les coordonnees de v sont: ";
  for (int i=0;i<v.size();i++)
    cout << v[i] << " ";
  cout << endl;
}
\end{verbatim}

{\bf Exercice:\\}
\'Ecrire un programme qui calcule la moyenne d'un vecteur de \verb|double|.
Puis en triant le vecteur, d\'eterminer la m\'ediane.

\'Ecrire un programme qui d\'etermine le maximum et le minimum
d'un vecteur de \verb|int|. Plus difficile: d\'eterminer la position
(l'indice) o\`u le maximum et le minimum sont atteints.



\subsection{Les chaines de caract\`eres} \label{sec:strings}
Il s'agit d'un type repr\'esentant une suite de caract\`ere. Ce type
n'est pas un type de base, il faut donc mettre la ligne~:\\
\verb|#include <string>|\\
au d\'ebut de votre fichier source.

Le type de variable est \verb|string|, par exemple~:\\
\verb|string s|\\
d\'eclare une variable \verb|s| de type chaine de caract\`eres.
On peut initialiser une chaine de caract\`ere:
\begin{itemize}
\item par une chaine \'ecrite dans le texte source d\'elimit\'ee par 
\verb|"|\footnote{Attention, on utilise le d\'elimiteur {\tt "} 
pour les chaines de caract\`eres et {\tt '} pour un caract\`ere}~:\\
\verb|string s("Coucou");|
\item par une autre chaine de caract\`ere (\verb|string t(s);|) ou un morceau
de chaine de caract\`ere (\verb|string t(s,0,3);|) recopie 3
caract\`eres cons\'ecutifs de \verb|s| dans \verb|t| en 
commen\c{c}ant par \verb|s[0]|.
\item par la r\'ep\'etition d'un m\^eme caract\`ere, par exemple~:\\
\verb|string s(15,'A');|\\
cr\'ee la chaine de caract\`eres \verb|"AAAAAAAAAAAAAAA"|.
\end{itemize}
On peut concat\'ener (mettre bout \`a bout) deux chaines en utilisant 
l'op\'erateur \verb|+|, cet op\'erateur \verb|+| permet aussi de rajouter
un caract\`ere \`a une chaine de caract\`eres, par exemple~:\\
\verb|s = s + '.';|\\
rajoute un point \`a \verb|"Coucou"|.

Pour connaitre la longueur d'une chaine de caract\`ere, on utilise sa
{\em m\'ethode}\/ \verb|size()|, par exemple~:\\
\verb|int l=s.size();|

Dans une chaine de caract\`ere, les caract\`eres sont num\'erot\'es
de 0 \`a $l-1$ o\`u $l$ est la longueur de la chaine. Pour acc\'eder
au $i$-\`eme caract\`ere de la chaine \verb|s|, on utilise \verb|s[i]|
ou \verb|s.at(i)|, par exemple~:\\
\verb|char c=s[i];|\\
Pour acc\'eder \`a un morceau de la chaine \verb|s| on indique la
position de d\'epart et le nombre de caract\`eres, par exemple~:\\
\verb|string s("Bonjour");|\\
\verb|string t=s.substr(3,4); // renvoie "jour"|

Remarque~: en C, le type \verb|string| n'existe pas, on utilise alors
le type tableau \verb|char *|, 
la m\'ethode \verb|c_str()| permet de convertir une chaine
de type \verb|string| en un tableau de caract\`eres C, ce qui s'av\`ere
parfois n\'ecessaire (par exemple pour convertir des donn\'ees en chaine
de caract\`eres, cf. la section \ref{sec:flux_chaine}).

{\bf Exercice~:}\\
\'Ecrire une boucle calculant le nombre d'apparitions du caract\`ere \verb|'A'|
dans une chaine de caract\`ere.

\'Ecrire une boucle affichant les caract\`eres d'une chaine par groupe
de 3.

\subsection{Autres types.}
La librairie standard C++ (STL) permet de cr\'eer des structures de donn\'ees
classiques comme les annuaires (\verb|map|), les piles (\verb|stack|), les
tas (\verb|heap|), ... Par exemple pour cr\'eer un r\'epertoire 
de num\'eros de t\'el\'ephone, on ajoute en d\'ebut de fichier~:\\
\verb|#include <map>|\\
\verb|#include <string>|\\
puis on d\'eclare la variable \verb|tel| qui servira de r\'epertoire~:\\
\verb|map<string,string> tel;|\\
Le premier type param\`etre de \verb|map| (\verb|string| ici) 
sert \`a indiquer le nom de la personne, le second type indique le
num\'ero de la personne, on a encore choisi le type \verb|string| car
le type \verb|int| est trop limit\'e pour contenir des num\'eros de
t\'el\'ephone de 10 chiffres.
Pour rajouter un num\'ero~:\\
\verb|tel["Gaston"]="0476000000";|\\
Pour afficher le num\'ero de Gaston~:\\
\verb|cout << tel["Gaston"] << endl;|\\
Pour chercher si Gaston poss\`ede un num\'ero on \'ecrit~:\\
\verb|if (tel.find("Gaston")!=tel.end())|
Pour afficher tous les num\'eros du r\'epertoire~:\\
\verb|map<string,string>::const_iterator it=tel.begin(),itend=tel.end();|\\
\verb|for (;it!=itend;++it)|\\
\verb|  cout << it->first << " : " << it->second << endl;|

\subsection{TP 3} \label{sec:tp3}
 \'Ecrire un programme qui lit trois nombres et retourne le
  maximum.

Cr\'eer un vecteur contenant les carr\'es des entiers de 10 \`a 19,
demandez \`a l'utilisateur d'entrer un entier $i$ (entre 0 et 9), 
affichez le $i$-i\`eme \'el\'ement du vecteur.

\'Ecrire un programme renvoyant l'ARN cod\'e par une chaine d'ADN.
Le code ADN utilise les lettres A, T, C, G et le code ARN correspondant
est obtenu par correspondance de bases A-U, T-A, C-G, G-C.


\subsection{Type d\'efini par l'utilisateur (struct)} \label{sec:structures}
Il est parfois souhaitable de regrouper en un bloc plusieurs
donn\'ees, par exemple on pourrait cr\'eer un type \verb|date| qui
regrouperait 3 entiers d\'esignant respectivement le jour, le mois
et l'ann\'ee. On utilise \`a cet effet le mot-clef \verb|struct| suivi
du nom du nouveau type de donn\'ee cr\'e\'e, puis on d\'efinit le type,
dans notre exemple~:
\begin{verbatim}
struct date {  int jour; int mois; int annee;  };
\end{verbatim}
On peut alors d\'eclarer une variable de type \verb|date|, par exemple~:\\
\verb|date naissance;|\\
\verb|naissance.jour=2; naissance.mois=3; naissance.annee=1980;| \\
cr\'ee la variable \verb|naissance| et lui donne la valeur 2 mars 1980.

Remarques:
\begin{itemize}
\item n'oubliez pas le \verb|;| apr\`es l'accolade fermante \verb|}| lorsque
vous d\'efinissez un type \verb|struct|.
\item \verb|typedef| permet de donner un nom de type synonyme d'un type
existant, par exemple~:\\
\verb|typedef vector<double> vect;|
\item On peut d\'efinir un {\em constructeur} pour faciliter
la cr\'eation de variables d'un type structur\'e, par exemple pour
le type \verb|date|~:\\
\verb|struct date { |\\
\verb|  int jour,mois,annee;|\\
\verb|  date(j,m,a):jour(j),mois(m),annee(a) {};|\\
\verb|};|\\
on peut alors d\'eclarer une variable \verb|d| valant le 2 janvier 2002 par~:\\
\verb|date d(2,1,2002);|
\end{itemize}

{\bf Exercice~:}\\
D\'efinir une structure pour repr\'esenter les coordonn\'ees spatiales
d'un point. Ecrire la distance entre deux points en utilisant cette
structure.


\section{Instructions fondamentales}

\subsection{Op\'erations.} \label{sec:operations}

\centerline{\bf affectation}\index{affectation} 
La syntaxe de l'affectation est {\tt x= e} o\`u {\tt x}
est une variable (d\'eclar\'ee) et {\tt e} est une expression dont le type est
compatible avec celui de {\tt x} (si 
{\tt x} est un r\'eel (float ou double) {\tt e} peut \^etre entier).
L'expression {\tt e} est \'evalu\'ee et sa valeur est affect\'ee \`a {\tt x}.      

\noindent {\bf Attention} {\tt (n=10)} renvoie la valeur affect\'ee (ici 10),
ce qui permet d'\'ecrire~:\\
\verb|m=(n=10)+5|\\
qui stockera 10 dans \verb|n| et 15 dans \verb|m|.

\noindent{\bf exemple:}
%%
%% Creator: c++2latex -o exemple5.tex exemple5.cc
%% Date:    Thu Jun 25 15:32:07 1998
%%
\expandafter\ifx\csname indentation\endcsname\relax
\newlength{\indentation}\fi
\setlength{\indentation}{0.5em}
\begin{flushleft}
{\tt\#include} $<${\tt iostream}$>$\mbox{}\\
{\tt\#using namespace std;} \mbox{}\\
\mbox{}\\
{\bf int\/} main()\{                  \mbox{}\\
\hspace*{1\indentation}{\bf int\/} n;\mbox{}\\
\hspace*{1\indentation}{\bf if\/} (n=0) cout $\ll$ {\tt "n$=$0"} $\ll$endl;  \hfill{\em //\hspace*{1\indentation}pi\`ege: (n=0) renvoie la valeur 0}\mbox{}\\
\hspace*{1\indentation}{\bf else\/} cout $\ll$ {\tt "n$\ne $0"} $\ll$endl; \hfill{\em //\hspace*{1\indentation}il faut \'ecrire n= = 0}\mbox{}\\
\}\mbox{}\\
\end{flushleft}
 

\centerline{\bf Op\'erateurs arithm\'etique} 
Les op\'erateurs arithm\'etiques suivants sont 
d\'efinis pour les types r\'eels ({\tt int, float,
double}) : \verb|+ - * /|

{\bf Remarques:}
\begin{itemize}
\item 
 le r\'esultat d'une division d'entiers est un entier 
(c'est le quotient euclidien, autrement dit la partie enti\`ere du
quotient) par exemple \verb|5/3| donne \verb|1|. 
\item 
Pour les entiers \verb|a % b| 
donne le reste de la division de \verb|a| par \verb|b|.
\item 
Contrairement \`a la notation math\'ematique, on ne peut pas
utiliser \verb|a^b| pour calculer une puissance. Pour les \verb|float|
et les \verb|double|, on utilisera \verb|pow(a,b)| (cf. la section
\ref{sec:numerique}).
\end{itemize}


\centerline{\bf Autres op\'erateurs}
\begin{itemize}
\item[\bf incr\'ementation]: {\tt n++}\index{n++}  
la valeur de {\tt n} est incr\'ement\'ee de 1
(dans le cas d'une boucle {\tt for} l'incr\'ementation se fait  {\bf apr\`es }  
passage dans la boucle).
\item[\bf d\'ecr\'ementation]: {\tt n-- } la valeur de {\tt n} est 
d\'ecr\'ement\'ee de 1
(dans le cas d'une boucle {\tt for} la d\'ecr\'ementation se fait  
{\bf apr\`es } passage dans la boucle)      
\item [\bf ou]:  $||$ 
\item [\bf et]:  $ \& \& $ 
\item [\bf non]: ! 
\item [\bf \'egalit\'e]: $==$ \hskip.1truein ($a==b$ est vrai (1) si $a=b$ et
faux (0) sinon.)
\item[\bf diff\'erent]: !=
\item [\bf inf\'erieur ou \'egal]: $<=$
\item [\bf sup\'erieur ou \'egal]: $>=$
\end{itemize} 

{\bf Attention:\\
Lorsqu'on teste qu'une variable a est \'egale \`a une autre variable b, il
faut \'ecrire a==b et non pas a=b qui recopie la valeur de a dans b
}


 

\subsection{Les tests.} \label{sec:tests}


\centerline{\bf if}\index{if} 
Ex\'ecute une instruction lorsqu'une condition est v\'erifi\'ee.

\noindent{\it Syntaxe:}

{\tt if (expression) $\{$ instruction ou bloc d'instructions $\}$

$[$ else $\{$ instruction ou bloc d'instructions $\}$ $]$.}

\vspace{0.2cm}

\noindent{\bf Exemple}

%%
%% Creator: c++2latex -o bissextile.tex bissextile.cc
%% Date:    Tue Jun 30 12:00:32 1998
%%
\expandafter\ifx\csname indentation\endcsname\relax
\newlength{\indentation}\fi
\setlength{\indentation}{0.5em}
\begin{flushleft}
{\tt\#include} $<${\tt iostream}$>$\mbox{}\\
{\tt\#using namespace std;} \mbox{}\\
\mbox{}\\
{\bf int\/} main()\{\mbox{}\\
\hspace*{2\indentation}{\bf int\/} an;\mbox{}\\
\hspace*{2\indentation}cin $\gg$ an;	\mbox{}\\
\hspace*{2\indentation}{\bf if\/} ( (an\%4 ==0) \&\& ( (an\%100 !=0) $\mid\mid$ (an\%400 ==0) ) )\{\mbox{}\\
\hspace*{4\indentation}cout $\ll${\tt "ann\'ee bissextile"}$\ll$ endl;\mbox{}\\
\hspace*{2\indentation}\}\mbox{}\\
\hspace*{2\indentation}{\bf else\/} \mbox{}\\
\hspace*{4\indentation}cout $\ll$ {\tt "ann\'ee non bissextile"};    \mbox{}\\
\}\mbox{}\\
\end{flushleft}





\centerline{\bf switch}\index{switch} 
Ex\'ecute une instruction parmi un ensemble d'instructions selon la
valeur d'un entier.
 
\noindent{\it syntaxe:} 

{\tt switch(type entier)$\{ $


\hskip.1truein	case 1: instruction(s);
\hskip.2truein		 break;

\hskip.1truein		case 2: instruction(s);
\hskip.2truein		 break;

\hskip.1truein		default: instruction;
 
		$\}$
		}

\vspace{0.2cm}

\noindent{\bf Exemple:}

%
% This file was automatically produced at Mar 20 2000, 16:18:33 by
% c++2latex -o exemple6.tex essai.cc
%
\expandafter\ifx\csname indentation\endcsname\relax%
\newlength{\indentation}\fi
\setlength{\indentation}{0.5em}
\begin{flushleft}
{$//$\it{} -$\ast$- mode:C$+$$+$ ; compile-command: "g$+$$+$ -g  essai.cc  -lm" -$\ast$- {}\mbox{}\\
}{$//$\it{} Auteur: {}\mbox{}\\
}{$//$\it{} Date:  {}\mbox{}\\
}\mbox{}\\
{\tt \#include} $<${\tt{}iostream}$>$\mbox{}\\
\mbox{}\\
using namespace std;\mbox{}\\
\mbox{}\\
{\bf int} main()\{\mbox{}\\
\hspace*{2\indentation}{\bf double} x,y,res=0;\mbox{}\\
\hspace*{2\indentation}{\bf char} op;\mbox{}\\
\hspace*{2\indentation}cin $\gg$ x $\gg$ op $\gg$ y;\mbox{}\\
\hspace*{2\indentation}{\bf switch}(op)\{\mbox{}\\
\hspace*{2\indentation}{\bf case} '$+$':\mbox{}\\
\hspace*{4\indentation}res=x+y;\mbox{}\\
\hspace*{4\indentation}{\bf break};\mbox{}\\
\hspace*{2\indentation}{\bf case} '-':\mbox{}\\
\hspace*{4\indentation}res=x-y;\mbox{}\\
\hspace*{4\indentation}{\bf break};\mbox{}\\
\hspace*{2\indentation}{\bf case} '/':\mbox{}\\
\hspace*{4\indentation}{\bf if} (y!=0)\mbox{}\\
\hspace*{6\indentation}res=x$/$y;\mbox{}\\
\hspace*{4\indentation}{\bf else}\mbox{}\\
\hspace*{6\indentation}cerr $\ll$ {\tt"division par 0"} $\ll$ endl;\mbox{}\\
\hspace*{4\indentation}{\bf break};\mbox{}\\
\hspace*{2\indentation}{\bf default}:\mbox{}\\
\hspace*{4\indentation}cerr $\ll$ {\tt"Operation non prevue!"} $\ll$ endl;\mbox{}\\
\hspace*{2\indentation}\}\mbox{}\\
\hspace*{2\indentation}cout $\ll$ res $\ll$ endl;\mbox{}\\
\hspace*{2\indentation}{\bf return} 0;\mbox{}\\
\}\mbox{}\\
\end{flushleft}




On a tout int\'er\^et \`a remplacer, dans la mesure du possible, une suite de 
``if''(s) par un {\tt switch}: d'une part c'est plus facile \`a lire,
d'autre part  
{\tt switch} est plus rapide \`a l'ex\'ecution qu'une succession de ``if''.
   

\subsection{Les boucles} \label{sec:boucles}

\centerline{\bf for}\index{for} 
Ex\'ecute une instruction tant qu'une condition est v\'erifi\'ee.

\noindent{\it syntaxe:} 



\noindent {\tt {\bf for} (initialisation; condition d'arret; incr\'ementation) $\{$ 

  instruction; ou bloc d'instructions \\
$\}$}


Il est possible de d\'eclarer une variable de boucle dans l'instruction
{\tt for} : {\tt  for(int i=0;...;...)$\{$ $\}$}. Cette variable ne
sera cependant pas utilisable hors du bloc de la boucle.

On peut arr\^eter la boucle \`a tout moment en utilisant l'instruction
\verb|break;|. On peut arr\^eter l'it\'eration actuelle et
passer \`a l'it\'eration suivante en utilisant l'instruction 
\verb|continue;|

\noindent{\bf Exemple:}
\expandafter\ifx\csname indentation\endcsname\relax
\newlength{\indentation}\fi
\setlength{\indentation}{0.5em}
\begin{flushleft}
\hspace*{2\indentation}{\bf for\/} ({\bf int\/} i=0; i$<$ 10; i++) cout $\ll$ setw(5) $\ll$ i$\ast$i$\ast$i $\ll$endl;\mbox{}\\
\end{flushleft} 

\centerline{\bf while}\index{while}   
Il s'agit d'un cas simplifi\'e de boucle \verb|for|. Il n'y a pas
d'instruction d'initialisation de boucle ni d'instruction d'\'evolution.

\noindent {\it syntaxe:} 


\noindent {\tt {\bf while} (expression) $\{$ instruction ou 
bloc d'instructions $\}$}


\noindent{\bf Exemple:}\\
Calcul de la factorielle d'un (petit) entier.
%%
%% Creator: c++2latex -o exemple7.tex exemple7.cc
%% Date:    Tue Jun 30 12:15:55 1998
%%
\expandafter\ifx\csname indentation\endcsname\relax
\newlength{\indentation}\fi
\setlength{\indentation}{0.5em}
\begin{flushleft}
{\bf int\/} facto({\bf int\/} n)\{\mbox{}\\
\hspace*{2\indentation}{\bf int\/} j=1;\mbox{}\\
\hspace*{2\indentation}{\bf while\/} (n!=0)\{    \mbox{}\\
\hspace*{4\indentation}j=j$\ast$n;\mbox{}\\
\hspace*{4\indentation}n-{}-; \mbox{}\\
\hspace*{2\indentation}\}\mbox{}\\
\hspace*{2\indentation}{\bf return\/} (j);\mbox{}\\
\}\mbox{}\\
\end{flushleft}

\vskip.2truein

\centerline{\bf do ... while}\index{do ... while}  
Comme \verb|while|, mais la condition d'arr\^et est test\'ee {\bf apr\`es}
l'ex\'ecution du bloc d'instruction de la boucle.
La boucle est donc ex\'ecut\'ee au moins une fois.  


\noindent {\it syntaxe: } 



\noindent {\tt {\bf do} $\{$ instruction(s); $\}$ {\bf
  while } 
(expression );}.




\noindent {\bf Exemple:}
%%
%% Creator: c++2latex -o dowhile.tex dowhile.cc
%% Date:    Tue Jun 30 12:25:55 1998
%%
\expandafter\ifx\csname indentation\endcsname\relax
\newlength{\indentation}\fi
\setlength{\indentation}{0.5em}
\begin{flushleft}
{\tt\#include} $<${\tt iostream}$>$\mbox{}\\
{\tt\#using namespace std;} \mbox{}\\
\mbox{}\\
{\bf int\/} main()\{\mbox{}\\
\hspace*{2\indentation}{\bf char\/} rep;\mbox{}\\
\hspace*{2\indentation}{\bf do\/} \{\mbox{}\\
\hspace*{4\indentation}cout $\ll$ {\tt "voulez vous jouer (o/n)"} $\ll$endl;\mbox{}\\
\hspace*{4\indentation}cin $\gg$ rep;\mbox{}\\
\hspace*{2\indentation}\}\mbox{}\\
\hspace*{2\indentation}{\bf while\/} ( (rep!='o') \&\& (rep !='n') );\mbox{}\\
\hspace*{2\indentation}{\bf if\/} (rep=='o')\mbox{}\\
\hspace*{4\indentation}cout $\ll$ {\tt "on n'est pas ici pour s'amuser"} $\ll$endl;\mbox{}\\
\hspace*{2\indentation}{\bf else\/}\mbox{}\\
\hspace*{4\indentation}cout $\ll$ {\tt "au revoir"} $\ll$endl;\mbox{}\\
\}\mbox{}\\
\end{flushleft}


\subsection{TP4: Exercices} \label{sec:exos_if}
(maths--) \'Ecrire un programme qui lit au clavier une dur\'ee en secondes
  et la convertit en jours, heures, minutes et secondes.

(g\'en\'etique-)
\'Ecrire un programme v\'erifiant que 2 brins d'ADN sont compl\'ementaires
(i.e. les lettres des 2 brins se correspondent par la r\`egle A-T, T-A,
C-G, G-C)

(maths-) Construire un programme qui lit un entier positif $n$ et calcule
  les termes successifs de la suite d\'efinie par r\'ecurrence  de la
  fa\c{c}on suivante:
$u_0=n$, $u_{n+1}=u_n/2$ si $u_n$ est pair , $u_{n+1}=3u_n +1$
  sinon. On s'arr\^ete lorsque $u_n=1$ ou lorsque le nombre d'it\'erations
  est trop grand; dans tous les cas on affiche le nombre d'it\'erations
  et un message qui permet de distinguer les deux cas.


(maths-) Construire un programme qui lit un entier $N$ et calcule la
  somme $\sum_1^N \frac{1}{k^2}$ dans le sens des indices croissants
  puis d\'ecroissants. 


(maths) Construire un programme qui, \'etant donn\'ee une droite dans le
  plan, d\'etermine si deux points du plan sont plac\'es de part et
  d'autre de la droite ou non.

(g\'en\'etique) \'Ecrire un programme qui d\'etermine le d\'ebut et la
fin d'une partie codante d'une s\'equence d'ARN 
(en recherchant le premier triplet de d\'emarrage AUG 
et l'un des triplets de fin correspondants UAA, UGA, UAG). 
Modifier le programme
pr\'ec\'edent pour qu'il lise de 3 en 3 seulement et d\'etermine
les 3 possibilit\'es de partie codante de l'ARN (selon que l'on commence
\`a la 1\`ere, 2\`eme ou 3\`eme lettre la lecture de 3 en 3). On renverra
pour chacune la longueur de la s\'equence codante et le rapport
du nombre de bases AU sur le nombre de bases CG.




\section{Les fonctions.} 
On peut d\'efinir une fonction
de deux mani\`eres selon que le bloc d'instruction est accol\'e \`a la
d\'eclaration du prototype de la fonction ou non. Dans le deuxi\`eme cas
on d\'eclare la fonction puis on la d\'efinit:

\vskip.2truein
\noindent{\bf D\'eclaration d'une fonction}\index{fonction (d\'eclaration)} 

{\tt  type Nom-de-fonction(liste-typ\'ee-des-arguments);}

Le type\index{type}  est le type de la valeur prise par la
fonction. Le type {\tt void} pr\'ecise
simplement que la fonction ne retourne pas de valeur.

La liste des arguments peut \^etre vide:  dans ce cas, 
la d\'eclaration se fait de la  fa\c{c}on suivante:\\
{\tt   type Nom-de-fonction();}

{\bf Attention~: \\
Ne pas oublier de mettre des parenth\`eses lors de l'appel de la fonction 
m\^eme si elle ne prend aucun argument.}

La d\'eclaration des fonctions, si elle n'est pas toujours n\'ecessaire 
dans de petits programmes, est indispensable si l'on veut appeler une 
fonction avant de l'avoir d\'efinie ou l'utiliser dans des modules 
distincts (on parle de ``programmation modulaire''). 


\vskip.2truein
\noindent{\bf D\'efinition d'une fonction} \index{fonction (d\'efinition)} 

{\tt  type Nom-de-fonction(liste-typ\'ee-des-param\`etres)}

{\tt bloc d'instructions }     


\noindent {\bf Exemple 1:}
%%
%% Creator: c++2latex -o exemple1.tex exemple.cc
%% Date:    Thu Jun 25 14:10:17 1998
%%
\expandafter\ifx\csname indentation\endcsname\relax
\newlength{\indentation}\fi
\setlength{\indentation}{0.5em}
\begin{flushleft}
{\tt\#include} $<${\tt iostream}$>$\mbox{}\\
{\tt\#using namespace std;} \mbox{}\\
{\bf void\/} salut()\{\mbox{}\\
\hspace*{2\indentation}cout $\ll$ {\tt "salut toi!"} $\ll$endl;\mbox{}\\
\}\mbox{}\\
\mbox{}\\
{\bf int\/} main()\{\mbox{}\\
\hspace*{2\indentation}salut();\mbox{}\\
\}\mbox{}\\
\end{flushleft}


\noindent{\bf Exemple 2:}
%%
%% Creator: c++2latex -o exemple2.tex exemple2.cc
%% Date:    Thu Jun 25 14:20:49 1998
%%
\expandafter\ifx\csname indentation\endcsname\relax
\newlength{\indentation}\fi
\setlength{\indentation}{0.5em}
\begin{flushleft}
{\tt\#include} $<${\tt iostream}$>$\mbox{}\\
{\tt\#using namespace std;} \mbox{}\\
{\bf float\/} carre ({\bf float\/} x);                     \hfill{\em //\hspace*{1\indentation}d\'eclaration\hspace*{1\indentation}de\hspace*{1\indentation}la\hspace*{1\indentation}fonction}\mbox{}\\
\mbox{} \\
{\bf int\/} main()\{ // declaration et definition de main\mbox{}\\
\hspace*{2\indentation}{\bf float\/} x;\mbox{}\\
\hspace*{2\indentation}cin $\gg$ x;\mbox{}\\
\hspace*{2\indentation}cout $\ll$ {\tt " le carr\'e de "} $\ll$ x $\ll$ {\tt "est "} $\ll$ carre(x) $\ll$ endl;\mbox{}\\
\}\mbox{}\\
\mbox{}\\
{\bf float\/} carre ({\bf float\/} x)\{                    \hfill{\em //\hspace*{1\indentation}d\'efinition\hspace*{1\indentation}de\hspace*{1\indentation}la\hspace*{1\indentation}fonction\hspace*{1\indentation}carre\hspace*{1\indentation}}\mbox{}\\
\hspace*{2\indentation}{\bf return\/} (x$\ast$x);\mbox{}\\
\}\mbox{}\\
\end{flushleft}


\noindent{\bf Exemple 3:}
%%
%% Creator: c++2latex -o exemple10.tex exemple10.cc
%% Date:    Fri Jun 26 09:51:11 1998
%%
\expandafter\ifx\csname indentation\endcsname\relax
\newlength{\indentation}\fi
\setlength{\indentation}{0.5em}
\begin{flushleft}
{\tt\#include} $<${\tt iostream}$>$\mbox{}\\
{\tt\#using namespace std;} \mbox{}\\
{\bf float\/} pointure({\bf float\/} x);\mbox{}\\
{\bf void\/} sortie({\bf string\/} nom, {\bf float\/} y);\mbox{}\\
\mbox{}\\
{\bf int\/} main()\{\mbox{}\\
\hspace*{2\indentation}cout $\ll$ "donnez votre nom de login"$\ll$ endl; \mbox{}\\
\hspace*{2\indentation}{\bf string\/} nom;\mbox{}\\
\hspace*{2\indentation}cin $\gg$ nom;\mbox{}\\
\hspace*{2\indentation}cout $\ll$ "Quelle est la longueur de votre pied en centim\`etres"$\ll$ endl;\mbox{}\\
\hspace*{2\indentation}{\bf float\/} pied;\mbox{}\\
\hspace*{2\indentation}cin $\gg$ pied;\mbox{}\\
\hspace*{2\indentation}sortie(nom, pied);\mbox{}\\
\}\mbox{}\\
\mbox{}\\
{\bf float\/} pointure({\bf float\/} x)\{\mbox{}\\
\hspace*{2\indentation}{\bf return\/} (1.5 $\ast$ (x+1));\mbox{}\\
\} \mbox{}\\
\mbox{}\\
{\bf void\/} sortie({\bf string\/} nom, {\bf float\/} y) \{\mbox{}\\
\hspace*{2\indentation}cout $\ll$ nom $\ll$ "votre pointure est " $\ll$ pointure(y) $\ll$  endl;\mbox{}\\
\}\mbox{}\\
\end{flushleft}

Remarques:
\begin{itemize}
\item L'instruction {\tt return (y)}\index{return}  
permet d'assigner la valeur {\tt y} \`a valuer renvoy\'ee par la 
fonction.
\item 
Une instruction {\tt return}  provoque une sortie imm\'ediate de la fonction.
\item 
On appelle parfois ``proc\'edure''\index{proc\'edure}  
une fonction de type {\tt void} 
(qui ne comporte donc pas d'instruction {\tt return}).  
\end{itemize}

{\bf Exercices:}

1/ \'Ecrire une fonction qui renvoie 1 si deux caract\`eres d'un code
ADN sont compl\'ementaires et 0 sinon
(les couples A T et C G sont compl\'ementaires).
Utilisez cette fonction pour \'ecrire une fonction qui renvoie
1 si deux chaines d'ADN sont compl\'ementaires et 0 sinon.

2/ \'Ecrire une fonction qui renvoie la chaine d'ADN compl\'ementaire
d'une chaine donn\'ee.

3/ \'Ecrire une fonction qui renvoie le vecteur somme des deux vecteurs
pass\'es en argument. Utilisez cette fonction pour \'ecrire une
fonction qui renvoie la matrice somme de deux matrices.

4/ \'Ecrire une fonction qui calcule le produit scalaire de deux vecteurs.
\'Ecrire une fonction qui calcule la transpos\'ee d'une matrice.
Utilisez ces deux fonctions pour calculer le produit de deux matrices.

\vskip.2truein

\noindent{\bf Passage par r\'ef\'erence}\index{passage par r\'ef\'erence} \\
Une fonction ne peut renvoyer qu'une et une seule valeur.
Il arrive parfois qu'on souhaite modifier la valeur de plusieurs variables
\`a l'int\'erieur d'une m\^eme fonction. Par exemple consid\'erons
une fonction \verb|virement| qui effectue le virement d'une somme d'un compte
bancaire \`a un autre. Cette fonction doit modifier deux variables en m\^eme 
temps: le solde du compte d\'ebit\'e et le solde du compte cr\'edit\'e.
Supposons aussi que le compte \`a d\'ebiter soit inscrit dans le deuxi\`eme 
classeur des archives de la banque et que le solde actuel soit de 10000F.

Les fonctions que nous avons vu jusqu'\`a maintenant
recopient les arguments lors de l'appel de la fonction
dans de nouvelles variables qui sont d\'efinies \`a l'int\'erieur de 
la fonction. Elles peuvent alors modifier les valeurs de ces
nouvelles variables mais ces modifications ne se r\'epercutent pas
sur la valeur des variables dont elles sont la copie.

L'id\'ee est en fait de passer en arguments \`a la fonction
non pas la valeur d'une variable 
mais l'adresse m\'emoire o\`u est stock\'e le contenu de la variable.
Dans l'exemple ci-dessus, au lieu de passer en argument la valeur
du solde (c'est-\`a-dire le nombre 10000F), on passe en argument l'endroit 
o\`u est \'ecrit la valeur du solde (c'est-\`a-dire ``le nombre
du deuxi\`eme classeur'')

C'est ce qu'on appelle passer des arguments 
{\it par r\'ef\'erence}.\index{passage par r\'ef\'erence}

{\bf Les arguments pass\'es par r\'ef\'erence sont pr\'ec\'ed\'es 
du signe $\&$. }\\
Dans l'exemple ci-dessous, {\tt $\&$ debit} repr\'esente en fait l'adresse 
(en m\'emoire) de la variable {\tt debit}
(c'est-\`a-dire l'adresse m\'emoire o\`u est stock\'e le contenu de la
variable)

\noindent{\bf exemple:}
\begin{verbatim}
#include <iostream>
using namespace std;

void virement(int somme, int & debit, int & credit){
  debit = debit - somme;
  credit = credit + somme ;
  somme = 0;
}

int main(){
  int solde_client1 = 10000;
  int solde_client2 = 5000;
  int montant;
  cout << "Tapez le montant a virer: ";
  cin >> montant ;
  virement(montant,solde_client1,solde_client2);
  cout << "Montant vire: " << montant << endl;
  cout << "Nouveau solde du client 1: " << solde_client1 << endl;
  cout << "Nouveau solde du client 2: " << solde_client2 << endl;
}
\end{verbatim}

Observez que la fonction \verb|virement| modifie les variables 
\verb|solde_client1| et \verb|solde_client2| mais ne modifie pas
la valeur de la variable \verb|montant| qui n'est pas pass\'ee par
r\'ef\'erence (mais a \'et\'e recopi\'ee dans la variable \verb|somme|
de \verb|virement|). A la fin de l'ex\'ecution de \verb|virement|, 
\verb|somme| vaut 0, mais \verb|montant| n'a pas chang\'e.


{\bf Exercice:\\}
Modifier la fonction de l'exercice 1/ ci-dessous 
en ajoutant un argument de type
entier qui sera augment\'e de 1 si les 2 caract\`eres sont compl\'ementaires.
Utilisez cette fonction pour compter le nombre de caract\`eres
compl\'ementaires dans deux chaines de caract\`eres.

\'Ecrire une fonction transpos\'ee qui modifie son argument en la
matrice transpos\'ee et ne renvoie rien.

\vskip.2truein
\noindent{\bf Remarque} \\
On utilise aussi le passage par r\'ef\'erence dans des situations
o\`u on {\bf ne modifie pas} l'argument. Il s'agit alors d'\'eviter de recopier
des donn\'ees de grande taille, par exemple un vecteur contenant un
million d'\'el\'ements. On fait alors pr\'ec\'eder le type de la variable
par le mot-clef \verb|const|, par exemple~:
\begin{verbatim}
int somme(const vector<int> & v){
  int resultat=0;
  for (int i=0;i<v.size();i++)
    resultat = resultat + v[i] ;
  return resultat;
}
\end{verbatim}

\vskip.2truein
\noindent{\bf D\'efinition inline}\index{inline} 
Un appel d'une fonction de ce type dans le code source
n'est pas remplac\'e par 
un appel de la fonction dans le programme ex\'ecutable, \`a la place,
le code source de la fonction est recopi\'e int\'egralement (autant de
fois que la fonction est appel\'ee).
L'ex\'ecution est un peu plus rapide mais le code engendr\'e peut devenir
beaucoup plus grand.

\noindent{\bf Exemple}

%%
%% Creator: c++2latex -o exemple15.tex exemple15.cc
%% Date:    Fri Jun 26 11:39:31 1998
%%
\expandafter\ifx\csname indentation\endcsname\relax
\newlength{\indentation}\fi
\setlength{\indentation}{0.5em}
\begin{flushleft}
{\tt\#include} $<${\tt iostream}$>$\mbox{}\\
{\tt\#using namespace std;} \mbox{}\\
\mbox{}\\
{\bf inline\/} {\bf int\/} cube({\bf int\/} n) \{ {\bf return\/} n$\ast$n$\ast$n;\}\mbox{}\\
\mbox{}\\
{\bf int\/} main()\{\mbox{}\\
\hspace*{2\indentation}cout $\ll$ cube(6)$\ll$ endl;\mbox{}\\
\}\mbox{}\\
\end{flushleft}
  

\vskip.2truein
\noindent{\bf Remarque} Il est possible de donner des valeurs 
{\it par d\'efaut} \`a certains param\`etres 
(les derniers de la liste des param\`etres). Quand on appelle la
fonction, on peut donner ou ne pas donner la valeur de ces arguments,
dans le deuxi\`eme cas les valeurs par d\'efaut sont utilis\'ees.
%%
%% Creator: c++2latex -o defaut.tex defaut.cc
%% Date:    Wed Jun  2 13:49:33 1999
%%
\expandafter\ifx\csname indentation\endcsname\relax%
\newlength{\indentation}\fi
\setlength{\indentation}{0.5em}
\begin{flushleft}
{\bf double\/} f({\bf double\/} x, {\bf int\/} n=0);\mbox{}\\
{\bf double\/} f({\bf double\/} x, {\bf int\/} n)\{\mbox{}\\
\hspace*{2\indentation}{\bf return\/} (x$\ast$x + n$\ast$x);\mbox{}\\
\}\mbox{}\\
\mbox{}\\
{\bf int\/} main()\{\mbox{}\\
\hspace*{2\indentation}cout $\ll$ f(3.0)$\ll$endl;\mbox{}\\
\hspace*{2\indentation}cout $\ll$ f(3.0 ,5)$\ll$endl;\mbox{}\\
\}\mbox{}\\
\end{flushleft}


\section{Lecture et \'ecriture des donn\'ees.}
Cette section explique comment transf\'erer des donn\'ees \'ecrites
en toutes lettres depuis le clavier, vers l'ecran, depuis et vers
des fichiers texte ou depuis et vers des chaines de caract\`eres.

\subsection{Lire au clavier et \'ecrire \`a l'\'ecran.} \label{sec:ecran_clavier}

Trois flots (``stream'')\index{flots}  
sont pr\'ed\'efinis apr\`es inclusion du fichier 
{\tt iostream}:
\begin{enumerate}
\item[{\bf cout}\index{cout}]  
  correspond \`a la sortie ({\tt out}) standard (\'ecran en g\'en\'eral...)
\item[{\bf cin}\index{cin} ]  correspond \`a l'entr\'ee ({\tt in}) standard 
(clavier en g\'en\'eral)
\item[{\bf cerr}\index{cerr} ] est utilis\'e pour envoyer des messages d'erreur
(\`a l'\'ecran en g\'en\'eral).
\end{enumerate}
$< <$  permet d'envoyer des valeurs dans un flot de sortie.\\
$> >$ lit des donn\'ees dans un flot d'entr\'ee.\\
Il faut s'imaginer que les donn\'ees s'\'ecoulent dans le sens d'un
entonnoir \verb|>>|.

Remarque:\\
\verb|cout| n'affiche pas forc\'ement les donn\'ees \`a l'\'ecran
imm\'ediatement. Il place les donn\'ees dans une zone m\'emoire transitoire 
({\em buffer}\/ en anglais). Cette zone sera affich\'ee d'un seul coup
par exemple lorsqu'on demande de passer \`a la ligne, pour cela on peut
utiliser l'instruction:\\
{\tt cout $<<$ endl;}


\noindent{\bf exemple:}   
%%
%% Creator: c++2latex -o exemple8.tex exemple8.cc
%% Date:    Fri Jun 26 09:47:08 1998
%%
\expandafter\ifx\csname indentation\endcsname\relax
\newlength{\indentation}\fi
\setlength{\indentation}{0.5em}
\begin{flushleft}
{\tt\#include} $<${\tt iostream}$>$\mbox{}\\
{\tt\#using namespace std;} \mbox{}\\
\mbox{}\\
{\bf int\/} main()\{\mbox{}\\
\hspace*{2\indentation}{\bf int\/} a, b;\mbox{}\\
\hspace*{2\indentation}cout $\ll$ {\tt " donnez deux entiers a et b (b non nul)"}$\ll$endl;\mbox{}\\
\hspace*{2\indentation}cin $\gg$ a $\gg$ b; \mbox{}\\
\hspace*{2\indentation}{\bf if\/} (b==0) \{ cerr $\ll$ {\tt "division par 0"} $\ll$endl; \} \mbox{}\\
\hspace*{2\indentation}{\bf else\/ } \{ \mbox{}\\
\hspace*{4\indentation}cout $\ll$ {\tt " le quotient entier de a par b est "} 
$\ll$ a$/$b $\ll$ endl;\mbox{}\\
\hspace*{4\indentation}cout $\ll$ {\tt " le reste de a par b est "} 
$\ll$ a \% b $\ll$ endl;\mbox{}\\
\hspace*{2\indentation}\} \mbox{}\\
\}\mbox{}\\
\mbox{}\\
\end{flushleft}

Notez le test \verb|if (b==0)|: si $b$ est nul, le bloc d\'elimit\'e
par \verb|{| et \verb|}| entre \verb|if| et \verb|else| est ex\'ecut\'e,
sinon c'est le bloc qui suit \verb|else| qui est ex\'ecut\'e.

L'inclusion du fichier en-t\^ete\index{header}  
{\tt iomanip}\index{iomanip}  permet de controler les param\`etres
d'affichage. Par exemple:\\
{\tt precision (int n)}\index{precision(int n)}\\
d\'efinit la pr\'ecision (\`a l'affichage) des nombres r\'eels (type 
\verb|float| ou \verb|double|)\\
{\tt setw (int n)}\index{setw}\\
d\'efinit la taille en nombre de caract\`eres d'un champ d'affichage.


\noindent {\bf exemple 1}:
\index{cout.precision(int n)} \\
\expandafter\ifx\csname indentation\endcsname\relax
\newlength{\indentation}\fi
\setlength{\indentation}{0.5em}
\begin{flushleft}
{\tt\#include} $<${\tt iostream}$>$\mbox{}\\
{\tt\#include} $<${\tt iomanip}$>$\mbox{}\\
{\tt\#include} $<${\tt cmath}$>$\mbox{}\\
{\tt\#using namespace std;} \mbox{}\\
\mbox{}\\
{\bf int\/} main()\{\mbox{}\\
\hspace*{2\indentation} cout.precision(6) ;\mbox{}\\ 
\hspace*{2\indentation} cout $\ll$ sqrt(2);\mbox{}\\  
\}\mbox{}\\
\end{flushleft}

\noindent donne {\tt 1.41421}.

\vspace{0.5cm}

\noindent {\bf exemple 2}:
%%
%% Creator: c++2latex -o exemple11.tex exemple11.cc
%% Date:    Fri Jun 26 10:03:19 1998
%%
\expandafter\ifx\csname indentation\endcsname\relax
\newlength{\indentation}\fi
\setlength{\indentation}{0.5em}
\begin{flushleft}
{\tt\#include} $<${\tt iostream}$>$\mbox{}\\
{\tt\#include} $<${\tt iomanip}$>$\mbox{}\\
{\tt\#using namespace std;} \mbox{}\\
\mbox{}\\
{\bf int\/} main()\{\mbox{}\\
\hspace*{2\indentation}{\bf for\/} ({\bf int\/} i=0; i$<$ 10; i++) cout $\ll$ setw(5) $\ll$ i$\ast$i$\ast$i $\ll$endl;\mbox{}\\
\}\mbox{}\\
\end{flushleft}


{\bf Exercice:\\} 
Lire un r\'eel et l'afficher successivement avec 0,1,2,3,4,5 et 6 d\'ecimales.

\subsection{Lire et \'ecrire sur le disque dur.} \label{sec:fichier}
Jusqu'\`a pr\'esent nous avons lu des donn\'ees au clavier et \'ecrit
des donn\'ees \`a l'\'ecran. Nous allons voir maintenant comment lire
des donn\'ees depuis un fichier et \'ecrire des
donn\'ees dans un fichier (sur le disque dur).

Le fichier header \`a inclure s'appelle \verb|fstream| au lieu de
\verb|iostream|. Ensuite il faut d\'eclarer une variable qui fera
le lien avec le nom du fichier sur le disque dur. Par exemple supposons
que le nom du fichier sur le disque dur s'appelle \verb|fichier_disquedur|
et qu'on souhaite utiliser le nom de variable \verb|fichier_prog| dans
le texte source.
\begin{itemize}
\item Pour lire des donn\'ees dans ce fichier, on d\'eclare:\\
\verb|ifstream fichier_prog("fichier_disquedur");|\\
puis on utilise \verb|fichier_prog| comme \verb|cin|, par exemple:\\
\verb|fichier_prog >> donnee ; |
\item Pour \'ecrire des donn\'ees dans ce fichier, on d\'eclare:\\
\verb|ofstream fichier_prog("fichier_disquedur");|\\
puis on utilise \verb|fichier_prog| comme \verb|cout|, par exemple:\\
\verb|fichier_prog << donnee << endl ;|
\end{itemize}


\subsection{Lire et \'ecrire dans des {\tt string}.} \label{sec:flux_chaine}
Cela permet en particulier de convertir des chaines de caract\`eres
en des types entiers ou r\'eels et inversement.

Le fichier en-t\^ete \`a inclure est \verb|#include <strstream>| (vous
devrez aussi inclure \verb|#include <string>|). Comme
pour les flots fichiers, on d\'efinit une variable qui fait le lien
entre la chaine de caract\`ere et la variable de flot.
\begin{itemize}
\item Pour lire des fichiers depuis une chaine~:\\
\verb|string s("15 22 13.6 64.1");|\\
\verb|istrstream a_lire(s.c_str());|\\
\verb|int i1,i2; double d1,d2;|\\
\verb|a_lire >> i1 >> i2 >> d1 >> d2;|
\item Pour \'ecrire des donn\'ees dans une chaine de caract\`ere~:\\
\verb|ostrstream a_ecrire;|\\
\verb|double d=17.3; int i=56;|\\
\verb|a_ecrire << d << " " << i ;|\\
\verb|string t(a_ecrire.str()); // Place le resultat dans la chaine t|
\end{itemize}


\section{Le g\'en\'erateur de nombres al\'eatoires} \label{sec:proba}
Vu son importance, nous allons maintenant d\'ecrire le g\'en\'erateur 
de nombre al\'eatoire de la librarie standard C.
La librairie standard C (\verb|#include <cstdlib>|) fournit deux instructions
pour renvoyer des nombres (pseudo-)al\'eatoires: \verb|rand| et \verb|srand|.\\
\verb|rand()| renvoie un entier compris entre 0 et la constante 
enti\`ere \verb|RAND_MAX|. \verb|srand(i)| sert \`a initialiser le
g\'en\'erateur de nombre al\'eatoire, pour une valeur de $i$ donn\'ee
la suite de nombre renvoy\'ee par des appels successifs \`a \verb|rand|
sera toujours la m\^eme ce qui est tr\`es utile pour mettre au point
un programme. Une fois le programme mis au point, on initialise en
g\'en\'eral le g\'en\'erateur de mani\`ere plus al\'eatoire, par exemple
\`a l'aide de l'horloge du syst\`eme.

Exemple:
\begin{verbatim}
#include <cstdlib>
#include <ctime>
#include <iostream>
using namespace std;

int main(){
  srand(time(NULL)); // initialise le generateur de maniere aleatoire
  for (int i=0 ; i<10;i++ ) { 
    float f=rand()/(RAND_MAX+1.0);
    cout << "Voici un reel compris entre 0 et 1: " << f << endl ;
  }
  return(0);
}
\end{verbatim}
Notez le \verb|1.0| (et non pas \verb|1|), sinon la division d\'efinissant
\verb|f| serait une division d'entiers et renverrait toujours 0.

Pour avoir toujours la m\^eme suite de nombres, remplacez
\verb|srand(time(NULL))| par exemple par \verb|srand(2000)|.

Pour g\'en\'erer un entier al\'eatoire entre 1 et 10 on utilisera:\\
\verb|j=1+(int) (10.0*rand()/(RAND_MAX+1.0));|

{\bf Exercices~:}
(proba) Simuler un tirage al\'eatoire de 2 d\'es (\`a l'aide des
fonctions \verb|rand| et \verb|srand|). V\'erifier exp\'erimentalement
sur un grand nombre de tirages les fr\'equences d'apparition de 2 \`a 12.

(proba) Simuler un tirage d'une chaine de caract\`ere de longueur
al\'eatoire et dont les caract\`eres sont choisis al\'eatoirement
parmi les caract\`eres A, C, G, T.

\section{TP 5} \label{sec:tp5}
\'Ecrire une fonction permettant de rentrer les coefficients
d'une matrice de r\'eels.

\'Ecrire une fonction affichant une matrice de nombres r\'eels
(de type\\ \verb|vector< vector<double> >|)

(g\'en\'etique) \'Ecrire une fonction renvoyant la position d'un codon 
de start dans une chaine d'ARN. Faites de m\^eme pour d\'eterminer
la position d'un codon de stop \`a partir d'une position donn\'ee.

(maths) On consid\`ere les suites r\'eelles $(u_n)$ et $(v_n)$ d\'efinies 
par leurs termes initiaux $u>0$ et $v>0$ et les relations de r\'ecurrence 
suivantes:
$$ u_{n+1}=\frac{u_n+v_n}{2} \quad \mbox{et } \quad v_{n+1}=\sqrt{u_nv_n}.$$
On peut montrer que ces suites convergent et ont m\^eme limite,
on veut v\'erifier exp\'erimentalement ce fait. \'Ecrire une fonction\\
{\tt int rang (double epsilon);} \\
qui d\'etermine le premier entier $n$ tel que 
$|u_n-v_n|<epsilon$ 
(on n\'eglige ici les erreurs d'arrondi faites par la machine).




\section{Calcul num\'erique} \label{sec:numerique}

\subsection{Les r\'eels.} \label{sec:reels}
On les repr\'esente avec les types \verb|float|, \verb|double| ou 
\verb|long double|.
Les fonctions usuelles (trigonom\'etriques, exponentielle, logarithme, etc.)
sont d\'efinies dans le fichier en-t\^ete~:\\
\verb|#include <cmath>|

Rappelons que \verb|a| \`a la puissance \verb|b| se note souvent \verb|a^b|
mais se code en C++ \verb|pow(a,b)|. Les autres diff\'erences par
rapport \`a la notation math\'ematique standard sont:
\begin{itemize}
\item \verb|log|: d\'esigne le logarithme nep\'erien (not\'e ln ou Log en 
math\'ematique)
\item \verb|log10|: d\'esigne le logarithme en base 10 (not\'e log en
math\'ematique)
\item \verb|atan2(x,y)|: d\'esigne l'argument du nombre complexe $x+iy$.
\item \verb|floor|: d\'esigne la partie enti\`ere (attention le type C 
renvoy\'e n'est pas \verb|int| mais reste \verb|double| ou \verb|float|)
\item \verb|ceil|: plus petit entier sup\'erieur ou \'egal
\end{itemize}


\subsection{Les nombres complexes.} \label{sec:complexes}
Il faut inclure~:\\
\verb|#include <complex>|

Ensuite on choisit quel type on utilise pour la partie r\'eelle et imaginaire,
par exemple~:\\
\verb|complex<double> c;|\\
On peut d\'efinir un type synonyme pour raccourcir~:\\
\verb|typedef complex<float> complexe;|\\
\verb|complexe c1(1.2,2.3);|\\
La ligne ci-dessus d\'efinit alors une variable complexe \verb|c1| de partie
r\'eelle \verb|1.2| et de partie imaginaire \verb|2.3|. Il est
agr\'eable de d\'efinir un complexe \verb|i| (en math\'ematique, mais
en \'electricit\'e on pr\'eferera d\'efinir un complexe \verb|j|)~:\\
\verb|complexe i(0.0,1.0);|\\
pour pouvoir utiliser la notation alg\'ebrique, par exemple~:\\
\verb|c1=c1*(1+3*i);|\\
mais faites alors attention \`a ne plus utiliser \verb|i| pour autre
chose, par exemple comme variable de boucle!

Les fonctions usuelles sont d\'efinies (voir les r\'eels), plus quelques
fonctions propres aux nombres complexes~:
\begin{itemize}
\item \verb|real|, \verb|imag|, \verb|conj|~: partie r\'eelle, imaginaire,
conjugu\'e d'un complexe
\item \verb|polar(r,t)|~: renvoie le complexe $r e^{it}$
\item \verb|abs|~: renvoie le module d'un nombre complexe (c'est un type
r\'eel).
\item \verb|norm|~: renvoie le module au carr\'e
\item \verb|arg|~: argument d'un nombre complexe
\end{itemize}


\subsection{Entiers en pr\'ecision arbitraire et calcul formel.} 
\label{sec:extended}
Ils ne font pas partie du standard C++, il est donc n\'ecessaire
d'utiliser des librairies (et \'eventuellement de les installer).
On utilisera la librairie C GMP que l'on peut t\'el\'echarger par
exemple depuis \verb|http://gmplib.org/|. GMP version 4
poss\`ede une interface C++, rajoutez au d\'ebut de votre fichier source~:\\
\verb|#include <gmp/gmpxx.h>|\\
puis remplacez le type \verb|int| par le type \verb|gmpxx| et rajoutez
\verb|-lgmp| \`a votre ligne de compilation.

Pour faire du calcul formel en C++~:\\
\verb|http://www-fourier.ujf-grenoble.fr/~parisse/giac_fr.html|

Un exemple de programme avec giac~:
\begin{verbatim}
// -*- mode:C++ ; compile-command: "g++ -g essai.cc -lm -lgiac -lgmp -lpng" -*- 

#include <iostream>
#include <string>
#include <giac/giac.h>

using namespace std;
using namespace giac;

int main(){
  context ct;
  gen a,b("x^2-1",&ct);
  cin >> a;
  cout << _factor(a*b,&ct) << endl;
}
\end{verbatim}

\section{D'autres librairies C(++) scientifiques.} \label{sec:libs}
Il existe de nombreuses librairies pour \'eviter de reprogrammer
ce qui a d\'ej\`a \'et\'e programm\'e, par exemple la Gnu Scientific
Library \verb|http://www.gnu.org/software/gsl/|.

\section{Mettre au point un programme.}
Lorsqu'un programme ne fonctionne pas comme pr\'evu, on peut souvent
d\'etecter des erreurs en l'ex\'ecutant en pas-\`a-pas (une ligne
de code apr\`es l'autre) et en examinant l'\'evolution du contenu
des variables. L'application qui permet de faire cela s'appelle un
d\'eboggueur. Plusieurs interfaces existent, on pr\'esente ici  
\verb|gdb| sous \verb|emacs|
qui s'ex\'ecute dans
l'environnement d'\'edition du texte source (ce qui permet de corriger
votre programme et de relancer le debuggueur sur la version
modifi\'ee avec les m\^emes arguments et points d'arr\^et).
\begin{enumerate}
\item V\'erifiez que l'option \verb|-g| apparait dans la ligne de compilation
(premi\`ere ligne du texte source par exemple:\\
\verb|// -*- mode:C++; compile-command:"g++ -g essai.cc -lm" -*-|)
\item Compilez le programme, on suppose dans la suite que le programme
compil\'e s'appelle \verb|a.out| ce qui est le cas par d\'efaut
\item Dans \verb|emacs|, s\'electionnez Debugger (GDB) dans le menu Tools
ou tapez sur la touche \verb|Echap|, vous devez voir
apparaitre \verb|ESC-| au bout de quelques secondes, puis tapez \verb|xgdb|
et la touche \verb|Entree|. Vous devez alors voir dans la ligne d'\'etat
en bas:\\
\verb|Run gdb (like this): gdb a.out|\\
Modifiez si n\'ecessaire puis tapez \verb|Entree|. Le deboggueur est activ\'e.
\item Pour visualiser \`a la fois le source du programme et le
d\'ebbugueur, il peut \^etre n\'ecessaire de couper la fen\^etre
en deux (menu File->Split Window ou raccourci clavier Ctrl-X 2),
et dans l'une des parties de s\'electionner le source (menu Buffers
ou raccourci Ctrl-X o).
\item L'\'etape suivante consiste \`a mettre un {\em point d'arr\^et}\/ 
pr\`es de l'endroit o\`u vous suspectez qu'il y a une erreur (par exemple
au d\'ebut d'une fonction suspecte). Il y a deux
m\'ethodes, soit en donnant le nom de la routine, par exemple pour le
programme principal \verb|main|:\\
\verb|b main|\\
soit dans le code source, en cliquant \`a gauche de la ligne ou
en tapant \verb|Ctrl-X| puis la touche Espace
\`a la ligne souhait\'ee. 
On peut aussi taper \verb|b|
suivi par le num\'ero de ligne dans le fichier source 
(ou \verb|nom_ficher:numero_ligne|). 
Vous pouvez mettre plusieurs points d'arr\^et.
\item Puis on lance l'ex\'ecution du programme en cliquant sur Go ou
en tapant \verb|r| (pour run). On peut aussi sp\'ecifier les arguments
de la fonction \verb|main(int argc,char ** argv)| apr\`es 
la commande \verb|r|.
\item Le programme s'ex\'ecute normalement jusqu'\`a ce qu'il atteigne
le point d'arr\^et. On peut alors visualiser le contenu d'une variable
en utilisant l'instruction \verb|p| (pour print), par exemple:\\
\verb|p modulo| puis touche \verb|Entree|\\
imprime le contenu de la variable \verb|modulo| (si elle existe).
\item L'instruction \verb|n| (next) ex\'ecute la ligne courante.
Pour ex\'ecuter ensuite plusieurs lignes \`a la suite, on tape plusieurs
fois sur la touche Entree. On peut aussi indiquer un param\`tre
num\'erique \`a la commande \verb|n|.
\item L'instruction \verb|s| (step in) permet de rentrer \`a l'int\'erieur
d'une fonction si la ligne courante doit ex\'ecuter cette fonction (alors
que \verb|n| ex\'ecute cette fonction en un seul pas, sauf si cette
fonction contient un point d'arr\^et)
\item L'instruction \verb|u| (until) ex\'ecute le programme sans arr\^et
jusqu'\`a ce que la ligne de code source suivante soit atteinte (ou une
adresse donn\'e en param\`etre). C'est
particuli\`erement int\'eressant pour sauter au-del\`a d'une boucle.
\item L'instruction \verb|c| (continue) permet de continuer l'ex\'ecution
jusqu'au prochain point d'arr\^et. On peut aussi indiquer un param\`etre
pour ignorer le point d'arr\^et un certain nombre de fois.
\item \verb|kill| permet de stopper
le programme en cours, 
\item \verb|d| permet de d\'etruire un point d'arr\^et (on donne alors
son num\'ero) ou tous les points d'arr\^et. On peut aussi temporairement
d\'esactiver ou r\'eactiver un point d'arr\^et 
(commandes \verb|disable| et \verb|enable|)
\item \verb|f 0|, \verb|f 1|, etc. permet de visualiser la
fonction appelante \`a l'ordre demand\'e de la fonction interrompue
(0 pour la fonction actuelle, 1 pour la 1\`ere appelante, etc.),
ainsi que les variables de cette fonction.
\item \verb|bt| affiche la liste des fonctions appelantes. Tr\`es utile
si votre programme plante avec un \verb|Segmentation fault|,
dans ce cas, lancez le programme depuis le debuggueur sans mettre
de points d'arr\^et et examinez le rapport de \verb|bt|
pour voir la fonction fautive, remontez dans les appels avec \verb|f|
et visualisez la valeur des param\`etres au moment de l'erreur
de segmentation. 
\item Vous pouvez corriger une erreur dans la fen\^etre d'\'edition,
recompiler le programme et revenir dans la fen\^etre \verb|gdb|
(c'est le buffer nomm\'e \verb|*gud-a.out*|) puis reprenez
ce mode d'emploi \`a l'\'etape 5
(relancer l'ex\'ecution du programme en tapant \verb|r|, etc.).
\item Pour quitter le d\'eboggueur, tapez \verb|q| (quit)
ou fermez le buffer \verb|*gud-a.out*| 
(activez ce buffer et choisissez \verb|Close|
dans le menu \verb|Files|)
\end{enumerate}

Remarques: 
\begin{itemize}
\item Les variables de type structur\'e ou les classes
s'affichent comme des structurs C, m\^eme si vous avez red\'efini
l'op\'erateur \verb|<<|. Pour afficher une variable avec \verb|<<|,
il est judicieux de pr\'evoir une m\'ethode:\\
\verb|void dbgprint() const { cout << *this << endl; }|\\
On peut alors visualiser une variable \verb|x| du type consid\'er\'e
en tapant\\ 
\verb|print x.dbgprint()|\\
Pour automatiser tout cela,
cr\'eez un fichier nomm\'e \verb|.gdbinit| et contenant\\
\verb|echo Defining v as print command for class types\n|\\
\verb|define v|\\
\verb|print ($arg0).dbgprint()|\\
\verb|end|\\
Dans la session \verb|gdb|, tapez \verb|v x| pour visualiser le contenu
de la variable \verb|x|.
\item Parmi les autres possibilit\'es int\'eressantes de gdb, il y a la 
modification du contenu d'une variable en cours
d'ex\'ecution (commande \verb|print variable=valeur|)
On peut aussi interrompre
le programme seulement si une condition est v\'erifi\'ee
(\verb|break .. if ..|).
\item Pour plus d'informations, vous pouvez taper \verb|help| dans la fen\^etre
du debuggueur pour obtenir l'aide en ligne ou \`a tout moment dans
\verb|emacs|, en tapant \verb|Ctrl-H I|, puis
\verb|Ctrl-S gdb| puis clic de la souris avec le bouton du milieu sur
\verb|gdb|.
\end{itemize}

\section{Quelques conseils}

Pour obtenir des programmes lisibles il faut essayer (m\^eme lors de la
cr\'eation de programmes assez brefs) de repecter les
r\`egles suivantes:
\begin{itemize}
\item Ne pas \'ecrire plus d'une instruction par ligne
\item Utiliser des noms de variables, fonctions ...  qui ont un sens 
\item Indenter correctement les lignes (l'indentation est
  automatique sous ``emacs''avec la touche de tabulation)
\item Laisser (de fa\c{c}on non al\'eatoire si possible) des lignes blanches
\item Mettre les accolades fermantes sur une ligne \`a part.
\item Commenter les programmes
\item Lors de la conception d'un programme, dans la mesure du possible, 
on essaiera d'estimer le co\^ut de l'algorithme utilis\'e. Un algorithme 
inefficace peut en effet rendre un programme inutilisable.
Sur les syst\`emes GNU/Linux, il est possible de ``profiler''\index{profiler} 
les programmes de fa\c{c}on \`a \'etudier l'utilisation du temps machine 
lors de l'ex\'ecution du programme. Pour 
ce faire il faut compiler en utilisant l'option 
{\tt -pg} (voir {\tt man  gprof}). 
\item Eventuellement utiliser la modularit\'e du langage C pour cr\'eer et
compiler s\'epar\'ement des modules (`sous-programmes´) de taille
convenable (on peut automatiser la compilation en utilisant \verb|make|).
Lire la documentation de automake, autoconf, autoheader ou utilisez
un logiciel de d\'eveloppement comme \verb|kdevelop| pour cr\'eer
un projet.
\end{itemize}  

\pagebreak

\section{TP 6}
(statistiques \`a une variables)
D\'eterminer la moyenne, l'\'ecart-type, la m\'ediane, le premier et 
troisi\`eme quartile d'une
s\'erie statistique. On pourra utiliser la fonction de tri 
\verb|sort(v.begin(),v.end());| pour trier le vecteur de donn\'ees.

(g\'en\'etique, exercice fastidieux!) 
\'Ecrire une fonction convertissant 3 codes de bases en un code de prot\'eine.
Renvoyer le codage de la prot\'eine correspondante \`a une chaine d'ARN.\\
{\tiny
\begin{tabular}{|c||c|c|c|c||c|}
\hline
 & U & C & A & G & \\
\hline\hline
U &
  \begin{tabular}{ccc}
  UUU & Phe & [F] \\
  UUC & Phe & [F] \\
  UUA & Leu & [L] \\
  UUG & Leu & [L] \\
  \end{tabular}
&
  \begin{tabular}{ccc}
  UCU & Ser & [S] \\
  UCC & Ser & [S] \\
  UCA & Ser & [S] \\
  UCG & Ser & [S] \\
  \end{tabular}
&
  \begin{tabular}{ccc}
  UAU & Tyr & [Y] \\
  UAC & Tyr & [Y] \\
  UAA & \multicolumn{2}{c}{\em STOP} \\
  UAG & \multicolumn{2}{c}{\em STOP} \\
  \end{tabular}
&
  \begin{tabular}{ccc}
  UGU & Cys & [C] \\
  UGC & Cys & [C] \\
  UGA & \multicolumn{2}{c}{\em STOP} \\
  UGG & Trp & [W] \\
  \end{tabular}
&
  \begin{tabular}{ccc}
  U \\
  C \\
  A \\
  G \\
  \end{tabular}
\\ \hline
C &
  \begin{tabular}{ccc}
  CUU & Leu & [L] \\
  CUC & Leu & [L] \\
  CUA & Leu & [L] \\
  CUG & Leu & [L] \\
  \end{tabular}
&
  \begin{tabular}{ccc}
  CCU & Pro & [P] \\
  CCC & Pro & [P] \\
  CCA & Pro & [P] \\
  CCG & Pro & [P] \\
  \end{tabular}
&
  \begin{tabular}{ccc}
  CAU & His & [H] \\
  CAC & His & [H] \\
  CAA & Gln & [Q] \\
  CAG & Gln & [Q] \\
  \end{tabular}
&
  \begin{tabular}{ccc}
  CGU & Arg & [R] \\
  CGC & Arg & [R] \\
  CGA & Arg & [R] \\
  CGG & Arg & [R] \\
  \end{tabular}
&
  \begin{tabular}{ccc}
  U \\
  C \\
  A \\
  G \\
  \end{tabular}
\\ \hline
A &
  \begin{tabular}{ccc}
  AUU & Ile & [I] \\
  AUC & Ile & [I] \\
  AUA & Ile & [I] \\
  AUG & Met & [M] \\
  \end{tabular}
&
  \begin{tabular}{ccc}
  ACU & Thr & [T] \\
  ACC & Thr & [T] \\
  ACA & Thr & [T] \\
  ACG & Thr & [T] \\
  \end{tabular}
&
  \begin{tabular}{ccc}
  AAU & Asn & [N] \\
  AAC & Asn & [N] \\
  AAA & Lys & [K] \\
  AAG & Lys & [K] \\
  \end{tabular}
&
  \begin{tabular}{ccc}
  AGU & Ser & [S] \\
  AGC & Ser & [S] \\
  AGA & Arg & [R] \\
  AGG & Arg & [R] \\
  \end{tabular}
&
  \begin{tabular}{ccc}
  U \\
  C \\
  A \\
  G \\
  \end{tabular}
\\ \hline
G &
  \begin{tabular}{ccc}
  GUU & Val & [V] \\
  GUC & Val & [V] \\
  GUA & Val & [V] \\
  GUG & Val & [V] \\
  \end{tabular}
&
  \begin{tabular}{ccc}
  GCU & Ala & [A] \\
  GCC & Ala & [A] \\
  GCA & Ala & [A] \\
  GCG & Ala & [A] \\
  \end{tabular}
&
  \begin{tabular}{ccc}
  GAU & Asp & [D] \\
  GAC & Asp & [D] \\
  GAA & Glu & [E] \\
  GAG & Glu & [E] \\
  \end{tabular}
&
  \begin{tabular}{ccc}
  GGU & Gly & [G] \\
  GGC & Gly & [G] \\
  GGA & Gly & [G] \\
  GGG & Gly & [G] \\
  \end{tabular}
&
  \begin{tabular}{ccc}
  U \\
  C \\
  A \\
  G \\
  \end{tabular}
\\ \hline \hline
\end{tabular}
}

(g\'en\'etique) On se donne un tableau de 16 r\'eels indic\'e horizontalement
et verticalement par les lettres de base A, C, G, T.
Chaque r\'eel correspond \`a un ``poids''
que l'on donne si les lettres correspondantes se trouvent sur 2 chaines
d'ADN, on mettra par exemple un poids positif si les lettres sont
\'egales et n\'egatif sinon. \'Ecrire une fonction calculant le poids
total obtenu en sommant tous ces poids pour les caract\`eres de deux
chaines de m\^eme longueur. Ceci servira ensuite \`a comparer une chaine
\`a des chaines connues en trouvant la plus proche.

(maths-g\'en\'etique +)
Le th\`eme est math\'ematique mais la m\'ethode de programmation est
extr\`emement utilis\'ee en s\'equen\c{c}age.
Le nombre de combinaisons de $p$ \'el\'ements parmi $n$ est not\'e
$\left(^n_p\right)$. On rappelle les relations:
\[ \left(^{n+1} _{p+1}\right)= \left( ^n_p \right) + \left( ^n_{p+1} \right),
\quad \left(^n_0\right)=1, \left(^n_n\right)=1
\]
Ceci donne un algorithme de calcul de $\left(^n_p\right)$ appel\'e
triangle de Pascal. Les $\left(^n_p\right)$ seront \'ecrits \`a
la $n$-i\`eme ligne, $p$-i\`eme colonne d'un tableau. On commence
par \'ecrire la 1\`ere ligne qui ne contient que 1. Puis chaque ligne
s'obtient de la fa\c{c}on suivante:
\begin{itemize}
\item on commence la ligne par un 1 qui correspond \`a $p=0$
\item ensuite on obtient une valeur en additionnant deux valeurs
de la ligne pr\'ec\'edente: celle de la m\^eme colonne
situ\'ee juste au-dessus et celle de la colonne pr\'ec\'edente situ\'ee
juste au-dessus
\item On termine par un 1 qui correspond \`a $p=n$.
\end{itemize}
Par exemple, on obtient les lignes suivantes:
\begin{verbatim}
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
\end{verbatim}
Ecrire un programme mettant en oeuvre cet algorithme.


\end{document}

