Développement structuré C++ en BTS IG 1ère année

Gilles Thomassin

Julien Legrand

Ce document est plaçé sous licence LGPL


Dédicace

Ce cours est dédié à tous les étudiants qui prennent du plaisir à apprendre et grâce auxquels on a du plaisir à enseigner, il est dédié aussi à la communauté Linux qui partage sans compter et grâce à laquelle on peut disposer d'un environnement de développement performant.

Table des matières

Les premiers pas
Prologue
Hello world
Exercices sur la compilation
Programme C++ minimal
une instruction avec cout
Les variables
Les types de variable
Le nom des variables
Organiser la saisie d'information
Exercices de base
Les structures de contrôle
Les structures alternatives
Les structures alternatives simples
Exercices sur les stuctures alternatives simples
Structure alternative multiple
Exercices sur les stuctures alternatives multiples
Les structures répétitives
Choix du type de boucle
Boucle 0,N
Boucle 1,N
Boucle n passages
Exercices d'initiation sur les boucles
Exercices sur les boucles : saisie contrôlée
Les tableaux
Introduction: pourquoi les tableaux
Ce qu'il faut savoir sur les tableaux
Algorithmes de base sur les tableaux
Exercices de base sur les tableaux
Exercices sur les tableaux surdimentionnés.
Exercices approfondis sur les boucles
Compléments d'affichage et de saisie
Quelques compléments sur l'affichage
Les séquences d'échappement
Les affichages formatés
Compléments pour la saisie de données
Traitement des chaines de caractères
Quelques concepts
Exercices sur les chaines de caractères
Les sous-programmes
Introduction
Les fonctions
Exercices sur les fonctions.
Les procédures
Valeurs par défaut des paramètres
Paramètres par valeur et par référence
Quelques exercices sur le passage de paramètres dans les procédures.
Les structures
Introduction aux structures
Exemple de stucture
S'en sortir avec les types structurés
Déclaration de variables d'un type structuré
Les types des champs d'une structure peuvent être aussi des structures
Les tableaux d'enregistrement
Exercices sur les structures
Les fichiers textes
Introduction sur les fichiers
Le principe d'utilisation des fichiers
Lire un fichier entier
Ecrire dans un fichier texte
Algorithmes de base sur les fichiers textes:
Problématique des accés concurrents
Projet -- unification des compétences système et développement : gestion des interfaces réseau en C++
La réalisation du projet
Lecture de la configuation IP.
Modification la configuation IP.
Passer d'une configuration IP à une autre.
Modification la configuation IP v2.
Passer d'une configuration IP à une autre v2.

Liste des tableaux

1. Table de multiplication

Liste des exemples

1. instruction sur plusieurs lignes
2. affichage de caractères, entier, réels, chaînes de caractères
3. les variables
4. Invite de saisie
5. structure alternative simple
6. structure alternative simplifiée
7. Utilisation de la fonction pow(x,y)
8. switch
9. Utilisation du break dans le switch
10. Boucle while (condition) {}
11. do..while
12. Affichage d'un rectangle de 3 * 4 étoiles.
13. Afficher un caractère d'après son code ASCII
14. Cadrer un affichage avec des tabulations
15.
16. setprecision
17. Affichage du 4ième caractère d'une chaîne
18. Déclaration et accès aux cases d'un tableau.
19. Utilisation d'une constante pour déclarer la taille d'un tableau
20. fonction sans paramètre
21. Une fonction qui accepte plusieurs paramètres

Loin d'être une référence sur le langage C++. Ce document est constitué d'un ensemble de cours et de TP permettant une initiation à la programmation. Il contient donc une progression sur les principaux concepts à mettre en oeuvre. Chaque partie contient des exercices permettant d'assimiler les concepts. Il s'agit dans ce livre de programmation structurée.

Les premiers pas


Prologue

Ce cours constitue une approche par la pratique du langage C++ Ansi.

Il suppose l'utilisation complémentaire d'une référence pure au langage C++.

Vous pourrez trouver cette référence soit sur internet: Cours de C/C++ de Christian Casteyde soit sous forme d'un ouvrage du genre C++ pour les nuls que vous trouverez en librairie ou grande surface.

Hello world

Vous apprendrez ici à préparer votre environnement, éditer le source d'un programme, le compiler et l'exécuter.

