INTRODUCTION AU C++

Le C++ est un langage parmi d'autres. Tous ne sont pas équivalents et peuvent avoir des utilisations différentes. Je te propose ici de te donner quelques informations qui te permettront de mieux orienter ton apprentissage. Tu sais c'est la partie chiante d'un cours quand le prof commence à raconter sa vie...

L'historique

Toutes les machines qui nous entourent fonctionnent grâce à des suites d'impulsions (des bits en base 2: "0" ou "1"). Les premiers programmeurs codaient directement leurs instructions en binaire. Afin de faciliter la communication entre le développeur et la machine, il fut nécessaire de développer une interface, un langage.

Dans un premier temps vinrent des langages bas niveau: les assembleurs. Ces langages sont spécifiques à chaque machine et s'adressent directement aux composants constituant celle-ci. C'est en fait une traduction directe du train binaire en instructions simples. (ex: charger en mémoire une valeur, lire une valeur, faire une addition,...)

Ensuite, dans un souci de simplicité, les langages devinrent de plus en plus complexes, proches de l'anglais écrit. Se succédèrent alors: BASIC, COBOL, FORTRAN. Notons que plus un langage est dit évolué plus il devient spécifique et facile d'utilisation (nous parlons ici uniquement de la syntaxe).

En 1972, Dennis Ritchie créa le C ancêtre du C++. Ce langage peut être qualifié à la fois de bas niveau car il permet de faire appel à toutes les ressources de la machine mais aussi de langage évolué. En effet, il introduit une syntaxe assez complexe par rapport aux langages précités ainsi que de nombreuses fonctions évoluées. Ces fonctions sont regroupées en librairies que tu peux considérer comme des boîtes à outils.

La mise à jour la plus marquante du C fut apportée par Bjarde Stroustup en 1982. Il y intégra la programmation objet. Le C++ est en fait une surcouche du C (C++ signifie une incrémentation du C). Il hérite donc de tous les outils du C.

Principe de la programmation objet

Trois générations de langage se sont succédés et coexistent encore aujourd'hui: les langages dits linéaires, modulaires puis objets.

Tous les premiers langages s'exécutaient de façon linéaire. Chaque ligne du programme était lue puis exécutée jusqu'à la dernière. Il était possible de faire des sauts ou des boucles mais le principe restait le même. Cette approche simpliste ne pouvait pas s'appliquer à des programmes complexes. De plus, les développeurs ne pouvaient pas réutiliser des outils déjà écrits. Le langage assembleur est un exemple de langage linéaire.

Afin, de réutiliser le code et d'éviter les redondances, les langages dits modulaires virent le jour. Le principe est de regrouper un ensemble d'instructions dans des fonctions ou procédures. En effet, chaque tâche exécutée par un programme représente un nombre variable d'instructions. Ces instructions sont réunies afin de pouvoir segmenter le code et de favoriser la réutilisation de celui-ci. Le C fait partie de ces langages.

Enfin, la méthode objet apparue. Elle est en fait une évolution de l'approche modulaire. Elle lui apporte principalement trois aspects primordiaux:

• L'encapsulation: cette technique permet de réunir des variables et des fonctions au sein d'une même entité nommée classe. Les variables sont appelées les données membres, les fonctions sont appelées les méthodes. L'accès aux données et méthodes peut-être aussi réglementé.

• L'héritage: cette technique permet de définir une hiérarchie de classe. Chaque classe fille hérite des méthodes et des données de ces "pères". En pratique, la classe de base est une classe générique, ainsi plus on descend dans la hiérarchie, plus on spécialise cette classe.

