\documentclass[a4paper]{article}

\usepackage[T1]{fontenc}
\usepackage[latin1]{inputenc}
\usepackage[francais]{babel}

\usepackage[margin=2cm]{geometry}

\usepackage{alltt}
\usepackage{amssymb}
\usepackage{array}
\usepackage{url}

\newcommand{\cmm}{C$--$}



\title{TP 0 : Introduction}
\author{Gilles Peskine}
\date{4 octobre 2002}

\begin{document}

\maketitle

Les sujets, corrigés, etc., de TD et de TP seront placés au fur et à mesure
sur ma page web : \\
\url{http://para.inria.fr/~peskine/enseignement/deug-2002}.


\section{Utilisation des ordinateurs}
\subsection{Introduction}

Les ordinateurs de la salle de TP tournent sous FreeBSD, une variante d'Unix.
Vous aurez essentiellement affaire à l'interface KDE.

Avant de pouvoir travailler sur une machine, il faut vous identifier. La
machine demande un nom d'utilisateur (\verb$login:$) et un mot de passe
(\verb$password:$). Dans la salle de TP, il y a un compte commun appelé
\verb$me$ sans mot de passe.

Le principal logiciel à connaître est l'éditeur de textes \texttt{kwrite},
qu'il est vivement recommandé d'utiliser pour écrire les programmes.

Vous aurez aussi besoin de taper des commandes Unix. Pour cela, lancer une
fenêtre \emph{shell} (sous KDE, cliquer sur l'icône représentant un coquillage
devant un écran d'ordinateur).


\subsection{Utilisation de \texttt{kwrite}}

Regarder dans le menu les commandes proposées. Les plus utiles sont dans le
menu « Fichier » (« Nouveau » pour créer un fichier, « Ouvrir » pour éditer un
fichier existant, « Enregistrer » pour écrire le fichier modifié sur le disque
dur).

\texttt{kwrite} peut afficher les programmes C($--$) en couleurs. Pour cela,
utiliser l'entrée « Activer la surbrillance » dans le menu option, choisir
« C » ou « C++ ».

\subsection{Le shell Unix}

C'est un programme qui permet de taper des commandes qui sont exécutées dès
qu'on appuie sur la touche « entrée ». Voici quelques commandes utiles.

\begin{tabular}{>{\noextrasfrench\ttfamily}ll}
  ls -l &
  afficher la liste des fichiers dans le répertoire courant \\
  cp \textit{fichier-original} \textit{nom-de-la-copie} &
  faire une copie d'un fichier \\
  mv \textit{ancien-nom} \textit{nouveau-nom} & renommer un fichier \\
  rm \textit{fichier} & supprimer définitivement un fichier \\
  mkdir \textit{nom-de-répertoire} &
  créer un nouveau répertoire dans le répertoire courant \\
  cd \textit{répertoire} & changer de répertoire courant \\
  cd .. & aller au répertoire parent du répertoire courant \\
  rmdir \textit{répertoire} & supprimer un répertoire vide \\
  grep \textit{mot} \textit{fichier1} \textit{fichier2} \textit{...} &
  chercher un mot dans un ou plusieurs fichiers \\
\end{tabular}

\subsection{Utilisation des disquettes}

Les disques des salles de TP sont régulièrement effacés. Aussi il n'est pas
possible de conserver vos fichiers après la fin du TP. Si vous souhaitez
garder une trace de votre travail, vous pouvez \textbf{apporter des disquettes}.

Bref guide d'utilisation des disquettes : \\
\begin{tabular}{>{\noextrasfrench\ttfamily}ll}
  mdir a: &
  affiche la liste des fichiers sur la disquette \\
  mcopy toto a: &
  copie le fichier \texttt{toto} du disque dur vers la disquette \\
  mcopy a:toto . &
  copie le fichier \texttt{toto} de la disquette vers le disque dur \\
  mcopy toto a: &
  copie le fichier \texttt{toto} du disque dur vers la disquette \\
  mdel a:toto &
  efface le fichier \texttt{toto} de la disquette \\
\end{tabular}


\subsection{Développement \cmm}

L'objectif des TP sera d'écrire des programmes en \cmm, un sous-ensemble de
C++. Une fois le texte du programme écrit et \textbf{enregistré} dans un
fichier \verb$toto.C$, le cycle de production du programme sera le suivant :
\begin{enumerate}
\item
  \textbf{Vérifier} que le fichier est un programme \cmm\ correct. Ceci se
  fait en tapant la commande suivante dans une fenêtre shell :
  \begin{alltt}
g-- <toto.C
  \end{alltt}
\item
  Si \verb$g--$ n'a pas signalé d'erreur, \textbf{compiler} le programme,
  c'est-à-dire produire du code exécutable à partir du code source :
  \begin{alltt}
g++ -O -Wall -W -o toto toto.C
  \end{alltt}
\item Si \verb$g++$ n'a pas signalé d'erreur, \textbf{exécuter} le programme
      en tapant la commande suivante :
  \begin{alltt}
./toto
  \end{alltt}
\end{enumerate}

Attention à bien faire la différence entre majuscules et minuscules.

S'il y a des erreurs signalées, utiliser \texttt{kwrite} pour les corriger, et
recommencer le cycle vérification-compilation-exécution. Astuce : dans le
shell, on peut utiliser la flèche vers le haut pour rappeler les commandes
précédentes.


\section{Exercice : afficher « Bonjour ! »}

Taper ce programme dans un fichier nommé \verb$bonjour.C$. Lancer \verb$g--$
pour le vérifier, puis \verb$g++$ pour le compiler, et enfin \verb$./bonjour$
pour l'exécuter.

\begin{verbatim}
#include <iostream.h>
int main () {
    cout << "Bonjour !\n";
}
\end{verbatim}


\section{Exercice : puissance entière}

\begin{verbatim}
#include <iostream.h>
// Calcul de la puissance entière d'un réel
float puissance (float r, int n) {
    int i;
    float p = 1;
    for (i=1; i<=n; i++) p = p * r;
    return p;
}

int main () {
    float a;
    int n;

    cout << "Élévation à une puissance entière.\n";
    cout << "Donnez un nombre réel : "; cin >> a;
    cout << "Donnez la puissance : "; cin >> n;

    if (n<0) cout << "La puissance doit être positive.\n";
    else cout << a << " puissance " << n << " = " << puissance (a,n) << endl;
}
\end{verbatim}

\section{Exercice : soustraction de deux nombres en base 10}

\begin{verbatim}
#include <iostream.h>

int main () {
    int a, b, c, d; /* les entrees */
    int e, f;       /* les sorties */
    cout << "Programme qui effectue l'operation ab - cd\n avec a, b, c, d des chiffres \n";
    cout << "Introduisez le deux nombres, chiffre par chiffre :\n";
    
    /* lecture de a */  
    do {
        cout << "a (0..9) = ";
        cin >> a;
    } while ((a < 0) || (a > 9)); /* fin do */
    /* lecture de b */  
    do {
        cout << "b (0..9) = ";
        cin >> b;
    } while ((b < 0) || (b > 9)); /* fin do */
    /* lecture de c */  
    do {
        cout << "c (0..9) = ";
        cin >> c;
    } while ((c < 0) || (c > 9)); /* fin do */
    /* lecture de d */  
    do {
        cout << "d (0..9) = ";
        cin >> d;
    } while ((d < 0) || (d > 9)); /* fin do */
 
   /* algorithme de soustraction */
    cout << "Le resultat de " << a << b << " - " << c << d << " = ";
    if ((a > c) || ((a==c) && (b >= d))) {
        if (b >= d) {
            f = b - d;
            e = a - c;
        } else {
            f = (10 + b) - d;
            e = a - 1 - c;
        } /* fin if */
    } else {
        if (d >= b) {
            f = d - b;
            e = c - a;
        } else {
            f = (10 + d) - b;
            e = c - 1 - a;
        } /* fin if */
        cout << "-";
    } /* fin if */
    cout << e << f << "\n";
}
\end{verbatim}

\section{Ressources}

Sur l'utilisation d'Unix :
\begin{itemize}
\item 
  \url{http://www.eleves.ens.fr/tuteurs/}\quad Unix très bien expliqué ;
  recommandé même si certaines parties sont spécifiques à l'ENS. Lire
  notamment le glossaire.
\item
  \url{http://www.grbb.polymtl.ca/syst_info/cours_unix.html} Bien, mais un peu
  vieux.
\item
  \url{http://www.kde.org/fr/index.php} Le site francophone de KDE.
\end{itemize}

En outre, Unix dispose d'une documentation en ligne assez fournie. La commande
\texttt{man} affiche le manuel d'une commande, par exemple « \verb$man ls$ »
L'aide en ligne de KDE est accessible par le menu « Aide ».

\end{document}

%% LocalWords: Unix d'Unix FreeBSD KDE kwrite shell
%% LocalWords: TP