Travail à faire : Dans votre répertoire personnel, créez un répertoire "IG1_C++". Ce répertoire accueillera les programmes que vous allez écrire lors de votre formation. Vous prendrez comme habitude de créer à l'intérieur de ce répertoire un répertoire par projet que vous commencez. Créez donc un répertoire "01_projetHello" placez vous à l'intérieur, et à l'aide de gvim ou à défaut vim, tapez le source de ce premier programme en langage C++.

/*Premier programme*/
//Inclusion des bibliothéques
#include <iostream>
using namespace std;
int main()
{
	char touche;
	cout<<"Bienvenue dans la communauté des programmeurs"<<endl;
	cout<<"Tapez un caractère suivi de Entrée pour continuer"<<endl;
	cin>>touche;
}

Ce programme est constitué d'instructions en langage C++. Il s'agit pour l'instant d'un simple fichier texte que l'on va sauver avec l'extension "cpp" hello.cpp.

Il s'agit maintenant de compiler le fichier source "hello.cpp": g++ hello.cpp

Si le fichier source est bien tapé, aucun message d'erreur n'apparait. En tapant la commande ls -l. Vous devriez obtenir la liste des fichiers suivante:

total 20
-rwxr-xr-x  1 jlegrand jlegrand 13447 aoû 10 09:10 a.out*
-rw-r--r--  1 jlegrand jlegrand 94 aoû 10 09:07 hello.cpp

La compilation a été effectuée. Le compilateur g++ a créé un éxécutable dont le nom est "a.out" dans le répertoire "01_projetHello".

Pour exécuter ce programme, on va signifier au système que l'on souhaite exécuter le fichier a.out se trouvant dans le répertoire courant. Nous allons donc taper la commande suivante : ./a.out Le programme a.out s'exécute alors.

	[jlegrand@bigserv projetHello]$ ./a.out
	Bienvenue dans la communauté des développeurs
	Appuyer sur une touche suivie de Entrée pour continuer
	a
	[jlegrand@bigserv projetHello]$
	

Quelques explications: a.out en tant que programme compilé est constitué d'une suite d'octets correspondant à des ordres que le processeur de l'ordinateur sait exécuter. On parle de langage machine.

Afin d'obtenir un exécutable au nom moins rébarbatif, nous allons voir une option de g++ qui va nous permettre de choisir le nom de l'exécutable généré par le compilateur. g++ -o coucou hello.cpp L'option "-o" suivie du nom de l'exécutable que l'on souhaite obtenir permet d'oublier le fameux a.out. En lieu et place, g++ crée un exécutable nommé coucou.

Exercices sur la compilation

Travail à faire : En vous inspirant du contenu de hello.cpp écrire un programme qui affiche:

	Ce programme est sous licence gpl.
	Vous êtes autorisés à le copier.
	Vous êtes autorisés à le modifier.
	

Consignes: Vous restez dans le dossier 01_projetHello. Le fichier source s'appellera exo1.cpp. L'exécutable obtenu s'appellera gpl.

Même exercice que précédemment, mais cette fois on demandera à l'utilisateur de taper une touche aprés affichage de chacune des trois phrases. Vous restez dans le dossier 01_projetHello. Le fichier source s'appellera exo2.cpp. L'exécutable obtenu s'appellera gpl2.

A retenir :

  • La compilation se fait comme ceci: g++ -o "nom de l'exécutable " "nom du fichier source"
  • Lorsqu'on ne donne pas le nom de l'exécutable, g++ crée un fichier a.out
  • On créera un répertoire pour chacun de nos projets

Programme C++ minimal

Il semble que le plus petit programme C++ qui puisse se compiler soit le suivant:

int main()
{
}
					

Ce programme contient une fonction appelée main mot anglais qui signifie "principal". Il s'agit donc de la partie principale du programme et elle est obligatoire. Le "int" placé devant main signifie que la fonction main renvoie un entier. Toute fonction est suivie de la liste de ses paramètres (ou arguments) placés entre parenthèses. Ici la fonction n'a pas d'argument. Il n'y a donc rien entre les parenthèses. Suivent enfin les instructions de la fonction main placées entre accolades. Nous remarquons que dans ce programme il n'y a pas d'instruction.

Travail à faire : Editez, compilez et exécutez ce programme.

A retenir :

  • Tout programme C++ doit contenir une fonction appelée main
  • La fonction main doit être du type entier.
  • Les instructions d'une fonction sont écrites entre deux accolades.
  • main est doit toujours être suivis par ( ), même si on n'écrit rien entre les parenthèses.

une instruction avec cout