• Le polymorphisme (non ce n'est pas un gros mot!): nous verrons que les objets sont définis par leur classe (sorte de moule). Pour expliquer le polymorphisme, retenons que deux objets, héritant une même méthode d'une classe parente, peuvent réagir de façon différente à l'appel de cette méthode. Par analogie, nous pouvons considérer l'exemple débile de l'ascenseur et de la bombe nucléaire... ben oui... Ces deux objets descendent de l'objet machine et donc héritent de la fameuse fonction "bouton rouge" que chaque machine possède. Maintenant, je te mets au défi d'appuyer sur le bouton rouge d'un ascenseur: c'est beaucoup plus violent que pour la bombe nucléaire. En effet, dans le cas de la bombe H, elle pète loin de toi sur un atol de Polynésie, alors que les coups de balais de ton gardien qui te coure dans la cage d'escalier, ça tu les sens!L'appel de la même fonction a donc entraîné un comportement différent.

Au cas où tu n'aies pas suivi les dernières notions, ne t'inquiète pas. Premièrement, rappelle toi que tu es un (gros) nul et fier de l'être : NULL POWER, deuxièmement ces notions sont vues en détail dans la partie 2 du cours.

Quel type d'utilisation?

Saches tout d'abord que le C++ est le langage le plus utilisé par la communauté des développeurs. Ce langage est utilisé aussi bien sur UNIX que MacOS ou Windows. Entre autres, la plupart des applications graphiques comportent une partie en C++, ce qui inclut les traitements de textes, utilitaires, jeux,...Toutefois, il ne faut pas croire que tout est possible avec le C++ ou au contraire que c'est un langage dépassé face au Java ou C#. Tu verras, si l'informatique devient ton métier, que l'on ne peut pas se limiter à un seul langage. Le choix du langage est souvent imposé par différents facteurs: portabilité, rapidité, disponibilité de composants déjà écrits, outils de développement,...

En fait, nous ne rentrerons pas dans un débat stérile afin de savoir quel langage est le plus avancé technologiquement. Le C++ est ici un choix d'apprentissage. En effet, à cause de sa conception le C++ hérite des langages modulaires et objets. Il n'est ni totalement objet ni restreint à un langage modulaire de type C. Ce conflit de génération qui rend le C++ un peu "bâtard" est un avantage pour les débutants. En fait, lorsque tu auras fini cet apprentissage tu auras la possibilité et la compétence de t'orienter tout seul vers le langage de ton choix.

Je te rappelle aussi que ce site à pour vocation de t'apprendre les bases de la programmation. Il n'a pour l'instant pas l'ambition de se spécialiser dans un sous-ensemble du C++. Il ne sera donc pas fait question d'environnement graphique ou de développement spécialisé dans une technologie donnée (Microsoft DirectX, Open GL, Linux, réseau,...)

Différence C/C++

Le C++ introduit un certain nombre d'améliorations syntaxiques, d'extensions et de nouveautés par rapport au C, dont les principales sont essentiellement liées à la programmation orientée objet. On peut décomposer le langage en C++=C+E+S+P avec:

• C désigne la norme AINSI C

• E représente les écarts à la norme

• S représente les spécificités de C++ non liées à la théorie objet

• P représente les possibililités de la programmation objet (la programmation objet n'est pas imposée)

Pour le néophyte, ces différences ne poseront aucun problème. Pour la personne qui sait déjà programmer en C, les quelques incompatibilités ou différences seront exposées tout le long du cours.

Conclusion

Une fois les connaissances de ce site acquises, il te sera facile de trouver des ouvrages permettant d'aller plus loin dans l'apprentissage du C++. Tu passeras alors du stade "gros nul" au stade "nul mais se soigne".

OUTILS DE PROGRAMMATION

Nous allons commencer par la prise en main d'un outil de programmation. Après ce cours tu pourras écrire un programme basique, le corriger (tout le monde ne s'appelle pas Billou), le compiler puis l'exécuter. C'est top, non?

Introduction

Les applications réalisées à partir de ce site se présenteront sous la forme d'une console du type Dos pour les adorateurs du WindowsPlanté et du MacOsTropCher.Quant aux fans de Linux ou autres Unix, nul besoin de leur présenter leur cher Shell. En fait, ces applications seront semblables à ce que l'on trouve sur calculette: les informations s'affichent sous forme de texte uniquement, le curseur clignotant te permet d'entrer des informations lorsque c'est nécessaire; la validation se fait grâce à la touche Enter.

Nous allons nous appuyer sur un outil appelé DevC++ qui a l'avantage d'être gratuit et très clair. Nul ne t'empêche d'utiliser un autre éditeur/compilateur. Pour trouver en une liste non exhaustive, cliquez ici. Et si tu cherches une assurance: par là, ou un site de funboard, par ici. Enfin si tu es décidé à aller plus loin ça se passe sur cette page! Non mais!

Compilation

On peut dès maintenant créer l'application correspondante. Pour cela, utilise le bouton compile ou dans le menu Execute clique sur Compile.

Cette fenêtre permet de voir l'évolution de la compilation des fichier C++.Pour lancer l'application ainsi créée, il suffit d'appuyer sur le bouton Execute.

Il ne se passe rien (une fenêtre apparaît puis disparaît)

L'application est créée dans le même dossier que le projet. Tu peux aussi la lancer en double cliquant sur son icône.

Premier Programme

Par tradition, tout apprentissage d'un nouveau langage commence par l'affichage du message "Hello World". C'est en fait l'opération la plus simple que l'on puisse apercevoir.Tape le code suivant ou récupère le fichier associé, puis compile à nouveau le projet (le fichier doit être inclus dans le projet et visible dans la fenêtre projet).

#include <iostream.h>#include <stdio.h>

void main(){

cout<<"Hello World!";

}

fichier > Hello World!

Tu peux voir très rapidement une fenêtre, avec le message Hello World, s'ouvrant puis se refermant. Pour que la fenêtre persiste, il suffit de rajouter la ligne suivante: getchar(); .Elle donne l'ordre au programme d'attendre que tu appuies sur une touche.

#include <iostream.h>#include <stdio.h>

void main(){

cout<<"Hello World!";getchar();

}

fichier > Hello World!>

Ne t'inquiète pas si tu ne comprend pas le code précédent, son explication est vue en détail dans le chapitre suivant.

Correction d'erreurs

Nous allons voir ce qui se passe si une erreur se glisse dans le code C++. Modifie le programme comme ci-dessous, puis compile-le:

#include <iostream.h>#include <stdio.h>

void main(){

cout<<"Hello World!"gtchar();

}

//le point virgule est manquant//la fonction est mal ecrite

fichier

> 7 outilprogrammation4.cpp parse error before '('

Lors de la compilation, Dev-C++ t'affiche 1 erreur à la ligne 7. "Parse error" signifie une erreur de syntaxe; cela est consécutif, la plupart du temps, à l'oubli d'un point-virgule ou d'une parenthèse.Ajoute à nouveau le point-virgule et compile:

> 7 outilprogrammation4.cpp implicit declaration of function `int gtchar(...)'

Une nouvelle erreur est signalée ligne 7. "Implicit declaration" signifie que la fonction concernée n'existe pas. En effet la fonction utilisée se nomme getchar() avec un "e". Modifie à nouveau le programme, la compilation ne présente alors plus de problème.

Conclusion

Voilà, il ne te reste plus qu'à explorer le logiciel pour compléter sa prise en main (une aide et un tutorial en anglais te sont fournis avec Dev-C++ 4). Pour commencer l'apprentissage du langage C++, en lui-même, je te propose le prochain chapitre: Premiers Pas.

PREMIERS PAS Nous y voilà! C'est un pas ridicule pour l'homme, mais un pas de géant pour des gros nuls comme nous! Tu rentres dans le monde merveilleux de la programmation et si tu viens à bout de ce chapitre sur les structures de base d'un programme en C++, tu auras le droit de... passer à l'étape suivante!

Les instructions:

Voici les éléments de base d'un programme écrit en C++:

#include <iostream.h>

void main(){

int grosNul; grosNul = 0;

char fin;cout<<"Appuyer sur une touche pour quitter!";cin>>fin;

}

//pour éviter que// l'application ne// quitte d'elle même

fichier>[ne

renvoie rien après compilation et exécution]>Appuyer sur une touche pour quitter!>

#include <iostream.h>Les premières lignes de code servent à introduire des informations utiles au compilateur: directive du préprocesseur. Ici on lui demande d'inclure la librairie iostream.h qui gère les fonctions standards d'entrée et de sortie d'informations (entrée/sortie). Ce sont les fonctions qui te permettront d'écrire à l'écran ou de rentrer des données par le clavier. De même, si on veut utiliser des fonction du type mathématique (cos, sin,...), il faudra inclure la bibliothèque math.h par le code: #include <math.h>.

void main()Ce sont des mots clefs introduisant le corps du programme principal. Sachez dès maintenant que void veut dire néant et que main veut dire principal. Tous programmes en C++ nécessitent un point d'entrée qui constitue la première fonction appelée dans ton programme: c'est le rôle de la fonction main(). Elle est appelée automatiquement lors de l'exécution du programme. Comme void l'indique notre fonction ne renvoie rien. Nous aurions pu choisir de renvoyer un entier en écrivant int main() par exemple. Mais ne sois pas pressé, ce point fait partie du cours sur les fonctions, alors patience!De plus, tu peux remarquer que main() est suivi de parenthèses. C'est le cas pour toutes fonctions. Les parenthèses servent à passer des arguments à la fonction, c'est-à-dire des données. Pour plus de détails et d'exemples concrets sur ce point tu peux encore aller jeter un oeil du côté des fonctions! Dans notre cas, les parenthèses sont vides, cela veut dire que notre fonction ne prend pas d'arguments, elle n'a besoin d'aucune donnée extérieure pour fonctionner.

{ }Le programme principal est délimité par les deux accolades, {}, une ouvrante, une fermante. Le contenu de ces deux accolades constitue un bloc d'instruction. Note qu'il est préférable lors de l'écriture du code de fermer une accolade juste après l'avoir ouverte. Ainsi, tu

éviteras de te poser les questions du type Pourquoi ça ne marche pas ? alors qu'il suffisait de fermer l'accolade!Comme dans l'exemple, l'alignement vertical et le décalage du code par rapport à celles-ci permettent aussi une lecture et un déboggage plus aisée du code. En pratique, utilise les tabulations qui te permettent d'aligner facilement ton code. Attention, cette convention n'est pas obligatoire, mais elle te facilitera la vie!

";"A l'intérieur d'un bloc d'instruction, chaque ligne se termine par un point virgule, ;. Chaque ligne représente alors une "phrase" indépendante des autres, interprétée séparément par le compilateur, appellée une instruction.

int grosNul;Cette instruction correspond à la déclaration d'une variable de type int (entier) nommée grosNul. Attention! Le C++ fait la différence entre les majuscules et les minuscules, les variables GrosNul et grosNul ne sont donc pas les mêmes: on dit que le C++ respecte la casse. Elles seront détaillées plus loin. Tu remarqueras que cette ligne se finit par un point virgule (;). C'est donc une instruction. L'absence du ; entraînerait une erreur de compilation.

La ligne suivante comporte l'initialisation de la variable grosNul à 0: l'entier grosNul contient maintenant 0. Remarque que le C++ ne tient pas compte des espaces: grosNul=0 signifie la même chose que grosNul = 0. Tu peux donc aérer ton code pour qu'il soit le plus lisible possible.

Ne prête pas attention aux 3 dernières lignes du programme. Tu les comprendras par la suite. Elles sont là seulement pour éviter que l'application ne se ferme d'elle-même. Il te suffit d'appuyer sur une touche pour quitter le programme.

Les commentaires:

Reprenons le même morceau de code:

#include <iostream.h>

void main(){

int grosNul; grosNul = 0;

char fin;cout<<"Appuyer sur une touche pour quitter!";cin>>fin;

}

//ne retourne rien

/* grosNul est un entier valant 0 */

//pour éviter que// l'application ne// quitte d'elle même

fichier>[ne

renvoie rien après compilation et exécution]>Appuyer sur une touche pour quitter!>

Par rapport au premier code, nous avons ajouté des lignes qui apparemment ne servent à rien. Ce sont des commentaires. Ceux-ci sont pourtant fondamentaux dans un programme. Un développeur un peu moins nul doit s'assurer que son code est suffisamment clair et explicite pour qu'un autre programmeur puisse le lire et éventuellement le modifier. Tu dois

donc commenter en détail ton programme pour qu'il soit lisible pour les autres, mais aussi pour toi (après un mois de bronzette au soleil et de perte de neurones, tu auras du mal à comprendre ton code s'il n'y a aucun commentaire !).

Les commentaires sont ignorés par le compilateur. Il en existe deux sortes en C++ :

• pour une ligne : // le commentaire sera ce qui suit sur un même ligne

• pour un ensemble de lignes : /* le commentaire sera tout ce qui est entre les caractères slash et étoile sur plusieurs lignes*/

Les flux d'entrées et de sorties

Les flux d'entrée et de sortie vont nous permettre d'entrer des valeurs au clavier ou bien d'en afficher à l'écran. Bon, au lieu de regarder un code tout fait et d'avoir la solution tout de suite, construisons ensemble notre programme. Entre nuls, on arrivera peut-être à avancer!Alors, nous allons afficher une phrase à l'écran. Pour cela, si tu as été attentif plus haut, nous avons tout d'abord besoin de la bibliothèque gérant les entrées/sorties : iostream.h. Le code commence donc ainsi:

#include <iostream.h>

void main(){

}

Maintenant, nous avons besoin d'afficher des instructions. Nous utiliserons la fonction cout de l'anglais output: sortie (prononcé cé a outte). Elle se construit comme suit:

cout << element1 <<...<< elementn;

Tout ce qui suit << est affiché à l'écran. Si element1 est une variable, la valeur de cette variable s'affichera (0 pour notre variable grosNul). Nous pouvons aussi remplacer element1 par une chaîne de caractères, c'est-à-dire un mot ou une phrase, qui doit être nécessairement entre guillemets " ". Notre code peut donc se continuer de la manière suivante:

#include <iostream.h>

void main(){

cout << " Bienvenue sur C++ pour les (gros) nuls " << endl ;

char fin;cout<<"Appuyer sur une touche pour quitter!";cin>>fin;

}fichier >Bienvenue sur C++

pour les (gros) nuls>Appuyer sur une touche pour quitter!>

Remarque qu'après la première instruction, nous en avons rajouté une seconde: endl (end lign) qui réalise un retour à la ligne. De plus, certains caractères spéciaux ne sont pas compréhensibles par le compilateur tel quel. Ainsi, pour effectuer un retour à la ligne à l'intérieur de la chaîne de caractère, il faudra inclure \n et pour inclure un guillemet, \". Par exemple:

#include <iostream.h>

void main(){

cout << "Les \"nuls\" sont parmi nous!\nLes nulles aussi!" << endl ;

char fin;cout<<"Appuyer sur une touche pour quitter!";cin>>fin;

}fichier >Les "nuls" sont

parmi nous! (\n= retour à la ligne)>Les nulles aussi!>Appuyer sur une touche pour quitter!>

D'autre part, dans tout programme qui se respecte, il y a une interaction entre l'utilisateur et la machine. Pour saisir un élément puis l'utiliser ultérieurement, nous utiliserons alors ici la fonction cin de l'anglais input: entrée. Elle se construit comme suit:

cin >> element1 >> element2;

Attention, pour saisir une variable element1, tu dois l'avoir définie auparavant dans ton programme. Après l'avoir récupérée, tu pourras l'utiliser dans la suite du programme.Note bien que cout est suivi de << et cin de >>, << et >> vont dans le sens du flux.

Voyons un exemple de saisie:

#include <iostream.h>

void main(){

int grosNul;

cin >> grosNul;

cout <<"Un (gros) nul vaut: "<<grosNul<<endl;

char fin;cout<<"Appuyer sur une touche pour quitter!";cin>>fin;

}

//définition de la variable

//saisie d'une valeur au clavier//(par exemple 0)//affichage

//pour éviter que// l'application ne// quitte d'elle même

fichier

>0 (saisie)>Un gros nul vaut: 0 (sortie + retour à la ligne)>Appuyer sur une touche pour quitter!>

Je pense que tu as compris maintenant le fonctionnement les 3 dernières lignes du programme. En effet, après avoir déclaré la variable fin de type char (caractère), celui-ci affiche à l'écran le message "Appuyer sur une touche pour quitter!" et attend que l'utilisateur saisisse un élément. Lorsque tu appuieras sur une touche, le programme quittera alors automatiquement.

Bonus

Maintenant que tu as assimilé et compris toute la base de la base du C++, va faire quelques exercices ! Tu verras, après tu te sentiras beaucoup moins nul, et en plus, ils sont corrigés, alors tu n'as vraiment rien à craindre!

• Exercice n°1: As-tu bonne mémoire? • Exercice n°2: Trouve l'erreur! • Exercice n°3: Qu'est ce que je renvoie? • Exercice n°4: Affiche à l'écran. • Exercice n°5: Petit problème de géométrie...

Si ça ne te suffit pas, tu as le droit à des petits bonus!

• La notation hongroise.

Si tu maîtrises le sujet, tu peux passer à l'étape suivante qui fera de toi un moins nul parmi les gros nuls: les variables.

C++ pour les (gros) nuls http://www.cplusnul.com exercice@cplusnul.com Premiers pas 2001 As tu une bonne mémoire?

/////////////// Enoncé ///////////////------------------------------------------------------------------------------

Serais-tu capable de réécrire le premier programme du cours, qui consistait à initialiser un entier nomme grosNul à zéro?

//////////////////Indiquation //////////////////------------------------------------------------------------------------------Afin de verifier ton résultat, compile ton code pour en faire un executable ouregarde la solution indiquée plus bas.Tu peux télécharger le fichier en faisant un "clique droit> enregistrer la cible sous..." sur le lien "Sources" en dessous de la fenêtre de dialogue.

///////////////Solution ///////////////----------------------------------------------------------------------------*/

#include <iostream.h>

void main(){

int grosNul; //declaration de la variable grosNul = 0; //initialisation de la variable

//pour que l'application ne quitte pas seule

char a;cout<<"Appuyer sur une touche pour quitter!";cin>>a;

}

/*------------------------------ EOF ---------------------------------------*/

http://www.cplusnul.com exercice@cplusnul.com Premiers pas 2001 Trouve l'erreur!

/////////////// Enoncé ///////////////------------------------------------------------------------------------------

Voici un programme. Celui-ci doit m'écrire un message à l'écran. Il y a une erreur, laquelle? */

#include <iostream.h>

void main(){

/*Message de bienvenuecout << " Bienvenue sur C++ pour les (gros) nuls!" << endl ; */

//pour que l'application ne quitte pas seulechar a;cout<<"Appuyer sur une touche pour quitter!";cin>>a;

}

/*///////////////Solution ///////////////------------------------------------------------------------------------------*/

//Les commentaires /* */ englobent le flux de sorties cout. //Il n'est donc pas pris en compte par le compilateur et le programme n'affiche rien à l'écran.

C++ pour les (gros) nuls http://www.cplusnul.com exercice@cplusnul.com Premiers pas 2001 Qu'est ce que je renvoie?

/////////////// Enoncé ///////////////------------------------------------------------------------------------------

Que renvoie à l'écran ce programme?

#include <iostream.h>

void main() {

int a=4;cout <<"a vaut: "<< a <<endl;

//pour que l'application ne quitte pas seulechar c;cout<<"Appuyer sur une touche pour quitter!";cin>>c;

}

///////////////Solution ///////////////----------------------------------------------------------------------------*/

//Ce programme écrit à l'écran: "a vaut: 4", retourne à la ligne et écrit://"Appuyer sur une touche pour quitter!".

/*------------------------------ EOF ---------------------------------------*/

C++ pour les (gros) nuls http://www.cplusnul.com exercice@cplusnul.com Premiers pas 2001 Petit Problème de géométrie

/////////////// Enoncé ///////////////------------------------------------------------------------------------------

Afficher à l'écran la valeur du périmètre d'un cercle. La valeur du rayon de ce cercle devra être saisi au clavier lors du lancement du programme.

//////////////////Indiquation //////////////////------------------------------------------------------------------------------L'équation donnant la valeur du périmètre d'un cercle est: P=2*Pi*R.Le type d'un nombre réel (comportant des décimales) est le type "double".

///////////////Solution ///////////////----------------------------------------------------------------------------*/

#include <iostream.h>

void main(){

double Rayon, Pi; //définition des données: double=réel Pi = 3.14;

cin>>Rayon; //saisi de la valeur du rayon cout <<"le perimetre est "<<2*Pi*Rayon<<endl;

//pour que l'application ne quitte pas seulechar a;cout<<"Appuyer sur une touche pour quitter!";cin>>a;

}

/*------------------------------ EOF ---------------------------------------*/

LES VARIABLESTout programme informatique nécessite de stocker et de manipuler des informations. Ces informations peuvent être de plusieurs types comme le nom de ton chat dans un programme de gestion d'animaux domestiques (très utile), une date, un nombre,… Les variables ont pour but de satisfaire ce besoin.

Définition

Une variable est une zone de mémoire réservée possédant plusieurs attributs :

• Un nom : c'est un identifiant permettant de faire référence à cette zone mémoire. L'appel de ce nom sera substitué par sa valeur par l'ordinateur.

• Un type : c'est une propriété définissant quels types de données peuvent être stockées dans une variable. Cela peut être un nombre, un caractère,…

• Une taille : à un type correspond généralement une taille de mémoire maximum pouvant contenir la valeur de cette variable. Cette taille est exprimée en bit.

• Une valeur : c'est l'information qui nécessite d'être stockée, comme le nom de ton chat.

• Une portée: c'est le domaine de validité des varaibles. Ce point est vu plus en détail à la fin du chapitre.

-C'est bien beau tout cela, mais comment définit-on une variable ? -Est-ce que c'est l'endroit pour répondre à de telles questions ? Il y a quand même des sujets plus importants dans le monde : la libération des bébés phoques du zoo de Vincennes, l'entartrage de Billou ou les discussions philosophiques sur la légitimité du couteau dans le pot de Nutella.-Ben oui, c'est le lieu ! Alors fait pas [censuré] tu es là pour apprendre !

Pour déclarer une variable, on utilise la syntaxe suivante :

type1 nomVariable;

type2 nomVariable1, nomVariable2,...,nomVariableN;

//déclaration de la variable "nomVariable"

//définition de plusieurs variables à la suite

typeN est le type de la variable ; il définit la nature des données qu'elle peut recevoir. nomVariableN représente le nom servant à y faire référence. On peut comme dans l'exemple déclarer plusieurs variables de suite à condition qu'elles soient du même type. On les sépare alors par une virgule. Notons aussi que deux variables ne peuvent pas avoir le même nom même si elles sont de types différents.

Pour l'initialisation d'une variable, on utilise la syntaxe suivante :

type1 nomVariable = valeur;

type2 Variable;Variable = valeur;

type3 nomVariable1 = valeur1, nomVariable2 = valeur2;

//initialisation d'une variable

//autre possibilité

//initialisation de plusieurs variables à la suite

L'affectation d'une valeur à une variable s'effectue, pour les types simples, grâce à l'opérateur =. La valeur affectée à la variable doit respecter son type et sa taille. Enfin, comme indiqué, il est possible d'initialiser plusieurs variables successivement.Notons aussi que l'initialisation d'une variable, préalablement déclarée, est obligatoire pour permettre la compilation d'un code. C'est à dire que l'on ne peut pas déclarer une variable qui ne sert à rien.

Le nommage des variables ne respecte pas de règle particulière hormis l'exclusion des espaces et des caractères accentués. Pourtant il est généralement conseillé de respecter des règles de normalisation: voir notation Hongroise.

Les types simples

Nous avons vu que toute variable possède un type. Par défaut, plusieurs types simples sont prédéfinis comme les entiers, les caractères ou les décimaux. Toutefois, il est possible de définir son propre type; mais ne mettons pas le traîneau avant les rennes:

Mot Clef Type Taille Intervalle Exemple

int entier 16 bits -32768 à 32768 int i=2;

char caractère 8 bits -128 à 127 (ASCII) char lettre='a';

float réel 32 bits

3.4e-38 à 3.4e+38 float Pi=3.14;

double réel 64 bits

1.7e-308 à 1.7e+308 double alpha=0.001;

unsigned int entier 16 bits 0 à 65535 unsigned int absolu=0;

unsigned char caractère 8 bits 0 à 255 (ASCII) unsigned char enter='/n';

long int entier 32 bits

-2.15e-9 à 2.15e+9 long int grand=33700;

long double réel 80 bits

3.4e-4932 à 1.1e+4932

long double tresGrand=39565655.2323565;

L'initialisation d'une variable de type char se fait avec la valeur entre simple guillemet: '. De façon générale, un caractère est représenté par sa valeur entre guillemets ou sa valeur numérique correspondante: voir ASCII . Le tableau des types exposés plus haut n'est pas exhaustif. En effet, on peut tout à fait combiner un mot clef du type short (court), unsigned (valeur absolue), long (long) avec un des types primaires char, int, float ou double. De plus, il n'est pas nécessaire de tous les retenir, saches seulement les utiliser à bon escient. Le choix de type doit dépendre de la nature de l'information à stocker et de l'intervalle des valeurs possibles.

#include <iostream.h>

void main(){

int entier= 235,k=9;char a, lettre='b';a='B';

cout<<"Un chiffre: "<<entier<<endl;cout<<"Un caractere: "<<lettre<<endl;

cout<<"Appuyer sur une touche pour quitter!";cin>>a;

}

//initialisation d'entiers et de caractères

//affichage de leur valeur

//pour éviter que l'application ne quitte d'elle même

fichier

>Un chiffre: 235>Un caractere: b>Appuyer sur une touche pour quitter!>

Nous verrons tout au long du cours qu'il existe des types de variables plus complexes comme les tableaux, les classes, les structures et les énumérations.

Les opérations

Une information stockée dans une variable peut être lue mais aussi manipulée. En effet, on peut effectuer une grande quantité d'opération sur ces variables.

La réallocation : par défaut, une variable n'est pas une constante ; c'est à dire que sa valeur peut être modifiée. Pour réallouer une variable on utilise l'opérateur d'initialisation, généralement =.

#include <iostream.h>

void main(){

int entier= 235;entier=0;

cout<<"La valeur de \"entier\" est: : "<<entier<<endl;

cout<<"Appuyer sur une touche pour quitter!";cin>>entier;

}

//allocation de la variable entier//modification de sa valeur

//affichage

fichier>La

valeur de "entier" est: 0>Appuyer sur une touche pour quitter!>

Si on désire imposer la constance d'une variable grâce au mot clef const, alors cette opération de réallocation n'est plus possible.

Opération arithmétique : une opération arithmétique est une instruction permettant de stocker le résultat d'une opération arithmétique dans une variable, de l'afficher à l'écran ou bien d'autres jolies choses encore. Par exemple, a=1+2 ; est une opération arithmétique dont les opérandes sont 1 et 2 et dont l'opérateur est +. Les opérateurs arithmétiques existants sont les suivants:

Mot Clef Signification Exemple + addition int i=2+3; - soustraction float alpha=2-0.3; * multiplication float P; int R=2; P=2*3.14*R; / division int j=2/3; //j est égal à 0 car j est un entier

%modulo

(reste de la division)

int j=2%3; //j est égal à 2

Le résultat de la division de deux entiers donne un autre entier. Dans notre exemple, 2/3=0.667 en réalité; pourtant la valeur retournée dans j est la valeur 0 car j est un entier (int) qui ne peut pas recevoir de valeur décimale. De plus, l'opérateur % permet de récupérer le reste de cette division entière. Le signe % s'applique uniquement aux entiers (int). Si tu essayes de compiler l'expression suivante: int j=2%0.5; le compilateur t'indiquera une erreur.

Les opérandes de toutes ces expressions peuvent être des constantes, des variables, des résultats d'autres opérations ou des valeurs retournées par des fonctions. Pour faciliter, la lecture d'expressions pouvant être parfois très complexes, il est recommandé d'utiliser les parenthèses aussi souvent que possible.

#include <iostream.h>

void main(){

int a= 1,b=3,c=1;double racine1=0,racine2=0;

racine1=(-b-sqrt(b*b-4*a*c))/(2*a);racine2=(-b+sqrt(b*b-4*a*c))/(2*a);

cout<<"Les racines du polynome "<<a<<"x2+"<<b<<"x+"<<c<<" sont: "<<endl;cout<<racine1<<endl<<racine2<<endl;

cout<<"Appuyer sur une touche pour quitter!";cin>>a;

}

//allocation des variables

//operation arithmétique//sqrt() est la fonction racine carre

//affichage des racines d'un polynome du second degré

fichier

>Les racines du polynome 1x2+3x+1 sont:>-2.61803>-0.38196>Appuyer sur une touche pour quitter!>

Opération logique: ce type d'expression permet de stocker le résultat d'une opération logique dans une variable. Ce résultat peut prendre deux états booléens: vrai (différent de 0) ou faux (égal à 0). C'est à dire que lors de l'exécution du programme l'ordinateur va évaluer si l'expression est vraie ou fausse. Par exemple, 3>2 est une expression ayant comme opérateur logique le signe > ; cette expression renvoie le booléen Vrai (1). Les opérateurs logiques existant sont les suivants:

Mot Clef Signification Exemple < inférieur à int resultat=2<3; //resultat=1 c'est vrai

<= inférieur ou égal à int resultat=(2.5<=(6/2)); //resultat=1 c'est

vrai > supérieur à int resultat=2>3; //resultat=0 c'est faux

>= supérieur ou égal à int resultat=(2>=(4/2)); //resultat=1 c'est vrai

== égal à int resultat=2==3; //resultat=0 c'est faux

&& ET logique int resultat=(2==2) && (3==2); //resultat=0 c'est faux

|| OU logique int resultat=(2==2) || (3==2); //resultat=1 c'est vrai

!= différent de int resultat=2!=3; //resultat=1 c'est vrai

Ces opérateurs sont très utiles dans le cas des boucles et branchements conditionnels vus plus tard.

Opération d'incrémentation et de décrémentation : ces opérateurs sont incontournables pour les langages dont la syntaxe est héritée du C, ce qui est le cas du C++. Derrière ce terme barbare (à prononcer avec un accent suédois) ce cache un mécanisme très simple. L'incrémentation est l'ajout de 1 à une variable numérique ou à un caractère, la décrémentation est la suppression de 1. Voilà la liste de ces opérateurs :

Mot Clef Syntaxe Equivalence ++ x++; x=x+1; ++ y=x++; y=x; puis x=x+1; ++ y=++x; x=x+1; puis y=x; -- x--; x=x-1; -- y=x--; y=x; puis x=x-1; -- y=--x; x=x-1; puis y=x;

L'incrémentation et la décrémentation peuvent être postfixées (après la variable) ou préfixées (avant la variable). Dans le cas où l'opérateur est préfixé, l'ajout ou la suppression se fait avant l'allocation donc pour un opérateur postfixé l'allocation se fait avant l'ajout ou la suppression. C'est assez bête dit comme cela mais c'est régulièrement source d'erreurs.

Entre nous, tu ne trouves pas qu'il est long ce chapitre? Je t'invite à de détendre un peu: prends une pause, ferme les yeux, pense à une île paradisiaque avec la femme ou l'homme de tes rêves... STOP! Faut pas déconner quand même, on n'est pas là pour rigoler, allez hop, exercices:

• Exercice n°1: Division euclidienne

• Exercice n°2: Incrementation

• Exercice n°3: Un peu de logique

Conversion

Tu as vu que chaque variable possède un type qui déterminera quel type de valeur il est susceptible de contenir. Il n'existe pas de mécanisme permettant de changer le type d'une variable, pourtant il est tout à fait possible de convertir une valeur et de stocker le résultat dans une variable de type adéquat. Prenons un exemple: imaginons que l'on veuille stocker la valeur entière de Pi (3) qui est un décimal (3,14..). Il suffit alors de convertir la valeur de Pi en entier (int) puis stocker cette valeur dans une autre variable de type entièr.Il existe trois mécanismes de conversion:

La conversion implicite: Tu vas dire que je t'agresse encore avec des mots savants. C'est en fait la conversion la plus simple car le compilateur se charge de la réaliser pour toi. Dans la plupart des cas, si tu essayes d'initialiser une variable avec une valeur qui ne correspond pas à son type, le compilateur fera la conversion de façon " implicite ".

#include <iostream.h>

void main(){

int entier= 3.14;

char caractere= 65;

int entier2='A';

double decimal=entier;

cout<<entier<<endl<<caractere<<endlentier2<<endl<<decimal<<endl;

cout<<"Appuyer sur une touche pour quitter!";cin>>caractere;

}

//float dans int

//int dans char

//char dans int

//int dans double

fichier >3>A>65 >3 (la perte de donnée est irrémédiable)>Appuyer sur une touche pour quitter!>

Attention, cette technique est à utiliser avec parcimonie (ouah moi aussi je fais des mots compliqués). Il n'y pas de problème lorsque l'on convertit implicitement un type de petite taille vers un type de taille supérieure (int vers float), alors que le contraire entraîne au moins une perte de donnée voire une aberration du résultat.

Le cast: Autrement appelé conversion explicite, cette technique permet de forcer une conversion. L'opérateur cast consiste à indiquer le type entre parenthèses devant la variable à convertir: type1 variable1=(type1)variable2. Voici un exemple de syntaxe:

#include <iostream.h>

void main(){

int entier= (int)3.14;

double decimal=6.56;int entier2=(int)decimal;

char caractere=(char)56;

cout<<entier<<endl<<decimal<<endl<<entier2<<endl<<caractere<<endl;

cout<<"Appuyer sur une touche pour quitter!";cin>>caractere;

}

//cast d'un decimal en entier

//cast d'un decimal en entier

//cast d'un entier en caractere

fichier

>3>6.56>6 >8 (56 est la valeur ASCII de '8')>Appuyer sur une touche pour quitter!>

Cette méthode est très utile dans l'emploi des fonctions et des objets. En effet, les fonctions vues plus tard imposent le type des arguments demandés et peuvent ne pas faire de conversion implicite. Néanmoins, je te conseille de l'utiliser le plus souvent possible: ton code sera plus intelligible et moins tu seras assisté par le compilateur mieux tu identifieras les erreurs.

Les fonctions de conversion: Tu verras l'utilisation des fonctions dans le chapitre suivant. Pourtant, sache qu'il existe des fonctions fournies avec tous les environnements C et C++ (fonctions standards). Certaines de ces fonctions te permettent de convertir des variables vers des types différents.Voici, un exemple que tu comprendras sûrement mieux grâce au chapitre suivant:

#include <iostream.h>

int ctoi(char a){

return (a-'0');

}void main(){

char caractere= '2';int entier1, entier2;

entier1=(int)caractere; entier2=ctoi(caractere);

cout<<entier1<<endl<<entier2<<endl;

cout<<"Appuyer sur une touche pour quitter!";cin>>caractere;

}

//cast d'un entier en caractere//utilisation d'une fonction

fichier >50 (le caractère '2' correspondant à la valeur ASCII 50)>2 (le caractère '2')>Appuyer sur une touche pour quitter!>

Dans cette exemple, la conversion explicite a seulement rangé le caractère '2' dans un type int, ce qui correspond à une valeur dans le tableau ASCII différente de '2'. La fonction de conversion int ctoi(char) a initialisé l'entier avec la valeur 2 et non sa représentation ASCII.

La portée d'une variable

Si tu as bonne mémoire (je sais je déconne:-) tu te rappelles qu'une variable possède un nom, un type, une taille, une valeur et une portée. Ce dernier point indique le domaine de validité d'une variable. Il dépend de l'endroit où est placée cette variable:

• en local: tous les exemples précédents et exercices utilisent ce type d'emplacement. Une variable est déclarée dans un bloc d'instructions: entre deux accolades. Cela peut être une fonction ou une boucle. La variable n'existe alors qu'entre ces deux accolades; au-delà la zone mémoire est effacée. La portée d'une variable locale est son bloc d'instruction.

#include <iostream.h>

void main(){

int variableLocale=1;cout<<variableLocale<<endl;{

int variableLocale=2;cout<<variableLocale<<endl;

}

cout<<variableLocale<<endl;

cout<<"Appuyer sur une touche pour quitter!";cin>>variableLocale;

}

//declaration dans un bloc

//declaration dans un autre bloc

//declaration dans le premier bloc

fichier

>1>2 (valeur locale au bloc)>1 >Appuyer sur une touche pour quitter!>

• en globale: la variable globale est déclarée en dehors de tout bloc. Elle est déclarée au début du fichier source; c'est d'ailleurs la seule instruction avec les directives préprocesseurs à être tolérée en dehors des blocs d'instructions (fonction). La portée d'une variable globale est tout le fichier où elle est déclarée.

#include <iostream.h>

char variableGlobale='a';

void main(){

cout<<"VariableGlobale: "<<variableGlobale<<endl;

cout<<"Appuyer sur une touche pour quitter!";cin>>variableGlobale;

}

//declaration en dehors du bloc

//appel

fichier >VariableGlobale: a>Appuyer sur une touche pour quitter!>

Il faut toutefois utiliser les variables globales avec modération car il y a des risques de conflits avec d'autres variables nommées de la même façon.

Bonus

Bon allez encore quelques exercices pour la route,... Pour ceux qui ne voient pas de quelle route je parle, passez votre chemin,... Et que je n'entende personne me poser la question sur le chemin!

• Exercice n°4: Conversion

• Exercice n°5: Valeur de la variable

• Exercice n°6: Récapitulatif

Si tu maîtrises le sujet, tu peux passer à l'étape suivante qui fera de toi un moyen nul parmi les gros nuls: les fonctions.

LES FONCTIONS

Les fonctions de la vie c'est un peu comme en C++, certaines personnes sont vouées à faire grève, d'autres à gagner du fric, beaucoup à faire chier le monde et enfin les meilleurs d'entre nous à devenir moins nul en C++. Le rapport avec le schmilblick : tu verras en lisant ce chapitre qu'il n'y en a aucun.

Introduction

Tu as vu dans l'introduction que le C++ hérite des outils du C, en particulier son aspect procédural. Cela consiste à découper le programme en une série de blocs d'instructions indépendants les uns des autres. Ces blocs sont les fonctions. Une fonction regroupe une ou plusieurs instructions qui permettent de réaliser une tâche précise qui peut se répéter plusieurs fois. Ainsi, un problème complexe peut être découpé en plusieurs sous problèmes, c'est-à-dire plusieurs fonctions.

Définition et Déclaration

Une fonction est un bloc d'instructions qui demande des informations passées en paramètres et qui retourne un seul résultat. Tu peux l'identifier au modèle des fonctions en mathématiques, même si ce n'est pas ta tasse de thé :

z = f(x1, x2,…,xn)

Pour réaliser une opération précise, la fonction f a besoin de données externes (x1, x2, …,xn). Le résultat de l'opération est stocké alors dans la variable z.En C++, la déclaration d'une fonction respecte la syntaxe suivante :

typeRetour nomFonction(type1 argument1, type2 argument2, …){

//instructionsreturn (variableRetour);

}

//declaration de la //fonction "nomFonction"

La définition d'une fonction se découpe donc en 5 éléments :

typeRetour : il s'agit du type de la variable retournée par la fonction, toujours placé avant le nom de celle-ci. Ce type peut correspondre aux types standards du C++ (int, char, double…) ou à d'autres types de données plus complexes vus dans les chapitres suivants.

nomFonction : c'est le nom grâce auquel tu pourras appeler la fonction dans ton programme. Ce nom doit être suffisamment explicite pour comprendre le but de la fonction. La première lettre doit être un caractère, les espaces et accents ne sont pas autorisés. (voir nommage)

(type1 argument1, type2 argument2, …) : tu déclares à cet endroit les arguments de la fonction. Ce sont des informations extérieures nécessaires à son fonctionnement. Il s'agit de variables dont la valeur peut être différente à chaque appel de la fonction. Elles sont donc placées entre parenthèses et séparées par des virgules. Tu dois préciser le type de chaque argument avant de donner son nom. Cependant, si la fonction ne prend pas de paramètres (c'est possible si sa tâche ne nécessite pas d'informations externes), on utilise le mot clé void entre les parenthèses. Ce mot clé est aussi sous-entendu si tu ne mets rien entre parenthèses. Par exemple tu peux écrire :

int fonction(void) ou int fonction()

Le bloc d'instructions : délimité entre accolades, tu peux y inclure tout type d'instructions. C'est le cœur de ta fonction.

return variableRetour; : Pour retourner le résultat de la fonction, on utilise le mot clé return suivi du nom de la variable. Il est utilisé en dernière ligne de la fonction. En effet, dès que ton programme rencontre ce type d'instruction, il quitte automatiquement la fonction. On verra par la suite que la valeur retournée peut être récupérée et utilisée dans la suite du programme.

Voici maintenant un exemple de déclaration de fonction. Je sais, il est temps ! Je t'aurais même proposé de prendre une pause si je n'avais pas un complexe de vieux dictateur raté.

int addition(int a, int b){

int resultat; resultat = a+b;

return (resultat);

}

// declaration d'un entier// operation arithmetique utilisant les arguments

// renvoi du resultat

fichier> (ne

renvoie rien après compilation)

Tu retrouves tous les éléments évoqués plus haut. En cas d'oubli de l'instruction return (resultat); , le compilateur provoque une erreur, sauf dans le cas des procédures. Mais qu'est ce que tu me racontes là (me dit Arnold !) ? Un procédure a les mêmes buts et caractéristiques qu'une fonction, sauf qu'elle ne renvoie pas de résultat et l'instruction return (resultat); est donc supprimée. Comme elle ne renvoie rien, le type de la variable de retour est donc remplacé toujours par le mot clé void :

#include <iostream.h>void affiche(void) {

cout << " Je suis une procédure " << endl ;

}

// ou void affiche() : declaration d'une// procedure sans parametres

// affichage d'un message a l'ecran

fichier> (ne

renvoie rien après compilation)

Ceci est donc une procédure qui, dans ce cas, ne prend pas de paramètres, elle se contente d'afficher un message à l'écran.

Appel d'une fonction

Pour appeler une fonction, ou l'exécuter, il suffit d'écrire dans ton programme son nom avec la valeur des ses arguments éventuels entre parenthèses, suivi d'un point virgule :nomFonction(argument1,argument2,argument3) ;Reprenons le premier exemple :

#include <iostream.h>int addition(int a, int b){

int resultat; resultat = a+b;

return (resultat);

}

void main(){

int x;int y=3;int z;int buf ;

x=addition(2,4) ;cout << "La valeur de x est " << x << endl ;z=addition(x,y) ;cout << "La valeur de z est " << z << endl ;cout << "z+1 vaut " << addition(z,1) << endl ;

cout<<"Appuyer sur une touche pour quitter!";cin>>buf;

}

// declaration d'un entier// operation arithmetique// utilisant les arguments // renvoi du resultat

// programme principal

// declarations d'entiers

//appels de la fonction et affichage//des resultats

// pour ne pas que l'application// quitte seule

fichier> La

valeur de x est 6 (2+4)> La valeur de z est 9 (6+3)> z+1 vaut 10 (9+1)> Appuyer sur une touche pour quitter!

Dans ce programme, nous avons donc fait plusieurs appels différents de la fonction addition. Dans le 1er appel, nous avons passé deux arguments de type entier (ici 2 et 4) comme la fonction le demande. Ces paramètres sont alors substitués aux mots clés des arguments (ici a et b) de la fonction pour faire le calcul. De plus, pour récupérer le résultat de l'addition, il suffit d'utiliser l'opérateur d'allocation =. La valeur renvoyée par la fonction est donc copiée dans x qui est bien un entier défini préalablement. N'oublie pas qu'à cause de la portée des variables, main ne peut pas avoir accès à la variable resultat de la fonction addition, c'est pourquoi il faut la récupérer dans une autre.

Les autres appels de la fonction montrent des méthodes différentes au niveau du passage des paramètres.Dans le 2ème appel, on passe directement des variables (ici x et y), mais de la même façon leurs valeurs sont recopiées dans les variables a et b de la fonction.Le 3ème appel est là pour te montrer que tu es assez libre dans ce passage d'argument et que dans le même appel tu peux passer une variable et une valeur entière numérique.La façon d'appeler ta fonction peut aussi être simplifiée. Dans la mesure où elle renvoie une valeur, tu peux afficher directement celle-ci grâce à l'instruction cout.

Le programme te permet bien de comprendre qu'une fonction est réutilisable et qu'elle t'évite ainsi d'écrire plusieurs fois le même code contenu dans la fonction. Ce principe facilite aussi la maintenance de ton code. En effet, supposons que la façon de faire une addition change demain, il te faudra juste modifier la méthode de calcul dans ta fonction, au lieu de la modifier plusieurs fois dans ton programme… Mais bon c'est comme les dents des poules !

Passage d'arguments par valeur et par référence

Le C++ te propose différentes techniques de passage d'arguments aux fonctions : le passage par valeur et le passage par référence.

[note de la rédaction: Si tu décides de passer ce stade et que tu prends le temps de comprendre le chapitre suivant, tu auras de ta propre volonté abandonné le piteuse état d'ignorance dans lequel tu te trouves. Les auteurs de ce site ne pourront en aucun cas être tenu responsable des fléaux qui peuvent s'en suivre. Dans l'éventualité d'une pluie de grenouilles ou d'une nuée de sauterelles, veuillez contacter immédiatement l'exorciste le plus proche de votre domicile.]

Passage par valeurJusqu'à maintenant, dans toutes les fonctions que nous avons vues, les paramètres étaient passés par valeur. Cela consiste à fournir à la fonction des copies des variables fournies en argument et non les variables elles-mêmes. Le programme fournit à la fonction uniquement la valeur de cette variable et non la case mémoire en elle-même.Prenons l'exemple d'une fonction qui modifie la valeur d'un de ses paramètres :

#include <iostream.h>void zorro(char lettre){

lettre = 'z' ;

}

void main(){

char x = 'a' ;int buf ;

cout << "Avant, la variable x vaut " << x << endl;zorro(x) ;cout << "Après, la variable x vaut " << x << endl;

cout << "Appuyer sur une touche pour quitter!";cin>>buf;

}

// declaration de la fonction// zorro qui modifie// le caractere passe en // parametre

// programme principal

// declaration et initialisation// d'un caractere

//appels de la fonction et affichage//des resultats

// pour ne pas que l'application// quitte seule

fichier>

Avant, la variable x vaut a> Après, la variable x vaut a> Appuyer sur une touche pour quitter!

Et non, ce n'est pas une erreur ! Tu remarques que la valeur de x n'a pas changé. C'est ce que je t'explique depuis une heure ! C'est parce que tu as fait un passage par valeur. A l'appel de la fonction zorro (désolé), la valeur de x ('a') a été recopiée dans la variable lettre. La valeur de lettre a été modifiée en 'z', mais x reste inchangé !Bon, mais comment faire alors pour modifier de cette façon une variable passée en argument ? Et bien continue de lire, c'est écrit…

Passage par référenceLors d'un passage par référence, tu peux manipuler à l'intérieur de la fonction la valeur d'une variable externe passée en paramètre. Pour pouvoir passer une variable par référence, rien de plus simple ! Il te suffit d'ajouter le symbole & devant un paramètre de ta fonction à la suite du type. Ce symbole permet de passer la variable elle-même et non une copie. Etudie l'exemple précédant modifié en conséquence :

#include <iostream.h>void zorro(char &lettre){

lettre = 'z' ;

}

void main(){

char x = 'a' ;int buf ;

cout << "Avant, la variable x vaut " << x << endl;zorro(x) ;cout << "Après, la variable x vaut " << x << endl;

cout << "Appuyer sur une touche pour quitter!";cin>>buf;

}

// declaration de la fonction// zorro qui modifie// la caractere passe en // parametre

// programme principal

// declaration et initialisation// d'un caractere

//appels de la fonction et affichage//des resultats

// pour ne pas que l'application// quitte seule

fichier>

Avant, la variable x vaut a> Après, la variable x vaut z> Appuyer sur une touche pour quitter!

C'est donc ici la variable x qui a été modifiée comme le montre l'affichage.

En conclusion, dans le premier exemple on a substitué la valeur de a dans lettre (passage par valeur), dans le deuxième exemple, on a remplacé la variable lettre par la variable a (passage par référence).

Prototype

Derrière ce nom hightech, se cache quelque chose de très simple. Tu as sans doute remarqué dans tous les exemples, que les fonctions étaient définies avant d'être appelées. Le main est laissé à la fin. Ceci pour la simple et bonne raison qu'une fonction doit toujours être "connue" par le programme avant d'être utilisée. Logique, me diras-tu! Sache en tout cas que si tu ne respectes pas cet ordre (vas-y, essaie !), le compilateur génère une erreur.Cependant, tu peux contourner ce problème et placer la définition de tes fonctions à la fin du programme ou dans un autre fichier. Pour cela, il existe les prototypes de fonctions. Il s'agit de donner une déclaration succincte de ta fonction, placée au début du programme, avant d'être appelée pour la première fois. Ainsi le compilateur a suffisamment d'informations (nombre et type des paramètres, de la variable de retour…) pour la reconnaître et ne pas générer d'erreur.

La syntaxe est la même que la 1ère ligne de la déclaration de la fonction :

typeRetour NomFonction(type1 argument1, type2 argument2, …);

outypeRetour NomFonction(type1, type2, …) ;

Mais tu remarques bien :

• il n'y a pas de bloc d'instructions, • le prototype se termine par un point virgule, • le nom des arguments est optionnel, le type suffit au compilateur.

Tu pourras tester cet exemple :

#include <iostream.h>

double calculPerimetre(double rayon);

void main(){

double r,p;int buf;cout << "Donner un rayon du cercle : " << endl;cin >> r ;p = calculPerimetre(r);cout << "Le perimetre est de : " << p << endl;cout<<"Appuyer sur une touche pour quitter!";cin>>buf;

}

double calculPerimetre(double rayon){

double Pi = 3.14;double perimetre;perimetre = 2*Pi*rayon;return (perimetre);

}

//prototype de la fonction

// programme principal

//appels de la fonction et affichage//du resultat// pour ne pas que l'application// quitte seule

//declaration de la fonction

fichier>

Donner un rayon du cercle :> 3 (valeur rentrée par l'utilisateur)> Le perimetre est de : 18.84> Appuyer sur une touche pour quitter!

Tu constates que tout se passe bien à la compilation et à l'exécution. Tu obtiendras le même résultat en inversant main et calculPerimetre. Mais je devine ta question : à quoi ça sert ? C'est vrai, on pourrait aussi bien laisser les fonctions au début. En fait, c'est surtout une question de lisibilité de ton programme. Si tu places toutes tes fonctions au début, il manquera de clarté et le main qui en est la partie principale sera repoussé tout en bas. De plus, cela te permet d'avoir une vue d'ensemble rapide des fonctions utilisées dans le programme.

Bon, je sens ton esprit un peu confus quant aux prototypes... allez, si tu veux, vas voir tout de suite le bonus: comment découper son code en C++ (construction)

Concepts avancés

Valeur par défautLe C++ te permet de donner des valeurs par défaut aux arguments des fonctions. Cette valeur par défaut est utilisée lorsque un paramètre n'est pas passé à la fonction lors de son appel. Pour attribuer une valeur par défaut à un paramètre, il te suffit d'assigner une valeur à l'argument lors de la déclaration de la fonction avec le symbole d'allocation =. Voici quelques exemples explicatifs :

#include <iostream.h>

void affiche(int x=1){

cout << x << endl;

}

void main(){

int y=5 ;int buf ;affiche(y);affiche();cout<<"Appuyer sur une touche pour quitter!";cin>>buf;

}

//declaration de la fonction

// programme principal

//appel avec argument//appel sans argument// pour ne pas que l'application// quitte seule

fichier> 5

> 1> Appuyer sur une touche pour quitter!

Ici tu as deux façon d'appeler cette fonction :

• avec un argument (ici y), la valeur par défaut est ignorée et la fonction affiche utilise la valeur de y (5).

• sans argument, dans ce cas, la fonction utilise la valeur par défaut 1 et l'affiche.

Mais, fais bien attention avec les valeurs par défaut ! A partir du moment où un argument en possède une, tous les arguments suivants dans la déclaration doivent également en posséder une. Voici le début d'une fonction qui provoque une erreur de compilation : void fonction(int a, int b=0, int c). La fonction correcte est : void fonction(int a, int b=0, int c=10).A toi donc de réfléchir soigneusement à l'ordre de passage des arguments si tu souhaites utiliser les valeurs par défaut.Attention! Si tu écris le prototype d'une fonction ayant une valeur par défaut, tu ne dois préciser la valeur par défaut que dans le prototype, une fois pour toute, et non plus dans la

déclaration. Sinon, le compilateur génère une erreur.

#include <iostream.h>

void affiche(int x=1);

void main(){

int y=5 ;int buf ;affiche(y) ;affiche() ;cout<<"Appuyer sur une touche pour quitter!";cin>>buf;

}

void affiche(int x){

cout << x << endl;

}

//prototype de la fonction

// programme principal

//appel avec argument//appel sans argument// pour ne pas que l'application// quitte seule

//on ne repete pas la valeur //par defaut

fichierSurchar

ge de fonctionLa surcharge de fonction consiste à définir des fonctions ayant le même nom, mais un nombre d'arguments différents. Cette technique permet donc de définir des fonctions faisant ou non le même traitement dans des contextes différents.

#include <iostream.h>

int division(int x){

int y=1 ;return (x/1) ;

}int division(int x, int y){

return (x/y) ;

}void main(){

int buf ;int a=10;int b=5;cout <<division(b) << endl ;cout << division(a,b) << endl ;cout<<"Appuyer sur une touche pour quitter!";cin>>buf;

}

//declaration de la fonction//division avec 1 argument

//declaration de la fonction//division avec 2 arguments

// programme principal

//appel avec 1 argument//appel avec 2 arguments// pour ne pas que l'application// quitte seule

fichier> 5

> 2> Appuyer sur une touche pour quitter!

Tu as 2 fonctions portant le même nom. La première ne prend qu'un argument de type entier et la deuxième deux arguments de type entier. Ne t'en fais pas: le compilateur sait quelle fonction utiliser parmi les 2. Tu verras par la suite que cette notion est très souvent utilisée dans la programmation objet.

Bonus

Bon, ouf ! On s'en est sorti ! Il est temps maintenant de passer aux exercices:

• Exercice n°1: Appeler une fonction • Exercice n°2: Demandez le menu! • Exercice n°3: Valeur des variables • Exercice n°4: Corrige l'erreur! • Exercice n°5: Valeur par défaut • Exercice n°6: Programme récapitulatif (construction)

Et pour toi, un petit bonus level !

• Comment découper son code? (construction)

Enfin si tu désires continuer dans le monde magique du C++ avec la découverte des boucles, des instructions conditionnelles, des elfes et autres farfadets, consulte le chapitre suivant (construction). Tu deviendras un bof nul parmi les nuls!