/*******************************************************************************
author: Pierre-Emmanuel Périllon
date: 30/05/2007
encoding: utf8
level: beginner+
langage: C++ (without class), comments in french
licence: Creative common by+nc+sa. see http://creativecommons.org/
website: http://tutorat.univ-lyon1.fr/
build: g++ -Wall if3_2006_janvier.cpp -o out
********************************************************************************


PARTIE 1************************************************************************
(source:wikipédia)

DEFINITION D'UNE FONCTION ------------------------------------------------------

En informatique, une fonction est un ensemble d'instructions réalisant une
certaine tâche. On utilise parfois le synonyme routine, notamment à propos des
fonctions bas-niveau des systèmes d'exploitation.

Une fonction prend zéro, un ou plusieurs paramètres et renvoie toujours un
résultat. Si elle ne renvoie aucun résultat, c'est une procédure.

En programmation orientée objet, une fonction membre d'un objet est désignée
par le terme de méthode.

Les fonctions réalisant des tâches similaires et dont l'objectif est d'être
réutilisées par plusieurs programmes sont regroupées dans des bibliothèques.

Un paradigme de programmation dans lequel toute l'application est vue comme un
ensemble de fonctions qui s'enchaînent et s'appellent mutuellement est dit
fonctionnel.

Une fonction en informatique se distingue principalement de la fonction
mathématique par le fait qu'en plus de calculer un résultat à partir de
paramètres, la fonction informatique peut avoir des effets de bord : par
exemple afficher un message à l'écran, jouer un son, ou bien piloter une
imprimante.

Une fonction qui n'a pas d'effets de bord, et qui renvoie systématiquement la
même valeur de retour pour les mêmes paramètres, est appelée fonction pure.


DEFINITION D'UNE PROCEDURE -----------------------------------------------------

En informatique, une procédure est une fonction qui ne renvoie pas de résultat
significatif.



DEFINITION D'UNE VARIABLE ------------------------------------------------------

Une variable associe un nom, c'est à dire un symbole, à une valeur
éventuellement changeante au cours du temps.

Dans les langages comme le C,C++ (java, php...) la variable regroupe les
dimentions suivantes:
-> son nom qui est transparent pour l'algorithme
-> sa valeur, l'information stockée
-> son adresse, lieu physique ou est stocké l'information,
-> son type qui caractérise la quantité de mémoire que la variable représente,
ainsi que la convention d'interprétation de la valeur,
-> sa portée, c'est a dire dans quelles parties de l'algorithme la variable
existe (durée de vie)
-> sa visibilité, c'est à dire si la variable est accessible (static en C,
private/protected/public en C++).

la variable sert à stoquer des données variables.

exemple d'utilisation:
int a;
a = 12;


DEFINITION D'UNE STRUCTURE -----------------------------------------------------

En informatique, une structure de données est une structure logique destinée à
contenir des données, afin de leur donner une organisation permettant de
simplifier leur traitement. Une structure de données implémente concrètement un
type abstrait.

En C, la structure permet de grouper plusieurs variables de types différents
sous un même nom afin de simplifier l'emploi de celle-ci.

typedef struct
{
double r;
double b;
double v;
} Couleur;

struct Pixel
{
double x;
double y;
struct Couleur color;
};

// utilisation
Couleur e;

e.r=0.7
e.b=0.8
e.v=0.9

struct Pixel zz;
zz.x= 9.5;
zz.y = 7.6;
zz.color.r = 0.1;
zz.color.v = 0.2;
zz.color.b = 0.3;
zz.color = e; //on peut aussi...

DEFINITION D'UN TABLEAU --------------------------------------------------------

Un tableau est une structure de données de base qui est un
ensemble d'éléments (des variables ou autres entités contenant des données),
auquel on a accès à travers un numéro d'index (ou indice).

On peut aligner plusieurs variables dans un tableau, à la condition qu'elles
soient de même types, ce type pouvant un type complexe (par exemple une
structure).

// définition d'un tableau à deux dimentions représentant un écran...
Couleur ecran[1024][768];

//mettre un point rouge au milieu
ecran[512][384].r =1.0;
ecran[512][384].v =0.0;
ecran[512][384].b =0.0;


PARTIE 2************************************************************************
*/
#include <iostream>
using namespace std;

/*
* no comments
*/
int max(const int a, const int b)
{
return (a>b)?a:b;
}

/*
* no comments
*/
int min(const int a, const int b)
{
if ( a > b)
return b;
else
return a;
}

/*
* ?
*/
int tabRechercheMax( const int tab[], const int taille )
{
int i;
int max = tab[0];
for ( i = 0 ; i < taille ; i++)
{
if ( tab[i] > max )
{
max = tab[i];
}
}
return max;
}

/*
* ?
*/
void tabSaisie( int tab[], const int taille )
{
int i = 0;
cout << "Entrez des valeurs"<<endl;
while ( i < taille )
{
cout << "(" << i + 1 << "/" << taille << ")?";
cin >> tab[i];
i = 1 + i;
}
cout <<"\t merci"<<endl;//\t c'est la tabulation
}

/*
* ?
*/
void tabAfficher( const int tab[], const int taille )
{
int i;
for ( i = 0 ; i < taille ; i++)
/* accolade facultative -> on arrete la boucle au prochain ';'*/
cout << "[" "#" << i <<": "<< tab[i] << "]";
cout << endl;
}



/*
PARTIE 3 ***********************************************************************
3.Q1
-> tri à bulle # on explique celui là
-> tri par selection..

l'idée est de prendre une case dans le tableau, la comparer avec la suivante et
permuter les deux valeurs si elle ne sont pas dans l'ordre désiré, le plus petit
ou plus grand élement va ainsi remonter vers une extrémité du tableau, comme une
bulle de champagne dans une flute.

l'algo se compose de deux parties:
une procédure pour faire remonter "la bulle",
une procédure pour itérer sur toutes les cases.

Q3 / on note l'usage abusif du mot fonction.
->void remonterBulle(int tab[], int taille)

on utilise des données-résultats avec un passage par "référence" des valeurs.
Les pointeurs n'étant pas au programme, on ne dit pas toute la véritée sur le
passage. Le passage par référence consiste à ne pas copier le tableau lors du
passage à la procédure de tri, mais seulement un code permetant de localiser
le tableau.
*/

/*
* ?
*/
void remonterBulle(int tab[], int taille)
{
int i;
int tmp;
for ( i = 0 ; i < (taille - 1) ; i++)
{
tmp = tab[i];
tab[i] = min( tab[i] , tab[i+1] );
tab[i+1] = max( tmp , tab[i+1] );
}

}

/*
* ?
*/
void trierBulle(int tab[], int taille)
{
int sousTab;
for ( sousTab = taille ; sousTab > 1 ; sousTab-- )
{
remonterBulle( tab , sousTab );
cout << taille - sousTab + 1 << ": ";
tabAfficher(tab, taille);
}
}


/*
* ?
*/
int main(){
int tab[10];
cout << "PARTIE 2 --------------------------" << endl;
tabSaisie(tab, 10);
cout << "le plus grand entier est "<< tabRechercheMax( tab, 10 ) << "." <<endl;

cout << "PARTIE 3 --------------------------" << endl;
cout << "tableau initial" << endl;
tabAfficher(tab, 10);
cout << "deroulement du tri" << endl;
trierBulle( tab , 10 );


return 0;
}