[PDF] Chapitre 9 Passage de paramètres

Différents types de passage de paramètres d’une fonction

Différents types de passage de paramètres d’une fonction Il existe deux modes de passages de paramètres : le passage par valeur et le passage par référence (ou par adresse) • Passage de paramètre par valeur Le passage de paramètre par valeur réalise une copie locale (au niveau de la fonction) de la valeur de la variable

Chapitre 9 Passage de paramètres

- En C++, 3 types de passage de paramètres: 1par valeur (existe aussi dans les langages C et Java ) par adresse (existe aussi dans le langage C) 1 par référence (uniquement dans les langages C++ et Java ) 1 Java : passage par valeur pour les primitifs et par référence pour les objets

Chapitre 3 : Procédures et fonctions

3-1 Passage paramètres par valeur C’est le mode de transmission par défaut, il y a de la valeur, des paramètres effectifs dans les variables copie locales issues des paramètres formels de la procédure ou de la fonction appelé

Les fonctions et les procédures en C - Paris Descartes

fonctions et procédures 15 Paramètres en entrée ou sortie (3/3) • En langage C, il n'existe pas d'autre paramètre de sortie que le paramètre de retour :-( • Passage de paramètre par valeur – On passe la valeur du paramètre – Implique que le paramètre est en entrée • Passage de paramètre par adresse – On passe l'adresse du

LIFAP6Sem1 20 21 Cours01

•Donnée : la procédure travaille sur une copie (passage par valeur) •Donnée-Résultat : la procédure travaille sur l’original (passage par adresse ou bien par référence) •Notion de pointeur et de référence •Arithmétique des pointeurs •Type Abstrait et Programmation Modulaire ( hpp cpp) •Nuance entre définition et

Variables (locales et globales), fonctions et procédures

Le passage de paramètres en entrée/sortie Passage de paramètre qui combine les deux précédentes A utiliser lorsque le sous-programme doit utiliser et/ou modifier la valeur de la variable du (sous-)programme appelant Comme pour le passage de paramètre en sortie, on ne peut pas utiliser de constante Par exemple :

Programmation sous Delphi - Laboratoire ERIC

• en fournissant l’adresse des valeurs (passage par adresse ou par référence), ce qui permet de modifier la valeur initiale ( paramètres en sortie ou en entrée/sortie ) Dans les exemples ci-dessus, les paramètres sont passés par valeur

Information, Calcul et Communication

valeur 00000000 valeur valeur Une adresse étant aussi un motif binaire, on l’écrit sous forme condensée en base 16 En C++ on peut manipuler des constantes en hexadécimal en indiquant 0x avant sa valeur Ex: 0xF0 L’adresse d’une variable est l’adresse du premier octet réservé pour mémoriser la valeurde cette variable

Information, Calcul et Communication

appel par valeur transmet la valeur de la variable à la fonction Pour les type de base il n’y a aucune différence de performance entre ces 2 options pour l’exécution de l’appel de la fonction -> privilégier le passage par valeur car plus local (plus sûr) Par contre, la transmission de la valeur d’un type T plus

[PDF] passage par référence c++

[PDF] passage par valeur et par adresse en c

[PDF] passage par référence c++ open classroom

[PDF] acting out psychanalyse

[PDF] le salaire du sniper analyse

[PDF] le salaire du sniper texte pdf

[PDF] le salaire du sniper questionnaire

[PDF] redaction le salaire du sniper

[PDF] le salaire du sniper personnage principal

[PDF] passé composé terminaison

[PDF] passé composé cm2

[PDF] passé composé exercices pdf

[PDF] passé composé utilisation

[PDF] passé composé etre et avoir

[PDF] passé composé cm1

Chapitre 9 : Passage de paramètres 103

© Mohamed N. Lokbani v1.01 POO avec C++

Chapitre 9

Passage de paramètres

Chapitre 9 : Passage de paramètres 104

© Mohamed N. Lokbani v1.01 POO avec C++

1. Référence

- Référence est un alias à un espace mémoire. - Syntaxe: Type& var = valeur; #include using namespace std ; int main() { int i=0,j=20; int& valeur =i; cout << "i: " << i << " valeur: " <Chapitre 9 : Passage de paramètres 105

© Mohamed N. Lokbani v1.01 POO avec C++

- Les variables de référence doivent être initialisées au moment de leurs déclarations.

#include using namespace std ; int main() { int i=0; int& valeur; // Erreur valeur a été déclarée comme référence mais n'a // pas été initialisée. La manière correcte est // int& valeur = i; cout << valeur << " " << i << endl; return 0;

Chapitre 9 : Passage de paramètres 106

© Mohamed N. Lokbani v1.01 POO avec C++

- Ne peuvent être réaffectées (réassignées) comme alias à d'autres variables. #include using namespace std ; int main() { int i=0, j=20; int& valeur = i; valeur = j; cout << valeur << " " \ << i << " " << j << endl; return 0; La valeur a été déclarée comme référence alias à la variable i Cette valeur n'a pas été réaffectée à j, elle est toujours alias de i. Cette ligne sert uniquement à affecter 20 (donc le contenu de j) à valeur (donc i) \ permet de dire au compilateur que la ligne qui suit fait partie de l'instruction

Chapitre 9 : Passage de paramètres 107

© Mohamed N. Lokbani v1.01 POO avec C++

- Une fois que la référence est déclarée alias d'une autre variable, toutes les opérations que l'on croit

effectuer sur l'alias (c'est à dire la référence) sont en fait exécutées sur la variable d'origine.

