introduction:

le langage de programmation utilisé est le C++ qui nous génère le code machine
après compilation. ce dernier permis à la fois la programmation ordinaire classique ainsi que
la programmation orientée objet qui est notre objectif final, pour atteindre ce dernier on
envisage le plan de travail suivant:

1/en premier lieu on va se familiariser(création est exécution des projets) avec l'EDI
(Environnement de Développement Intégré) qui est code::blocks par le codage des petits
programmes simples dans une seule fenêtre (un seule fichier).

2/ on essaye d'introduire le concept des méthodes typées et non typées.

3/en troisième étape on essaye de restructurer le même code sous forme de classe dans la
même fenêtre (un seule fichier).

4/dans cette étape on essaye d'introduire la notion des méthodes déportées (typées ou non
typées) qui permet de séparer la définition de l'implémentation des méthodes (la définition
arrive en premier lieu. toujours un seul projet (programme) une seule fenêtre (un seul
fichier).

5/ en exploitant les méthodes déportées on sépare la classe en deux partie l'entête portant
la définition des membres sans corps et deuxième partie arrivent les corps proprement dit.

(toujours un fichier par projet)

6/en dernière étape on sépare les classes dans des fichiers distincts (deux fichiers par classe
un pour l'entête classe.h et l'autre pour le corps classe.cpp) et le projet portant la méthode
(main) dans un fichier autonome, alors c'est la compilation séparée.

TP N°1:

objectif: à la fin de cette manipulation l'étudiant doit se familiariser avec l'EDI code::blocks
(création est exécution des projets)

1/validation des instructions simples.

2/validation des méthodes typées.

3/validations des méthodes non typées.

Déroulement:

alors on commence par le codage d'une instruction "cout" permettant de dégager un

texte à l'écran. en suite on essaye de générer le même travail dans une méthode en deux
alternatives (typée et non typée).
 une méthode est un sous programme qui contient un nom et un corps; elle existe en
deux formes:

la méthode typée dont le nom de la méthode est précédé par un type est clôturé par
un résultat du même type après le mot clé return.

syntaxe: type1 nom_méthode() {

corps de la méthode "ensemble d'instructions"

return type1 R; }

la méthode non typée dont le nom de la méthode est précédé par le mot clé void n'a aucun
type de retour.

syntaxe: void nom_méthode() {

corps de la méthode "ensemble d'instruction"

Rq: l'exécution et la validation des instructions et des méthodes se déroule au niveau de la

méthode principale main() dont la syntaxe:

int main () {

dans ce corps on peut tester toutes les validations

return 0; }

le logiciel interface qui nous permis toutes ces manipulation et qui nous facilite beaucoup de
développement appelé IDE "code::blocks"

lancer l'EDI (Environnement de Développement Intégré) code::blocks

cliquez sur new projet et tapez le nom du projet ainsi que le répertoire de travail ("bureau"
par défaut)

Rq: ne laissez pas d'espace dans les noms

Alors un projet de base est crée portant le nom saisi, cliquez sur source et valider le fichier
main.cpp pour le visualiser, en fin compiler puis exécuter le projet s'il y a pas d'erreur.

#include <iostream> //l'introduction de l'unité flux d'entré sortie

using namespace std; //utiliser l'espace des mots clés standard

int main() // méthode typée (ici type int-entier- principale "exécutable" nommée-main-

{ //début du corps de la méthode.

 cout << "Hello world!" << endl; //sortir un texte à l'écran par la fonction "cout"

return 0; // fin de la méthode typée (ici 0 pour le bon déroulement d'exécution de la

méthode)

} // fin du corps de la méthode

deuxième alternative

#include <iostream>

#include <string> // introduction de l'unité chaine de caractère

using namespace std;

string accueil() { // méthode typée (de type string) nommée accueil().

return "Hello word!"; //retournant un résultat de même type (string)

//validation de la méthode accueil();

int main()

cout <<accueil()<< endl;

return 0;

//3ème alternative

#include <iostream>

#include <string>

using namespace std;

string h; //déclaration d'une variable h de type string.

void accueil() { méthode non typée (void) nommée accueil().

h="Hello word!"; //instruction d'affectation à h d'une chaine de caractère" Hello word!".

}
int main()

accueil(); /appel de la méthode accueil();

cout <<h<< endl; // affichage du contenu de h à l'écran.

return 0;