/conf Csharp/tp/TP_Simple/sujet.tex

%Version en ligne
\documentclass[12pt,a4paper]{report}
\newcommand{\caml}{\textsc{Caml}}
%Version imprimable
%\documentclass[12pt,a4paper,twoside,openright]{report}

\input{config}

\begin{document}

\title{
  \vspace{1cm}
  \textbf{\Huge{\Tp{} \workshoptitle}}\\
  %\vspace{1cm}
  %\includegraphics[scale=0.75]{images/logo.png}
}
\author{
  \Large{S�bastien \textit{AzrYel} \textsc{Crozet} ({\ttfamily crozet\_s})}\\\\
}

\date{
  \vspace{1cm}
  % GConfs logo
  \includegraphics[scale=0.5]{\baserelTPpath/images/gconfs.png}\\
  \vspace{0.5cm}
  Day xx Month 201x
}
\maketitle
\newpage
\tableofcontents
\newpage

% beginning of document
\section{Introduction}
\subsection{Environnement de Travail}
\begin{itemize}
\item Lancer Visual Studio 2008
\item Fichier / Nouveau / Projet / C\# / Application console
\item Une portion de code minimale sera g�n�r�e:
\end{itemize}
\begin{lstlisting}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        { 
        }
    }
}
\end{lstlisting}		
Vous venez de mettre en place votre environnement de travail. Il est compos� de plusieurs fichiers.
Parmi ceux-ci, seul un nous int�resse pour le moment: Program.cs\\
De nombreux autres fichiers seront g�n�r�s tels que des fichiers contenant des informations de d�bogage.\\
Un fichier est toutefois important: ControleApplication1.sln. Il s'agit du fichier que vous devrez ouvrir si vous fermez puis r�-ouvrez VS2008. En effet,
il contient toutes les information concernant votre projet. (En r�alit�, il repr�sente une "solution", et vous trouverez aussi un fichier ConsoleApplication1.csproj qui repr�sente un "projet".
De ce fait vous pouvez avoir plusieurs "projets" dans une solution, mais ce n'est pas important pour ce TP).\\
\\
Comme vous pouvez le voir, le fichier Program.cs contient une fonction "Main". Il s'agit du point d'entr�e de l'application: la premi�re fonction appel�e automatiquement lors du d�marrage de votre programme.\\
C'est donc ici que tout commence et que vous ferez des appels � d'autres fonctions. Par la suite, nous allons �crire d'autres fonctions que vous devrez tester. Vous les �crirez dans ce fichier, mais gardez en t�te qu'il
est parfois pr�f�rable de travailler dans plusieurs fichiers s�par�s.
\subsection{Hello World !}
Comme tout bon tutoriel qui se respecte, la premi�re chose � vous faire
faire est d�afficher Hello World!. Pour cela il vous faudra utiliser la proc�dure
Console.WriteLine( ). Tous les param�tres donn�s seront
convertis en cha�ne de caract�res (pour les types pr�d�finis) puis
affich�s sur la sortie standard.
Dans un premier temps nous allons le placer dans le fichier Program.cs, et compl�ter la fonction Main(string[] args).
\begin{lstlisting}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello world");
            Console.ReadLine();
        }
    }
}