"cout" est le "petit nom" du périphérique de sortie standard de l'ordinateur : l'écran.

Lorsqu'un programme doit afficher quelque chose, le meilleur endroit où il peut le faire est l'écran.

L'information part de l'ordinateur et va sur l'écran: ecran <---info-- ordinateur

L'instruction permettant d'afficher le message "bonjour" est comme on l'a déjà vu:

	cout<<"bonjour";
					

Notez bien le sens des chevrons indique de sens de "déplacement" de la chaîne de caractères "bonjour" : vers cout (l'écran).

Toute instruction se termine par un ";" en anglais: "semicolon". Oublier le ";" provoquera une erreur lors de la compilation:

  • semicolon missing on line xxx
    . Le xxx est le numéro de la ligne suivant l'instruction non correctement délimitée.
  • erreur: expected `;' before «nb2»
    , suffisamment explicite, encore que insiqué sur la ligne suivante.
  • ou un autre message d'erreur indiqué sur la ligne suivante

Comme vous pouvez le voir dans l'exemple ci-dessous, une instruction peut tenir sur plusieurs lignes.

Exemple 1. instruction sur plusieurs lignes

	cout
	<<
	"bonjour"
	<<
	endl
	;
						

C'est là une pratique que l'on évitera mais qui justifie la présence du ";" marqueur de fin d'instruction.

On peut afficher à l'écran: un caractère, un entier, un réel, une chaine de caractères.

Exemple 2. affichage de caractères, entier, réels, chaînes de caractères

	cout<<"Le nombre d'élèves"
	<<endl<<"est de"<<4<<endl
	<<"la moyenne est de "<<10.25<<endl;
		 

Chaque information à afficher est à précéder du <<

Attention

  • Les chaînes de caractères (ensemble de plusieurs caractère) sont notées entre " doubles-quotes.
  • Un caractère est noté entre simples quotes '
  • Les numériques sont notés sans quotes


Les variables

Les informations saisies par les utilisateurs du programme ou les résultats intermédiaires obtenus lors de calculs doivent nécessairement être stockées quelque part dans la mémoire de l'ordinateur. Ces informations sont mémorisées dans des variables. Chaque variable a un un nom et un type, elles doit de plus être déclarée.

Voici ci-dessous un exemple de programme qui déclare et utilise des variables.

Exemple 3. les variables

//Inclusion des bibliothéques
#include <iostream>
using namespace std;
	 int main()
	 {
		//déclaration des variables:
		double taille;
		double poids;
		double densite;

		//affichage du message d'accueil
		cout<<"Bienvenue sur le calculateur de densité"<<endl;
		//saisie du poids
		cout<<"Votre poids : ";
		cin>>poids;
		//saisie de la taille
		cout<<"Votre taille : ";
		cin>>taille;
		//calcul de la densité
		densite=poids/taille;
		cout<<"Votre de densité est de "<<densite<<endl;
	 }
 

Dans l'exemple ci-dessus, 3 variables de type double sont déclarées.Ces trois variables ont pour nom respectivement:

  • taille
  • poids
  • densite

Le type double correspond au type réel (nombre à virgule) courant.

La forme générale d'une déclaration est: <type> <nom>;

Si l'on a plusieurs variables du même type, on peut les déclarer sur une même ligne:

string nom, prenom;

Les types de variable

On considèrera pour l'instant qu'il existe 5 types de variables:

  • double pour les nombres réels ex: 145.26
  • long pour les nombres entiers ex: 65210
  • char pour les caractères ex: 's'
  • string pour les chaînes de caractères ex: "Bonjour"
  • bool pour les booléens ex: true

Exercice : Indiquez pour chacune des informations suivantes le type informatique qui correspond:

  • couleur
  • altitude
  • pi
  • taux de réduction
  • smic horaire
  • nom
  • prénom
  • âge
  • nombre d'enfants

Le nom des variables

Le nom de la variable doit être significatif du contenu de celle-ci les variables appelées i, j, x, ou y sont à proscrire définitivement. Le nom de variable ne comporte que des lettres en minuscule. Il est toutefois possible lors de noms composés de changer de casse pour marquer le début d'un nouveau mot. Voici quelques exemples de noms de variable composés: nomProduit prixUnitaireProduit. Il est éventuellement possible aussi d'utiliser les chiffres mais jamais en première position. On peut donc trouver les noms de variable suivant: taux1, taux2.

Organiser la saisie d'information

La saisie d'information suppose l'affichage préalable d'un message qui renseigne l'utilisateur sur ce qu'il doit taper.

Exemple 4. Invite de saisie

	cout<<"Votre nom :";

Tout comme cout désigne l'écran cin désigne le périphérique d'entrée standard: le clavier.

cin>>nomClient;

L'information part du clavier et va dans la variable : cin ---info--> variable.

Voici donc le programme complet:

//Inclusion des bibliothéques
#include <iostream>
using namespace std;

	int main()
	{
		string nomClient;
		cout<<"Votre nom :";
		cin>>nomClient;
		cout<<endl<<"Bonjour "<<nomClient;
	}	
	

Exercices de base

Travail à faire : Créez un dossier nommé 02_projetVariables dans IG1_C++. Dans les exercices ci-dessous, le nom indiqué pour chaque programme servira pour le programme source .cpp et pour le programme l'exécutable généré lors de la compilation.

exercice 1 : Ecrire le programme convertisseur qui demande à un utilisateur une somme en francs et lui affiche l'équivalent en euros

exercice 2 : Ecrire le programme bienvenue qui conformément à l'écran ci-dessous demande à l'utilisateur son nom et son prénom et lui affiche un message d'accueil.

	Tapez votre prénom : Louis
	Tapez votre nom : Dupond
	Bonjour Louis Dupond

exercice 3 : Ecrire le programme piscine qui demande à l'utilisateur la largeur, la longueur et la profondeur de sa piscine et lui calcule son volume en mètres cubes (le fond de la piscine est plat).

exercice 4 : Ecrire le programme piscinePlus qui demande à l'utilisateur la largeur, la longueur et les profondeurs aux deux extrémités de sa piscine et lui calcule son volume en mètres cubes. La piscine ayant un fond en pente et la profondeur varie linéairement dans le sens de la longueur. Pour calculer le volume de la piscine, il faut utiliser la profondeur moyenne de celle-ci.

exercice 5 : Réaliser une nouvelle version du programme ci-dessus, nommée piscineCout permettant de calculer le cout de remplissage de la piscine. On peut estimer à 2,60 euros le coût au mètre cube de l'eau.

exercice 6 : Ecrire le programme horaire qui convertit en heures, minutes, secondes une durée exprimée en seconde rentrée par l'utilisateur. Indications:

  • si la duree est de 7274s 7274=2*3600+1*60+14 la durée est donc de 2 heures 1 minute et 14 secondes.
  • En utilisant la division euclidienne, 7274 divisé par 3600 donne 2 et il reste 74. Pour obtenir le reste on utilise l'opérateur %. L'instruction correspondante est donc:
    reste=7274 % 3600;

exercice 7 : Ecrire un programme voyageEnTrain qui demande à l'utilisateur l'heure de dépard d'un train, la durée du voyage et renvoie l'heure d'arrivée. L'heure de départ ainsi que celle d'arrivée et la durèe du voyage seront exprimées en heures, minutes, secondes.

Les structures de contrôle


Les instructions sont par défaut exécutées en séquence (les unes à la suite des autres).

Mais il est heureusement possible de contrôler l'exécution des instructions de façon plus fine. Par exemple, on peut n'effectuer une instruction que sous certaines conditions. Ou alors on peut répéter un groupe d'instructions un certain nombre de fois. Dans le premier cas on parlera de structure alternative et dans le second de structure répétitive.

Les structures alternatives

Les structures alternatives permettent l'exécution conditionnelle d'un bloc de code.

Les structures alternatives simples

Structure alternative siAlorsSinonFsi

Syntaxe:

if(<condition>)
{
	<bloc1...>
}
else
{
	<bloc2...>
}
						

C'est la structure de test générale.

Elle se lit comme ceci : si la proposition logique <condition> est vérifiée alors exécuter les instructions contenues dans le <bloc1> sinon exécuter les instructions du <bloc2>.

Exemple 5. structure alternative simple

	if (nom=="Dupond")
	{ 
       		cout<<"Bonjour patron"<<endl; 
		cout<<"Bonne journée";
	} 
	else
	{
	  cout<<"Bonjour simple employé"<<endl;
	}
							

Structure alternative siAlorsFinSi

Il existe aussi une structure alternative simplifiée similaire à la structure alternative simple mais ne disposant pas du bloc sinon:

Exemple 6. structure alternative simplifiée

plusGrand=nombre1;
if (nombre2>nombre1)
{ 
	plusGrand= nombre2;
}
cout<<"Le plus grand est : "<<plusGrand<<endl;
							

Exercices sur les stuctures alternatives simples

Travail à faire : Créez un dossier nommé 03_projetAlternativesSimples dans IG1_C++. Dans les exercices ci-dessous, le nom indiqué pour chaque programme servira pour le programme source .cpp et pour le programme l'exécutable généré lors de la compilation.

exercice 1 : Ecrire le programme triNoms qui demande à l'utilisateur deux noms et les lui affiche dans l'ordre alphabétique.

exercice 2 : Ecrire le programme deuxReels qui demande à l'utilisateur deux réels, en affiche la somme, la moyenne, trouve le minimum et le maximum.

exercice 3 : Ecrire le programme plusPetitNombre qui demande à l'utilisateur de saisir 4 réels et lui affiche le plus petit des quatres.

exercice 4 : Ecrire le programme triNombre qui demande à l'utilisateur 3 réels et les lui affiche dans l'ordre croissant.

exercice 5 : Ecrire le programme facturation qui calcule le montant d'une facture. Sont demandés: libellé du produit , quantité à facturer, prix unitaire hors taxe. Seront affichés: le montant total ht, le montant total ttc auquel seront ajoutés les frais de port. Les frais de port correspondent au montant forfaitaire de 100 euros. Les frais de port ne sont pas facturé lorsque le montant ht de la facture est supérieur à 1000 euros. Une réduction de 10% du montant ht de la facture est appliqué entre 500 et 1000 euros. Le taux de TVA appliqué sera 19,6%.

exercice 6 : Ecrire le programme delta qui résoud une équation du second degré du type 0=ax²+bx+c, a,b et c seront rentrés par l'utilisateur. Indication: la fonction pow(x,y) renvoie l'élévation à la puissance y du nombre x.

Exemple 7. Utilisation de la fonction pow(x,y)

	double res=pow(nb,0.5);
	cout<<endl<<"La racine de "<<nb<< " est  "<<res<<endl; 

exercice 7 : Ecrire le programme nuancier qui demande à l'utilisateur de taper deux couleurs et lui affiche le nom de la couleur composée. Les couleurs pouvant être tapées sont à prendre parmi l'ensemble suivant:(rouge,jaune,bleu).

exercice 8 : Ecrire le programme bissextile qui détermine si une année saisie par l'utilisateur est une année bissextile. Une année est bissextile si elle divisible par 4, sauf si elle est divisible par 100 à moins qu'elle soit divisible par 400.

exercice 9 : Ecrire le programme mention qui demande une note et affiche la mention correspondante ou un message si la note saisie n'est pas correcte.

Exercice 10 : Ecrire le programme dureeMois qui affiche le nombre de jours que comporte le mois saisi par l'utilisateur dans l'année saisie par l'utilisateur.

Structure alternative multiple

C++ dispose aussi d'une structure permettant de comparer le résultat d'une expression à plusieurs valeurs et d'associer des instructions pour chacune de ces valeurs :

...
switch (variable)
{
	case...
	case... 
	default...
}
...
					

Voici un exemple de code utilisant la structure alternative multiple.

Exemple 8. switch

	long	nombre;
	cout<<"Tapez un nombre compris entre 1 et 5 : ";
	cin>>nombre;
	switch(nombre) 
	{
		case 1:
			{
				cout<<"vous avez tapé 1";
				break;
			}
		case 2:
			{ 
				cout<<"vous avez tapé 2";
				break;
			}
		case 3:
			{
				cout<<"vous avez tapé 3";
				break;
			}
		case 4:
			{
				cout<<"vous avez tapé 4";
				break;
			}
		default:
			cout<<"Sauf erreur de votre part, le nombre tapé est 5;
	}
					

La variable examinée ne peut être qu'un entier ou un caractère. L'instruction break permet de sortir du switch. Si on l'oublie, toutes les instructions suivantes sont exécutées même, si le cas ne correspond plus à la valeur de la variable, et ce jusqu'à la prochaine instruction break; ou à défaut jusqu'à la fin du switch Voici un autre exemple exploitant cette particularité :

Exemple 9. Utilisation du break dans le switch

	char lettre;
	cout<<"Tapez une lettre entre a et z : "
	switch(lettre)
	{
		case 'a':
		case 'e':
		case 'i':
		case 'o':
		case 'u':
		{
			cout<<"c'est une voyelle"<<<<endl;
			break;
		}
		default:
		cout<<"c'est une consonne"<<endl;
	}
					

A partir du moment où l'on rentre dans un cas les instructions sont exécutées jusqu'au prochain break. On ne rentrera dans la section default que si aucun des cas précédents n'a été vérifié.

Exercices sur les stuctures alternatives multiples

Travail à faire : Créez un dossier nommé 03_projetAlternativesMultipes dans IG1_C++. Dans les exercices ci-dessous, le nom indiqué pour chaque programme servira pour le programme source .cpp et pour le programme l'exécutable généré lors de la compilation.

exercice 1 : La voyelle 'y' n'a pas été prise en compte dans l'exemple ci-dessus. Reprenez et rectifiez le programme voyelles en conséquence.

exercice 2 : Le programme codageHumain permet de donner le code numérique correspondant à la description d'un humain : 2 bits pour la taille (très grand, grand, normal, petit), 2 bit pour les cheveux (clairs, foncés, colorés, aucun), 2 bits pour les yeux (bleus, verts, marrons), 1 bit pour le sexe (Homme, Femme). A vous de documenter votre programme pour qu'il soit facile de comprendre votre codage. Vous devez donc saisir, en saisie contrôlée et non en saisie ouverte, les caractéristiques puis afficher le code résultant.

Les structures répétitives

Choix du type de boucle

Les boucles servent à répéter un certain nombre de fois une instruction ou un bloc d'instructions.

On distingue 3 types de boucles différents que l'on choisi en fonction de la situation.

	Si on connait le nombre de fois où l'on va exécuter le bloc d'instruction, 
		on utilisera la boucle for(...;....;...){....}
	Sinon
		Si le nombre de répétition appartient à [0..n] 
			On utilisera la boucle while(...) {...} 
				//on peut ne pas passer ds la boucle.
		Sinon (si le nombre de répétition appartient à [1..n])
			On utilisera la boucle do {...} while(...); 
				//on passe au moins une fois dans la boucle
		FinSi
	FinSi
						

Boucle 0,N

Syntaxe: while (condition logique d'arrêt) {bloc d'instructions}

Utilisation: Cette boucle est à utiliser lorsqu'on ne connait pas le nombre de passage dans la boucle, et qu'on peut ne pas y passer du tout.

La condition logique d'arrêt doit répondre à la question : continuer tant que ??? Elle peut utiliser les tous les opérateurs logiques étudiés avec les alternatives.

Exemple 10. Boucle while (condition) {}

long dividande, diviseur;
cout<<"Ce programme affiche le résultat de la division entière d'un dividande par un diviseur (sans les opérateurs / et %)";
cout<<"Tapez le dividande :";
cin>>dividande;
cout<<"Tapez le diviseur";
cin<<diviseur;
long resultat, intermediaire;
intermediaire=dividande;
resultat=0;
while(intermediaire>=diviseur)
{
  intermediaire=intermediaire-diviseur;
  resultat=resultat+1;
}
cout<<"Le résultat est : "<<resultat;
						

Principe : Tant qu'il est possible de soustraire le diviseur au dividande, on le fait. Résultat compte le nombre de soustractions que l'on a pu effectuer. Tant que intermediaire est plus grand que le diviseur, on enlève à intermédiaire diviseur et on ajoute 1 à résultat.

Boucle 1,N

Syntaxe : do {bloc d'instructions} while(condition logique d'arrêt)

Utilisation : Cette boucle est à utiliser lorsqu'on ne connait pas le nombre de passage dans la boucle, et qu'on sait qu'on doit y passer au moins une fois.

La condition logique d'arrêt doit répondre à la question : continuer tant que ??? Elle peut utiliser les tous les opérateurs logiques étudiés avec les alternatives.

Exemple 11. do..while

Obtention du nombre de lancers de dés à effectuer pour obtenir le chiffre 3.
								
#include <time.h>
#include <iostream>
using namespace std;
int main()
{	
	//déclarations des variables:
	long nombreDeLancers , nombreAleatoire , nombreTire;				
	// initialisation du générateur de nombres aléatoires
	srand((unsigned)time(NULL));
	// initialisation à zero du nb de lancers
	nombreDeLancers=0;
	do
	{
		nombreDeLancers++; //incrémentation du nb de lancer de dé
		nombreAleatoire=rand();//tirage au hasard d'une nombre réel de l'intervalle [0 .. 1 [
		nombreTire=nombreAleatoire%6 +1;//tirage entre [1..6]
	}
	while (nombreTire!=3); // tant que le nb tiré est différent de 3
	cout<<"Pour tirer le chiffre 3 il a fallut : "<<nombreDeLancers<<" lancers du dé"<<endl;
}
							

Boucle n passages

Syntaxe: for ( initialisation ; arrêt ; évolution ){bloc d'instructions} initialisation est l'instruction d'initialisation du compteur de la boucle. arrêt est la condition logique portant sur le compteur permettant d'arrêter la boucle. Cette condition répond à la question répéter tant que ??? évolution est l'insctruction permettant de faire évoluer le compteur (incrémantation, décrémentation, saut de 2, ...).

Utilisation : la boucle for est à utiliser lorsque l'on connait dès l'entrée dans la boucle le nombre de passage à effectuer dans la boucle.

Exemple 12.  Affichage d'un rectangle de 3 * 4 étoiles.

		for ( ligne=1 ; ligne<=3 ; ligne++ )
		{
			for ( col=1 ; col<=4 ; col++ )
			{
				cout<<'*';
			}
			cout<<endl;
		}
							

Exercices d'initiation sur les boucles

Travail à faire : Créez un dossier nommé 04_projetRepetitive dans IG1_C++. Dans les exercices ci-dessous, le nom indiqué pour chaque programme servira pour le programme source .cpp et pour le programme l'exécutable généré lors de la compilation.

Exercice 01 : Ecrivez le programme tenPrems, qui affiche les 10 premiers entiers.

Exercice 02 : Ecrivez le programme tenPremsPairs, qui affiche les 10 premiers entiers pairs.

Exercice 03 : Ecrivez le programme rectangle; qui affiche un rectangle d'étoiles de 10 lignes de 7 étoiles.

Exercice 04 : Ecrivez le programme triangle qui affiche ceci :

	*
	**
	***
	****
	*****
	******
	*******
	********
	*********						
						

Exercice 05 : Ecrivez le programme cone qui affiche ceci :

	    *
	   ***
	  *****
	 *******
	*********						
						

Exercice 06 : Ecrivez le programme coneVariable qui affiche un cone comme dans l'exercice précédent, sauf que le nombre d'étoiles impair de la base sera saisi par l'utilisateur.

Exercice 07 : Ecrivez le programme coneVariableControle qui affiche un cone comme dans l'exercice précédent, mais on contrôlera que le nombre d'étoiles de la base appartient à l'intervalle [1..79] et est impaire. La saisie resa recommencée tant qu'elle n'est pas conforme.

Exercice 08 : Ecrivez le programme fleche qui affiche un cone comme dans l'exercice précédent, au dessus d'un tronc de 10*5 étoiles, toujours en contrôlant que le nombre d'étoiles de la base appartient à l'intervalle [5..79] et est impaire. La saisie resa recommencée tant qu'elle n'est pas conforme.

	         *
	        ***
	       *****
	      *******
	     *********					
	    ***********
	   *************
	  ***************
	 *****************
	*******************
	       *****	 
	       *****	 
	       *****	 
	       *****	 
	       *****	 
	       *****	 
	       *****	 
	       *****	 
	       *****	 
	       *****	 
						  

Exercice 09 : Ecrivez le programme tableMultiplication qui affiche la table de multiplication de 1 à 10 d'un nombre N quelconque saisi par l'utilisateur.

Tableau 1. Table de multiplication

*12345678910
4481216202428323640

Exercices sur les boucles : saisie contrôlée

Exercice 10 : Reprenez le programme 03_projetAlternativesMultipes/codageHumain et ajouter un contrôle sur chaque saisie : la saisie recommence tant que l'utilisateur ne saisit pas une valeur cohérente.

Exercice 11 : Reprenez le programme tableMultiplication. Modifiez le de façon à ce que le programme marque une pause après l'affichage de la table, puis efface l'écran et redemande à l'utilsiateur quelle table afficher. Pour quitter, l'utilisateur devra saisir une valeur remarquable, que vous lui indiquerez et que vous intègrerez dans la contrpole de saisie.

Exercices approfondis sur les boucles

Exercice 12 : Ecrivez le programme moyenne qui calcule la moyenne de n notes. Le nombre de notes est demandé au préalable à l'utilisateur.

Exercice 13 : Ecrivez le programme moyennePlus qui calcule la moyenne de n notes. Le nombre de notes n'est pas demandé au préalable à l'utilisateur. La saisie des notes s'arrête lorsque l'utilisateur saisi une note égale à 99.

Exercice 14 : Ecrivez le programme bin2dec qui converti un nombre binaire en décimal. Le nombre binaire est saisi comme un entier.

Exercice 15 : Ecrivez le programme ASCII qui affiche le contenu de la table ASCII (à partir du caractère n°32). Vous affichez le code ASCII, suivi du caractère correspondant.

Exemple 13. Afficher un caractère d'après son code ASCII

	char caractere;
	caractere=48;
	cout<<endl<<"Le caractère de code ASCII 48 est "<<car<<endl; 

Exercice 16 : Ecrivez le programme ASCIIRangée qui fait la même chose que précédemment, mais qui 10 caractères précédé de leur code ASCII par ligne, espacés d'une tabluation.

Exemple 14. Cadrer un affichage avec des tabulations

	cout<<endl<<"début \t milieu \t fin"<<endl; 

Exercice 17 : Ecrivez le programme testIntMax qui affiche les 10 nombres entiers de type int après 32 760. D'après ce qui a été dit en cours sur les variables de type int, que concluez-vous ?

Exercice 18 : Ecrivez le programme compareIntLong qui affiche les 10 nombres entiers de type int puis long après 2 147 483 640. Qu'en déduisez-vous ?

Exercice 19 : Ecrivez le programme valeursIntExtremes qui affiche les 10 nombres entiers de type int avant 2 147 483 640 et après 2 147 483 640. Qu'en déduisez-vous ?

Les tableaux


Introduction: pourquoi les tableaux

Une variable sert à mémoriser une valeur. Ainsi, si l'on doit mémoriser une note, on crée une variable "note". Mais que se passe-t-il si l'on doit mémoriser 2 notes ? On crée deux variables : note1 et note2. Imaginons maintenant que l'on ait 45 notes à mémoriser, il serait fastidieux de créer 45 variables. La solution est de créer un tableau de 45 notes. Il y a plusieurs types de tableau : les vieux tableaux statiques dont la taille est fixée àla déclaration du tableau, et les jeunes tableaux dynamiques dont la taille varie au fur et à mesure qu'on les rempli. Nous nous intéresserons tout d'abord aux vieux tableaux statiques.

Ce qu'il faut savoir sur les tableaux

Un tableau est une structure de donnée permettant de stocker un ensemble de valeurs du même type. Chaque case du tableau est une variable. Un tableau a une dimension (1,2,3).

Un tableau a un nom, un type (celui des valeurs qu'il va contenir) et un nombre de cases. Ce nombre de cases est fixé lors de la déclaration du tableau.

Déclaration d'un tableau de dimension 1:

	long tabNotes[45]; //déclaration du tableau tabNotes tableau de 45 entiers				
			

Le tableau s'appelle tabNotes, c'est un tableau d'entiers, il comporte 45 cases et contient donc d'ores et déjà 45 valeurs indéterminées (?).

Les cases du tableau ont un indice : il s'agit de leur position dans le tableau, la première case du tableau a l'indice 0 tandis que la dernière a l'indice 44.

Chaque case se comporte exactement comme une variable, toutes les opérations exercées sur les variables sont donc reproductibles sur les cases d'un tableau.

Exemple 18. Déclaration et accès aux cases d'un tableau.

	//affectation
	tabNotes[2]=20;
	//utilisation dans des opérations:
	somme=somme+tabNotes[3];
	//accueillir une saisie
	cout<<"Veuillez saisir la note n°10 : ";
	cin>>tabNotes[9];
				

Algorithmes de base sur les tableaux

Affichage de toutes les cases d'un tableau

Saisie de toutes les cases d'un tableau

Recherche d'une valeur dans un tableau et affichage de son indice

Tri d'un tableau

Correspondances entre tableaux par indice

Tableaux surdimensionnés et gestion du nombre de cases remplies

Suppression d'un element dans un tableau

Insertion dans un tableau trié

Exercices de base sur les tableaux

Travail à faire : Créez un dossier nommé 06_projetTableaux dans IG1_C++. Dans les exercices ci-dessous, le nom indiqué pour chaque programme servira pour le programme source .cpp et pour le programme l'exécutable généré lors de la compilation.

Exercice 1 : Ecrire le programme notes qui fait saisir 30 notes dans un tableau puis affiche le contenu du tableau

Exercice 2 : Reprendre l'exercice précédent et ajouter une partie qui trouve la note maxima