Eléments de base :
Qu'est ce que la programmation ?
L'art de transcrire un problème en une suite d'instruction compréhensible par l'ordinateur.
Les niveaux de programmation :
Assembleur : langage constitué du set d'instruction d'un processeur.
particulier à un type de processeur.
Compilteur : transformation d'un langage de haut niveau en assembleur
plus facile d'accès, indépendant du processeur.
Caractéristiques du C :
Langage structuré ( en blocs)
Langage déclaratif
Format libre (mise en page)
Langage modulaire
Langage compilé
Point d'entrée d'un programme :
Fonctiom main()
Commentaires : // ligne ; /*lignes*/
Instruction élémentaire bloc :
Syntaxe
instruction
commande
bloc
{
instruction 1
instruction 2
}
Un programme simple :
#include <iostream> // inclure
la libraire E/S
using namespace std; // necessaire pour les libraires STL
// affiche hello world
int main()
{
cout<<"hello world"<<endl;
}
Lecture de données :
cin >>i >> j ;
Les données :
Les nombres :
Nombres entiers : suite de chiffre ±
Nombre réels : comportent un . ±
Notation scientifique : 6.23 107 s'écrit 6.23E+7
Les caractères :
Encadré d'apostrophes 'a'
3 catégories utilisables : lettres, chiffre, caractères spéciaux
Les chaines de caractères (constantes)
Encadré de guillements " String"
La notion de variables :
Associe un nom a chaque valeur,
doit commencer par une lettre,
déclarée avant son utilisation
Déclaration d'une variable :
identificateur de type suivit du nom
identificateur :
int : variables entières
float : variables réelles (simple précision)
double : variables réelles (double précision)
char : variable de type de caractère
Affectation :
syntaxe : variable = expression;
stocke dans la variable la valeur de l'expression
int x; //déclaration de x
x = 3 ; // donne la valeur 3 à x
Déclaration et affectation combinées en une seule expression : int x = 3;
Affichage d'une variable :
int i;
i = 45 ;
cout<<"la valeur de i est : "<<i<<endl;
Une variable spéciale : string
Type chaine de caractère en C++
pour l'utiliser il faut une libraire string.
affectation :
#include <string>
using
namespace std;
int
main()
{
string s;
//déclaration de s
}
s = "hello
world"
char
c = S[0] // = h
char
c = S[4] // = o
cout<< s <<endl;
Les expressions mathématiques :
Expression : combinaison de valeurs numériques (constantes, invocation de fonction), de signes opératoires et parenthèses.
Opérateur disponible : +, -, *, /, %
Abreviation :
J = j + 4 à J += 4
x* = y + 2 à x*(y + 2)
Incrémentation :
Deux opérateurs uniaires : ++ , -- ( j++ à j+1)
Autre opération mathématique :
Diponible en utilisant des bibliothéques mathématique (math)
#include<math.h>
int main()
{
double x = sqrt(100) ;// racine carrée
double y = x * sin(0.4) + cos(-0,4);
}
Booléens :
Pas de variables booléennes en C , = 0 est vrai, !=0 est faux
Résultat de l'opération logique vaut 0 ou 1.
En C++ :
Type : bool
Operateurs logiques
&& : et
|| : ou
! : non
Expression booléenes : contenant plusieurs opérateurs logiques
Priorité des opérateurs : ! à && à || et de gauche à droite.
Les opérateurs relationnels : >, >=, <, <=, ==, !=
Les expressions booléennes simples : doivent être de même type,
sinon conversion de type implcite ( qui change le résultat attendue)
Nouveaux Types :
Syntaxe : typedef type_existant nom_type;
exemple : typedef long int grand_entier_t ;
Type par énumération :
défini une liste d'identificateur ou labels.
Associe valeur entière aux labels.
Par défaut, le 1er label = 0, les suivants sont incrémentés de 1 en 1.
Syntaxe : typedef enum {liste_def_label} nom_type;
! Les valeurs de la liste sont des entiers et pas des chaines de caractères.
Impossible de lire ou d'afficher comme chaine de caractères.
Un même label ne pas figurer dans deux enum différents.
Les pointeurs :
Variable contenant l'adresse mémoire d'une
autre variable.
Une variable a 2 attributs :
la valeur qui lui est associée
l'endroit de la mémoire ou elle est rangée (=adresse mémoire)
Déclaration de pointeur et type :
syntaxe : type*
nom_pointeur
Type pointeur = type de variable dont il contient l'adresse.
int a =5 ;
int*pa;
float
f =1.23f;
float*pf;
pa = &a; // pa pointe vers la variable a
*pa += 3 // = a + 3 donc a = 8
Constante NULL
valeur particulière pour pointeur ne pointant
nulle part.
float f =1.23f;
float*pf= NULL; //mis en attente, inutilissable
pf = &f //ok
cout
<< *pf << endl;
Initialisation des pointeurs :
Comme pour les autre variables…
Comparaison de pointeur :
Les opérateurs relationnels restent valides.
Erreurs communes :
Oubli de l'initialisation de l'adresse mémoire avant l'utilisation du pointeur
Instruction de contrôle :
if()…else :
syntaxe : if (expression booléenne )
{bloc
1}
else
{bloc 2}
Teste un condition, effectue sélectivement un bloc d'instructions
peut très bien être imbriquée.
switch :
syntaxe
: switch(variable_entière)
{
case valeur1 :
break;
case valeur 2 :
//liste
d'instructions
break;
// …
default :
//
liste d'instructions
break;
}
Permet de réaliser un choix multiple,
une action associée aux valeurs de la variable de type int, char, long int, …
L'instruction break peut être omise ou remplacée par return()
en l'absence de break ou return() : les actions associées aux case suivants seraont aussi exécutées.
Cas spécial : default :
facultatif, emploi similaire aux "case" mais sans valeur.
figure nécessairememnt après tous les "cases"
est activé lorsque tous les "cases" échouent.
Permet générallement d'indiquer un problème.
Différence entre if else et switch :
switch() : ne teste pas les condition l'une après l'autre,
fonctionne avec des variables entières seulement.
While :
syntaxe : while
(expressions booléenne)
{bloc}
ou :
do {bloc}
while
(expressions booléennes);
Le bloc d'instruction est exécuté tant que la condition est vraie.
différence while et Do while :
Avec Do while : l'expression est au mooins exécutée une fois.
For :
syntaxe : for (
expression initiale ; expression booléenne; expression d'itération)
{bloc a exécuter}
Evalue l'expression initiale :
répète :
le test de l'expression booléenne
l'execution du bloc tant que la condition est vérifiée
l'execution d'itération après chaque bloc
Fonction et décomposition d'un programme :
Le langage c est un langage modulaire :
regroupement de fonctionnalités par module ( décopage en sous problème)
2 types de sous routine :
fonction : retourne une valeur au programme appelant par l'instruction return()
procédure : identique aux fonctions mais ne retourne pas de valeur, void.
Déclaration, définition, références :
déclaration : indication du prototype de la fonction (type, parametre)
définition : indique l'implémentation de la fonction
Références : appel de la fonction depuis un bloc de contrôle.
#include " ou < ?
Les #include peuvent utiliser 2 types de notations
"fileheader.h" : définie explicitement le chemin ou trouver le fichier fileheader.h
<fileheader.h> : recherche le fichier dans les répertoires systèmes
Déclaration de sous-routine : (fonctions ou procédure)
Similaire au cas des variables, doit se faire avant la référence de la sous-routine
En utilisant des types existants int,float,void,… ou personnel
type nomProcedure();
Exemples :
déclaration d'une procédure :
void ecrire_message();
déclaration d'une fonction retournant un booléen :
bool ecrire_message();
Exemple résolution d'une série d'équations du 2nd degré.
ax2 + bx + c = 0
On doit lire les coeddicients a,b,c
Résoudre l'équation et afficher la solution
La condition d'arrêt : a == 0
Algorithme :
Lire les 3 coefficients
Tant qu'il y a une équation à trait (a ≠ 0)
Calculer la ou les solutions
Calculer delta = b2 – 4.a.c
en déduire s'il y a 0,1,2 solutions réelles
si delta < 0 : pas de solution
si delta = 1 : 1 solution
si delta = 2 : 2 solutions
Lire les 3 coefficients.
Résolution :
#include<iostream>
#include<math.h>
using
namespace.std;
int a,b,c;
void lire_coefs()
{
cin >>a >> b >>c;
}
bool
y_a_equation()
{
return
(a!=0);
}
int
calculer_delta()
{
return(b*b
– 4*a*c);
}
void ecrire_message()
{
cout <<"Pas de solution !"<<endl;
}
void solution_unique(){
float x = (-1.0*b)/(2.0*a);
cout <<"La solution est :"<<x<<endl;
}
void solution_double()
{
float x1 = (-1.0*b – sqrt((double)calculer_delta())) / (2.0*a);
float x2 = (-1.0*b + qrt((double)calculer_delta())) / (2.0*a);
}
void calculer_sol
{
int delta = calculer_delta();
if (delta<0)
{
ecrire_message();
}
else
{
if(delta == 0)
{
solution_unique();
}
else
{
solution_double();
}
}
}
void main(){
lire_coefs();
while(y_a_equation()){
calculer_sol();
lire_coefs();
}
}
Référence ou appel de routine :
Se fait à l'intérieur d'un bloc de contrôle
Valide pour une fonction déclarée ou définie précédemment
Peut être récursif : appel de fonction dans le corps de celle-ci
Le résultat d'une fonction peut être utilisé :
Pour l'affectation d'une variable :
int a = calcul();
Dans une expression :
int a = 3 * calcul();
Définition d'une routine :
Rappel : fournit l'implémentation de la routine
Consisite en : répétition de déclaration identique
suivie d'un bloc d'instructions
= corps de la fonction
Peut faire office de déclaration (définiton = déclaration + définition)
Instruction return()
Rappel : retourne la valeur de la fonction au programme appelant
return(expression);
C'est la dernière instruction exécutés dans la sous-routine !
return; Peut être utilisée dans une procédure pour stopper l'éxecution de celle-ci.
Valeur retournée par return()
Si le type varaible/expression donnée à return() est ≠ du type défini dans la déclaration de la fonction :
Soit erreur de compilation
Soit un type-cast implicite
Déclaration des variables :
Rappel :
Les variables sont valides à l'intérieurs des bloces de contrôle ou elles sont définies. ( = Variable locale)
Il est possible de définir des variables entre les corps des procédures et les fonctions.(=variable globale) à Les variables sont accessibles dans tout le programme après la déclaration globale.
Retour de valeur par main()
Succès _ 0 (0 erreur)
Erreur : valeur !=o (code erreur)
Exemple :
int main()
{
return (lire_fichier()); //retourn 1 si erreur
return(calculer_delta()); //retourne 2 si erreur
return 0; //le programme c bien terminé
}
Structure de données
:
struct :
Les structures permettent de regrouper des objets(des variables) au sein d'une entité repérée par un seul nom de variable.
Lors de la déclaration de la structure, on indique les champs de la structure, c'est à dite le type et le nom de la variable qui la composent:
struct Nom_structure
{
type_1 Nom_var1;
type_2 Nom_var2;
}
;
exemple :
strucut MaStructure
{
int Age;
char Sexe;
char Nom[12];
float MoyenneScolaire;
struct AutreStructure StructBis ; (si AutreStructure est deja définie)
};
Définition d'une variable structurée :
La définition d'une variable structurée es une opération qui consiste à créer une variable ayant comme type celui d'une structure que l'on a précédemment déclaré.
struct Nom_structuture Nom_Variable_structuree;
Exemple :
struct Personne
{
int Age;
char Sexe;
};
On peut définir plusieurs variables structurées
|
Struct Personne |
Pierre, Paul, … |
|
Strucut Personne |
Toto = {5, 'm'}; |
Déclaration d'un typedef de struct
But : définir un nouveau type correspondant à une structure
typedef struct {…} Nom_type;
Accès au champs d'une variable strcuturée :
Chaque variable de type structure des champs repérés avec des noms uniques.
Toutefois le nom des champs ne suffit pas pour y accéder étant donné qu'ils n'ont
de contextee qu'au sein de la variable structurée…
Pour accéder aux champs d'une structure on utilise l'opérateur de champs (un simple point) placé entre le nom de la variable strcuturée que l'on définie et le nom champ :
Nom_variable.Nom_champ;
Ainsi pour affecter des valeurs à la vairables Pierre ( variable de type strut Personne définie précédemment) :
Pierre.Age = 18;
Pierre.Sexe = 'M';
Passage de paramètres
:
Rappel : variables globales : sont visible de toutes les routines.
Limitation :
protection d'accès quasi impossible (n'importe qu'elle routine peut les modifier)
Le transfert d'information se fait par nom de variable,
les routine appelante et appelée doivent utiliser le même label de variable.(implicite)
Solution : passage explicite de paramètres : liste d'arguments passés à l'appel
Déclaration indique la liste des arguments
bool exemple (int arg1, float arg2);
Référence peut passer des variables locales
int i;
float
f;
bool
résultat = exemple(i,f);
Indépendance des labels :
Définition utilise ses propres lables de variables.
bool exemple(int vari, float vraf)
{
if(vari > 0 && varf >0.0f)
return true;
return false;
}
Appel d'une fonction paramétrée :
Respect des types de paramètres, sinon erreur ou type-cast implicite
Respect du nombre de varaible
Respect de l'ordre des variables
Rappel : respect du type de valeur retournée
// déclaration
void rien2special (double d);
void appelante(void)
{
int vali = 20;
char * valc = NULL;
rien2special(vali); // ok implicitemnet convertit en double
rien2special(valc); //erreur de conversion implicite
Exemple : i Procédure qui affiche n fois 1 caractère c
void afficher(char c, int n)
{
int i;
for( i=0; i <n; ++i)
cout << c;
}
int main()
{
char c;
cin >> c;
afficher(c, 10); //afficher 10 fois le caractère c
afficher('+',5); //afficher 5 fois +
afficher(c, 6); //afficher 6 fois le caractère c
}
Manières de passer les paramètres :
passage par valeur (copie des valeurs)
passage par référence (passage du pointeur)
Passage par valeur :
Les paramètres sont passés par valeur
la valeur de la variable du programme appelant est copiée dans une nouvelle variable locale à la routine à chaque appel.
La durée de vie des variables correspond à la durée de l'exécution de la fonction.
Comment modifier un paramètre ?
En passant son pointeur :
void affich(int n); //déclaration
affich(numero); //appel
void affich(int n)
{
n += 10;
cout << "n ="<<n; // N=11
}
void main ()
{
int n=1;
affich(n);
cout<<"n="<<n; // N=1
Pour modifier n dans affich() et obtenir sa nouvelle valeur dans la routine appelante.
void affich(int * n); //déclaration
affich(&numero); // appel
void affich(int * nn)
{
*nn += 10;
cout << "n ="<< *nn; // N=11
}
void main()
{
int n = 1;
int* pn = &n;
affich(pn); // *pn // *pn +=10 //N=11
cout << "n ="<< n;
}
Passage par référence en c++ :
C++ offre une altérantive au pointeurs : permet de modifier une variable à travers une routine.
Utilisation de & après le type dans la déclaration (indique passage par référence)
void affich (int & n); // déclaration
affich (numéro); // appel
void affich(int & n)
{
n
+= 10;
cout <<"n="<< n; // N =11
}
void main ()
{
int n=1;
affich(n);
cout <<"n ="<< n; // N=11
}
Les tableaux :
Les tableaux unidimensionnels :
Problème : comment mémoriser un grand nombre de valeurs ?
Sans utiliser un grand nombre d'identificateurs de variables ?
Solution : Nom de variable unique
Référencer valeurs par 1 numéro ou 1 adresse.
Définitions :
Tableau ou variable indexée : variable permettant de mémoriser plusieurs valeurs.
Indic ou index : numéro qui permet d'accéder à une vlauer particulière du tableau.
Composante ou entrée du tableau : valeur particulière pour un index donné.
Déclaration d'un tableau :
Préciser : sa dimension = le nombre d'éléments contenus dans le tableau.
exemple :
int nb[200];
char tab[10];
float prix[30];
Indexage :
En C, les indices vont de 0 à n-1
#define NOMBRE 20
int main()
{
int i;
int nb(NOMBRE);
for (i=0; i<NOMBRE; ++i)
cin
>> nb[i];
for(i
= NOMBRE-1; i >=0; --i)
cout << nb[i]<<endl;
}
Initialisation à la déclaration :
Donner la liste des valeurs entre {}, séparées par des virgules ,
int nb[2] = {29,34};
char tab[3] = {'x','y','z'};
float prix[1] = {22.0f};
string
str[2] = {"bon","test"};
Pointeurs et tableaux :
L'utilisation d'index peut être réalisée sous forme de pointeur.
Un tableau
déclaré : int tab[4];
Définit un bloc mémoire de 5 entiers rangés consécutivement et nommés :
tab[0],tab[1],tab[2],tab[3]
tab[i] désigne l'objet placé à la ième position à partir du début.
Relation tableau/pointeur :
Soit un pointeur pta déclaré par
int * pta;
Initialisé à
pta = tab ; // équivaut à pta=&(tab[0]);
pta pointe vers le 1er élement du tableau
int z = *pta; // équivaut à int z =tab[0];
pta+i pointe vers le l'élément en ième position dans le tableau.
*(pat+i) correspond au contenu de tab[i]
pta+i à l'adresse de tab[i] doit &(tab[i])
Exemple
(exercice 6)
#inculde <iostream>
#include <math.h>
using
namespace std;
typedef
struct
{
float
x,y;
} point2d;
float
disManathan(point2d a, point 2d b)
{
return
(abs(a.x-b.x)+abs(a.y-b.y));
}
float disEuclidienne(point 2d a, point 2d b)
{
float
dx = a.x – b.x;
float
dy=a.y-b.y;
return
((float)sqrt(dx*dx + dy*dy));
}
float
disEchiquier(point2d a, point2d b)
{
float
dx=abs(a.x – b.x);
float
dy = abs(a.y – b.y);
if
(dx > dy)
return dx;
return
dy;
}
int
main()
{
point 2d
p,q;
cout << "Saisir les coordonnees de p :";
cin >> p.x >> p.y;
cout <<"Saisir les coordoonnees de q :";
cin >>q.x>>q.y;
cout<<endl;<<"Resultats : "<<endl;
cout <<"Distance de Manathan =" <<disManathan(p,q)<<endl;
cout<<"Distance d'Euclidienne ="<<disEuclidienne(p,q)<<endl;
cout<<"Distance de l'echiquier ="<<disEchiquier(p,q)<<endl;
Exercice 8 "boite à outils"
#include<iostream>
#include<math.h>
using
namespace std;
typedef
struct
{
float x,y,z;
}point3d;
typedef
struct
{
float
dx, dy, dz;
float norme;
}vecteur;
//déclarations :
point3d saisirpoint();
vecteur vect_construct(point3d P, point3d Q);
float vect_norme(vecteur V);
vecteur vect_add(vecteur V, vecteur W);
void vect_mulScal(vecteur &V, float scal);
//Définition :
point3d saisirPoint()
{
point3d P;
cin>>P.x>>P.y>>P.z;
return(P);
}
vecteur vect_construct(point3d P, point3d Q)
{
vecteur V;
V.dx = abs(P.x –Q.x);
V.dy =abs(P.y
– Q.y);
V.dz =abs(P.z
–Q.z);
V.norme = vect_norme(V) // calcul de la norme
return (V);
}
float vect_norme(vecteur V)
{
return(sqrt(V.dx*V.dx) + (V.dy*V.dy) + (V.dz*V.dz)));
}
vecteur vect_add(vecteur V, vecteur W)
{
vecteur Res;
Res.dx = V.dx +W.dx;
Res.dy = V.dy+W.dy;
Res dz = V.dz+W.dz;
Res.norme = vect_norme(Res);
return(Res);
}
void
vect_mulScal(vecteur &V, float scal)
{
V.dx*=scal;
V.dy*=scal;
V.dz*=scal;
V.norme(V);
}
// Programme Principal
void main ()
{
point3d A,B;
A = saisirPoint();
B = saisirPoint();
vecteur V1;
V1 = vect_construct(A,B);
vecteur_mulsScal(V1, 3);
}
Exercicie 9 :
#include <iostream>
using
namespace std;
int A[9];
void
remplitA()
{
for
(int i=o; i<=9; i++)
{
A[i] = i;
};
};
void impA()
{
for
(int i=0; i<=9; i++)
{
cout <<"A[" << i << "] =
"<<A[i]<<"\n";
};
cout <<"\n";
}
int main()
{
remplitA();
impA();
int &b = A[5];
b++;
impA();
int * c=A+7;
(*c)++;
c++,(*c)++;
impA();
cout<<"b = "<< b <<"adr de b =" << &b <<"\n";
cout<<"c
="<<c<<"adr de c="<<&c<<"valeur
de c ="<<*c<<endl;
return(0);
}
Les tableaux multidimensionnels :
2 dimensions, ou +, se déclarant de façon similaire aux tableaux unidimensionnels
en précisamt les dimension de chaque coordonnée entre corchets []
int vec[80][20];
char
tab[10][11];
float
prix[30][2][50];
Initialisation à la déclaration :
Similaire au cas unidemensionnel, chaque dimension séparée par accolade {}
int vect1[2][3] = {{o,1,5},{7,3,2}};
int vect2[3][2][4] =
{ {{0,1,2,3},{1,2,3,4}},
{{0,1,2,3},{1,2,3,4}},
{{0,1,2,3},{1,2,3,4}}
};
Accès à un élément :
vect1[i][j]
exemples :
vect1[0][1] = 5
int x = vect1[0][1]*vect[0][0]
Attention : il n'existe pas de protection concernat les indices de tableaux, ie il est possible d'écrire ou de lire des cases qui ne sont pas allouées = crash.
Tableau et argument de fonction :
Un tableau de fonction peut être passé comme argument d'une fonction
soit par indice
soit par pointeur
2 déclarations différentes possibles
void traiter(int*t);
void
traiter(int t[]);
On peut modifier le contenudes tableaux passés en arguments dans la fonction.
Les tableaux ne sont pas passés par valeurs, toujours par référence !
Boite à truc :
Portée d'une variable :
Définition : région d'un programme ou une variable peut être référencée
Variable locales : portée : bloc de contrôle contenant le déclaration
Variable globale : portée : modules ou programme.
Variable temporaire :
Conserve sa valeur seulement dans la portée de la variable,
Mémoire associée est
Dynamiquement allouée en début de portée
Libérée ne fin de portée par le compilateur
Durée de vie illimitée
Variable statique :
Conserve sa valeurs hors de sa portée
Mot clef static lors de sa déclaration :
int tempsomme; // variable temporaire
static int statsomme; //varialbe statique
Initialisé qu'une fois.
Mots clefs : const
indique une constante : la valeur ne peut être modifié après l'initialisation.
const int n = 2;
n = 4; //erreur de
compilation
Utile pour protéger des paramètres de toute modification lors d'appel de fonction.
void erreur (const string & msg)
{
cerr<<"Erreur : "<< msg << endl;
msg = "C'est pas gagné " //erreur
}
Appel en utilisant const
void erreur (cosnt string& msg);
void main(void)
{
string
test ="si ca marche";
erreur(test);
}
Exercice 7
"IMC"
#include <iostream>
#include <math.h>
using
namespace std;
float
calculMC(float poids, float taille)
{
return(poids/(taille*taille));
}
int main()
{
float p,t;
cout<<"saisir votre poids(kg)";
cin >>p;
cout<<"saisir votre taille(m)";
cin>>t;
cout<<"Votre IMc est de =" calculIMC(p,t)<<endl;
return (0);
}
Les algorithmes de tri :
La fonction de permutation :
Pour trier les valeurs d'un tableau, il est nécessaire de permuter des valeurs contenues dans différentes cases du tableau.
Pour cela une fonction de permutation, s'appellant echanger doit être écrite
Arguments : un tableau, 2 entier i et j
Focntionnement :
La fonction récupère le contenu de la ième case du tableau, affecte à cette case la valeur contenue dans la jième case, puis affecte à la jième case la valeur initial de la case i.
void echanger(int tab[],int i, int j);
Fontion échanger : permuter 2 éléments d'un talbeau
void echanger(int tab[],int i, int j);
{
int memoire;
memoire = tab[i];
tab[i] = tab[j];
tab[j] = memoire;
}
Le tri par création :
Le principe de ce tri est de créer un tableau vide de même taille que le tableau à trier, puis de chercher dans le tableau à tgrier le plus petit élément afin de le placer en première position du tableau nouvellement créé.
Ensuite l'agorithme recherche successivement les éléments suivants afin de les placer, à la suite, dans le nouveau talbeau.
L'algorithme se termine lorsque tous les éléments du tableau ont été ajoutés.
Exemple de tri :
#defin NBELEM 6
// Variables gloables
int tabval[NBELEM] = {5,3,1,2,6,4};
bool isdone[NBELEM] = {false, fasle, false, false, false,
false};
int triCreation_get_index_min()
{
//l'élément de l'index le plus petit non encore trié -1 si pas trouvé
int res =-1;
//trouver le 1er index (s'il existe)
int i =0;
bool found = false;
while ((i<NBELEM)&&(!found)
{
if(!isdone[i])
{
found = true;
res = i;
}
i++;
}
if (!found) return res;
// chercher dans le reste du tableau s'il existe une valeur <
while (i<NBELEM)
{
if (!isdone[i] && (tabval[i] < tabval[res]))
res = 1;
i++;
}
return (res);
}
void triCreation(int input[NBELEM], int output[NBELEM]
{
//tri
le talbeau input -> output
int i;
for(i=0; i < NBELEM;i++)
{
int next_index = triCreation_get_index-min();
if (next_index !=1)
{
isdone[next_index] = true;
output[i] = input [next_index];
}
}
}
void inittab(tabtri &t)
{
for (int i = 0; i < NBELEM; i++)
{
cin >>t.tabval[i];
t.isdone[i]
= false;
}
}
Exemple tri par insertion :
void triinsertion(int t[], int nbelem)
Fin- Langage Communication Informatique, Partie 1, 2004-2005, A.Gyger " www.metah.ch "