\end{lstlisting}
\emph{- Remarque }La fonction ReadLine() va attendre que l'utilisateur appuie sur
Entr�e. Cela permet que le programme ne s'arr�te pas directement mais nous
laisse le temps de lire notre Hello World!
\subsection{Voir le r�sultat de votre travail!}
Coder c'est bien, mais �a ne sert � rien si on ne peut pas ex�cuter le fruit de son travail! Vous allez donc compiler votre code.\\
Visual Studio vous permet de compiler tr�s intuitivement et facilement si vous ne souhaitez pas d'options particuli�res. D'ailleurs, vous avez surement devin� que pour compiler il faut utiliser la petite fl�che verte dans la barre d'outils! Eh bien ce n'est pas tout � fait exact, ce bouton fera deux choses pour vous: la compilation et l'ex�cution.
Ainsi, si vous cliquez sur ce bouton, vous verrez au bout d'un moment votre console affichant "Hello World". Il est toutefois possible de compiler SANS ex�cuter le programme automatiquement.
Pour cela, choisissez le menu "G�n�rer -- G�n�rer la solution". Compiler sans ex�cuter est utile si vous souhaitez juste voir les messages d'erreurs, ou v�rifier que tout compile.\\
Toutefois, utiliser les boutons devient rapidement p�nible. Il existe donc deux raccourcis: F5 pour compiler+ex�cuter et F6 pour compiler uniquement.\\
Faites donc un F5 et regardez le r�sultat!
\subsection {Premi�re Fonction}
Votre premi�re fonction va �crire Hello World! sur la sortie. Vous devrez
la placer dans le fichier Program.cs en dehors de la fonction Main(), mais � int�rieur de la classe (d�limit�e par des accolades \{ \}) Program.
Votre fonction ressemblera � la fonction Main actuelle, mais sans arguments.\\
Toute fonction a un type de retour: int, float, string, etc... Toutefois, une fonction n'est pas toujours oblig�e de renvoyer quelque-chose!
Elle peut donc renvoyer 'rien', c'est � dire 'void'. Une telle fonction est usuellement appel�e "proc�dure".\\
Lorsque vous d�clarez une fonction, vous lui donnez donc: des attributs, un type, un nom, des param�tres, un contenu (le code ex�cut� lorsqu'elle est appel�e).
Pour le moment, nous ne ferons pas attention aux attributs et mettrons 'static' qui signifie que cette fonction peut �tre appel�e sans avoir � cr�er un objet.\\
Voici donc, � quoi devrait ressembler votre proc�dure HelloWorld():
\begin{lstlisting}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;  

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
        }

        static void HelloWorld()
        {
            Console.WriteLine("Hello world");
            Console.ReadLine();
      }
   }
}

\end{lstlisting}
Maintenant que nous avons cod� la fonction il faut l'appeler, c'est dans
le Main que vous allez le faire. Celui-ci va donc contenir :
\begin{lstlisting}
static void Main(string[] args)
       {
            HelloWorld();
        }
\end{lstlisting}
Bravo, vous �tes maintenant pr�ts � coder des fonctions plus compliqu�es !

\section{Factorielle}
\subsection{D�finition de Factorielle}
Pour une gestion plus simple des cas d�erreurs nous allons imposer une
d�finition de factorielle sp�ciale qui vaut 1 pour des nombres n�gatifs.\\