#include using namespace std ; int main() { int i=0; int& valeur = i; valeur++; cout << i << endl ; return 0; valeur = i =0 valeur = 1 affiche: 1

Chapitre 9 : Passage de paramètres 108

© Mohamed N. Lokbani v1.01 POO avec C++

- Danger ... // bugref.cpp #include using namespace std ; int main() { double i=0; int& valeur = i; valeur = 250; cout << i << endl ; return 0; valeur = i =0 valeur = 250 affiche: 0 - Le compilateur compile le programme sans erreurs et génère les warnings suivants: bugref.cpp: In function `int main()': bugref.cpp:5: warning: converting to `int' from `double' bugref.cpp:5: warning: initializing non- const `int &' with `double' will use a temporary

Chapitre 9 : Passage de paramètres 109

© Mohamed N. Lokbani v1.01 POO avec C++

- Le compilateur a créé une variable temporaire (signalée dans le second warning), comme suit:

double i=0; int temp = i; int& valeur = temp; conversion double vers int et initialisation de temp avec la valeur de i valeur est une référence à temp (mais pas i) - Modifier valeur revient à modifier temp mais pas i car il n'y a aucun lien entre i et temp.

- De ce fait, faire attention de déclarer le type de la référence identique à la variable référencée, pour éviter

des surprises lors de l'exécution de votre programme.

Utilité

- En général, pour éviter d'utiliser les pointeurs.

- En particulier, lors des passages de paramètres (des classes, des structures) afin d'éliminer la surcharge

causée par la copie de grandes quantités de données.

Chapitre 9 : Passage de paramètres 110

© Mohamed N. Lokbani v1.01 POO avec C++

2. Passage de paramètres

- Pour rappel, il y a 2 types de paramètres: ▪ paramètres réels: dans l'appel de fonction ▪ paramètres formels: dans l'entête de la fonction - En C++, 3 types de passage de paramètres: ▪ par valeur (existe aussi dans les langages C et Java 1) ▪ par adresse (existe aussi dans le langage C) ▪ par référence (uniquement dans les langages C++ et Java 1)

1 Java : passage par valeur pour les primitifs et par référence pour les objets.

Chapitre 9 : Passage de paramètres 111

© Mohamed N. Lokbani v1.01 POO avec C++

2.1. Passage de paramètres par valeurs

#include using namespace std ; void increment(int n,int z) { n=n+z; int main() { int k=7; increment(k,3); cout << k << endl; // affiche 7 mais pas 10 (i.e. 7+3) return 0; Aucun lien entre paramètre formel et paramètre réel. k = 7 //////////////// n = 7 z = 3

Pile d'exécution

Paramètre formel

n est initialisé avec la valeur du paramètre réel k=7. increment(k,3) // k=7

Devient

10 (7+3)

Chapitre 9 : Passage de paramètres 112

© Mohamed N. Lokbani v1.01 POO avec C++

2.2. Passage de paramètres par adresses

- Pour modifier le paramètre réel, on passe son adresse plutôt que sa valeur. #include using namespace std ; void increment(int *n,int z) { *n= *n + z; int main() { int k=7; increment(&k,3); cout << k << endl; // affiche 10 car c'est l'adresse qui a été passée. return 0;

Chapitre 9 : Passage de paramètres 113

© Mohamed N. Lokbani v1.01 POO avec C++

- Il y a un lien entre paramètre formel et paramètre réel. k = 7 ///////////////// n z=3

Pile d'exécution

- Paramètre formel n est initialisé avec le contenu de l'adresse pointant sur k.

- Il y a un lien potentiel entre les paramètres formels de la fonction et les paramètres réels.

- La gestion des adresses est effectuée par le programmeur (lourde et difficile à lire). increment(k,3) // k=7 devient

10 (7+3)

Adresse pointant

Chapitre 9 : Passage de paramètres 114

© Mohamed N. Lokbani v1.01 POO avec C++

2.3. Passage de paramètres par référence

- En C++ le compilateur peut se charger lui même de la gestion des adresses. - Le paramètre formel est un alias de l'emplacement mémoire du paramètre réel. #include using namespace std; void increment(int& n,int z) { n= n + z; int main() { int k=7; increment(k,3); cout << k << endl; // affiche 10 car c'est l'adresse qui a été passée. return 0;

Chapitre 9 : Passage de paramètres 115

© Mohamed N. Lokbani v1.01 POO avec C++

2.4 Exemple du swap

- Que va afficher le programme suivant sur la sortie standard? Réécrire le code suivant dans les 2 cas

suivants: -1- void swap(int a,int& b){...} -2- void swap(int& a,int& b){...} #include using namespace std ; void swap(int a,int b){ int c; c=a;a=b;b=c; int main() { int i=4,j=7; swap(i,j); cout << i << " " << j << endl; return 0;

Chapitre 9 : Passage de paramètres 116

© Mohamed N. Lokbani v1.01 POO avec C++

3. Passage d'un tableau

- 2 configurations possibles:

3.1. Par pointeur

#include using namespace std; void fonction(int* tableau, int taille) { for (int i=0; iChapitre 9 : Passage de paramètres 117

© Mohamed N. Lokbani v1.01 POO avec C++

3.2. Par semi-référence

#include using namespace std ; void fonction(int tableau[], int taille) { for (int i=0; iAu lieu d'un pointeur

Chapitre 9 : Passage de paramètres 118

© Mohamed N. Lokbani v1.01 POO avec C++

4. Quand utiliser une référence

(voir aussi P. Prados @ http://perso.club-internet.fr/pprados/Langage/CPP/ref/ref.html)

4.1. Comme attribut

- Revoir le paragraphe sur les références.

4.2. Comme un paramètre

- Une question difficile à trancher :

▪ Si le paramètre ne doit être consulté que par la méthode, il faut recevoir une référence (assez

souvent constante).

▪ Si le paramètre reçu par la méthode peut être absent, i.e. l'utilisateur peut envoyer la valeur

NULL, il faut recevoir dans ce cas un pointeur:

Chapitre 9 : Passage de paramètres 119

© Mohamed N. Lokbani v1.01 POO avec C++

void f(const TEST& x){ // x est une référence (if (&x == NULL) ... // À ne pas faire ... référence ne peut pas être NULL. - Utilisez la surcharge ... void f(const TEST& x){ // traite le cas d'un passage par référence void f(const void* x){ // traite le cas d'un pointeur NULL - Essayez de cogiter sur un exemple complet.

Chapitre 9 : Passage de paramètres 120

© Mohamed N. Lokbani v1.01 POO avec C++

4.3. En retour d'une méthode (ou fonction)

#include using namespace std ; int& fonction(int &a) { a += 10; return a; int main() { int val,test = 20; val = fonction(test); cout << "val: " << val << " " \ << "test: " << test << endl; // affiche: val: 30 test: 30 fonction(test) = 250; cout << test << endl; // affiche: 250 return 0;

Chapitre 9 : Passage de paramètres 121

© Mohamed N. Lokbani v1.01 POO avec C++

Danger ...

int& exemple() { int i=10; // i est une variable locale de la fonction exemple // durée de vie entre {} return i; // exemple va retourner un alias sur une variable // qui va cesser d'exister!

Chapitre 9 : Passage de paramètres 122

© Mohamed N. Lokbani v1.01 POO avec C++

quotesdbs_dbs44.pdfusesText_44