\begin{center}
\begin{math}
n! = \left\{
    \begin{tabular}{ccc}
        1 & si & n <= 1\\\\
        n * (n - 1)! & si & n > 1
    \end{tabular}
\right. 
\end{math}
\end{center}


Afin de pouvoir tester votre code, voici quelques exemples.\\

\begin{center}
\begin{tabular}{|c|c|c|c|c|c|c|c|c|}
\hline
\textbf{n} & -42 & -1 & 0 & 1 & 2 & 3 & 5 & 10\\
\hline
\textbf{n!} & 1 & 1 & 1 & 1 & 2 & 6 & 120 & 3628800\\
\hline
\end{tabular}
\end{center}


\helpbox{Aide}{lorsque vous aurez � choisir des exemples par vous m�me par
la suite, veillez � bien prendre en compte tous les cas particuliers (et � les
impl�menter) ! Ici il ne faut pas oublier les nombres n�gatifs, ni 0, ni 1.}
\subsection{Version Recursive}
Nous allons d�buter par une version r�cursive de la fonction qui � d�j� �t�
vue en \caml{}. Il s�agit d��crire le code C\# qui va retranscrire � la lettre la
formule math�matique.
\begin{lstlisting}
static int fact(int n)
{
}
\end{lstlisting}
\emph{Syntaxe: } Pour r�aliser des alternatives vous devez utiliser la structure
\begin{lstlisting}
if (Condition)
{
Action1();
}
else
{
Action2();
}
\end{lstlisting}
Si la Condition est �gale � vrai alors l�Action1 est effectu�e, sinon c�est
l�Action2 qui l�est.
\subsection{Version Imp�rative - While}
Nous allons transcrire cette fonction en imp�ratif. Nous allons utiliser des boucles
pour simuler les appels r�cursifs. Il existe plusieurs types de boucles mais la
plus simple pour commencer reste la boucle While.
\begin{lstlisting}
static int fact_while(int n)
{
}
\end{lstlisting}
\emph{Syntaxe: } La boucle while s�utilise de cette fa�on :
\begin{lstlisting}
while (Condition) 
{
Action;
}
\end{lstlisting}
Tant que la Condition est v�rifi�e, alors on effectue l�Action. Avec la Condition
�tant une expression de type bool.\\
Par exemple le code suivant va afficher
les nombres de i � 0.
\begin{lstlisting}
while (i>=0) 
{
      Console.WriteLine(i);
      i--; // ou bien i = i - 1;
}
\end{lstlisting}
\subsection{Version Imperative - For}
Maintenant que vous avez r�ussi � retranscrire gr�ce � la boucle While la
fonction factorielle, nous allons utiliser la boucle For. Lorsque l�on connait
le nombre d�it�rations � l�avance elle est plus pratique � utiliser.
\begin{lstlisting}
static int fact_for(int n)
{
}
\end{lstlisting}

\emph{Syntaxe: } La boucle For s�utilise de cette fa�on :
\begin{lstlisting}
for(int i=0; i < 10; i++)
{
      action;
}
\end{lstlisting}
Pour comprendre son fonctionnement, on peut la r��crire avec une boucle
While. Vous remarquerez la concision de la boucle for.
\begin{lstlisting}
int i = 0;
while (i < 10) 
{
      action;
      i++; // ou bien i = i + 1;
}
\end{lstlisting}
\section{Point 2D}
\subsection{Type - Structure}
Nous allons apprendre � cr�er un nouveau type : un vecteur math�matique.
Il comporte deux coordonn�es repr�sent�es par deux champs dans notre
structure.
\begin{lstlisting}
struct Point2D
    {
        public int x;
        public int y;
    }
\end{lstlisting}
Vous pouvez placer cette d�finition � deux endroits: avant la d�claration de la classe Program, ou
dans un fichier s�par�. Le plus propre est encore de le faire dans un fichier s�par�.\\
Si toutefois, vous souhaitez le mettre dans le m�me fichier que votre Main, vous devrez le placer dans la partie "namespace", 
mais avant la d�claration "class Program". Vous obtiendrez ceci:
\begin{lstlisting}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;  

namespace ConsoleApplication1
{

    struct Point2D
    {
        public int x;
        public int y;
    }

    class Program
    {
        static void Main(string[] args)
        { /* du code ici */   }

        // d'autres fonctions ici 
    }

}

\end{lstlisting}
\emph{Utilisation: } Son utilisation est tr�s simple. Il vous suffit de d�clarer une
variable du type \textbf{Point2D}. Ensuite pour acc�der � chacun des champs il vous
suffit de mettre un \textbf{.} devant son identifiant. Remarquez l'attribut "public" devant chaque d�finition de variable
de la structure \textbf{Point2D}. Cela signifie que vous donnez � tout votre code le droit de lire et modifier les champs (i-e x et y)
de la structure. En g�n�ral, c'est une pratique � �viter car cela brise certains principes li�s � la Programmation Orient�e Objet.
Toutefois, ici notre structure est tr�s simple, donc pour plus de simplicit�, nous conserverons l'attribut public.
\begin{lstlisting}
Point2D pt;
pt.x = 0;
pt.x = pt.x + 1; // ou bien pt.x++
Console.WriteLine(pt.x);
// Affiche 1
\end{lstlisting}
\subsection{Afficher un Point2D}
La premi�re chose � faire avant de coder quoi que ce soit est de s�assurer
que l�on peut afficher ce que l�on est en train de faire. Nous allons donc r�aliser
une fonction qui prend un \textbf{Point2D} en param�tre, par exemple ${x = 12 \choose y = ?5}$,
et qui affiche dans la console:\\

\begin{verbatim}
x=12 ; y=-5
\end{verbatim}

\begin{lstlisting}
static void print_pt2d(Point2D p)
{
}
\end{lstlisting}
\warnbox{Attention}{lorsque l�on vous demande d��crire quelque chose dans la
sortie vous devez respecter le format � la lettre ! Pas d�espace autour du
�=�, les deux sur une m�me ligne ... Lorsque vous serez corrig�s par une
moulinette, la moindre faute de syntaxe vous vaudra 0.}
\subsection{Addition}
Passons aux choses s�rieuses. Vous devez coder l�addition de deux vecteurs,
inutile de vous donner la formule ...
\begin{lstlisting}
static Point2D add_pt2d(Point2D pa, Point2D pb)
{
}
\end{lstlisting}
\subsection{Oppos�}
En pr�vision de la fonction de soustraction, nous allons coder une fonction
qui donne l�oppos� d�un Point2D, c�est � dire l�oppos� de tous les champs.
Par exemple:
\begin{center}
\begin{math}
-{x = 2 \choose y = -5} = {x = -2 \choose y = 5}
\end{math}
\end{center}
\begin{lstlisting}
static Point2D opp_pt2d(Point2D pa)
{
}
\end{lstlisting}
\subsection{Oppos� par r�f�rence}
Il faut savoir que lorsque l�on retourne un type structur� par une fonction,
tous les champs sont recopi�s dans une nouvelle variable. M�me si dans cet
exemple ce n�est pas important, lorsque ces op�rations sont effectu�es des
millions de fois par seconde, toute optimisation, m�me aussi mineure que
celle-ci, est bonne � prendre.
La m�thode pour palier ce probl�me est le passage par r�f�rence. En effet,
la variable est directement modifi�e et non copi�e. Par contre il n�est plus
possible d�utiliser l�ancienne variable.

\begin{lstlisting}
static void opp_pt2d(ref Point2D pa)
{
}
\end{lstlisting}
\subsection{Soustraction avec Oppos�}
Maintenant que vous avez les deux fonctions Addition et Oppos�, il va
faloir les combiner afin de coder la fonction Soustraction.
\begin{lstlisting}
static Point2D sub_pt2d(Point2D pa, Point2D pb)
{
}
\end{lstlisting}
\subsection{Distance}
Il est possible � partir de vecteurs d�obtenir d�autres types que des vecteurs.
Par exemple on peut calculer la distance entre deux vecteurs qui est
un r�el.\\

\begin{center}
\begin{math}
dist({x1 \choose y1} , {x2 \choose y2}) = \sqrt{(x2 - x1)^{2} + (y2 - y1)^{2}}
\end{math}
\end{center}


\begin{lstlisting}
static float dist_pt2d(Point2D pa, Point2D pb)
{
}
\end{lstlisting}	
\helpbox{Remarque}{il existe plusieurs repr�sentations des nombres r�els en C\#.
Les plus couramment utilis�s sont les float. Les double permettent de stocker de plus grandes valeurs.}\\
\helpbox{Aide}{Vous devrez utiliser la fonction racine carr�e suivante : \textbf{Math.sqrt()}}
\section{Bonus}
Bravo, vous avez termin� le TP guid�, voici quelques exercices bonus pour
parfaire vos notions de C\#.
\subsection{Un g�n�rateur de particules!}
% end of document
\end{document}