Discussion :

[casafa]

Bonjour,

J'aimerais savoir si c'est possible de faire une fonction qui retourne 3 valeurs: a[0], a[1] et a[2].

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
int fonction(int chiffre){
  int a[3];
 
  a[0] = chiffre+1;
  a[1] = chiffre+2;
  a[2] = chiffre+3;
 
  return(????); //Faut mettre quoi ?
}
void main(void){
  int b[3];
  //Comment récupérer les 3 valeurs de la fonction dans le tableau b[3] ?
}

Merci d'avance...
++

[Giovanny Temgoua]

Une fois j'ai cru voir ce suejt traité dans ce forum.

Sinon, LA valeur de retour est celle que tu as précisée entre autre int dans ton cas...

Il n'est pas possible de retourner plus d'une valeur. Cependant, tu peuxx toujours trouver une astuce pour contourner le problème... Par exemple, tu peux définir comme type de retour un pointeur sur un tableau par exemple...

[raf_gug]

Salut!!!
Ce que tu peux faire, c'est passer des variables à la fonction par référence, c'est-à-dire que les variables passées en paramètres seront modifiées par la fonction.

Voici un petit exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
void fonction(int &n1, int &n2, int &n3, int chiffre)
{
  n1 = chiffre + 1;
  n2 = chiffre + 2;
  n3 = chiffre + 3;
}

Et on l'appel comme suit:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
int a, b, c;
fonction(a, b, c, 10);
 
cout << "a: " << a << "\n";
cout << "b: " << b << "\n";
cout << "c: " << c << "\n";

La sortie est:

a: 11
b: 12
c: 13


Voila, c'était une possibilité.

@++

R@f

[Luc Hermitte]

Je pense aussi que c'est la solution la plus propre.
Sinon, également possible (en vrac qui me viennent en tête) :
* mettre ton "int [3]" dans une structure et renvoyer cette structure (copie des 3 int)
* renvoyer un tableau alloué dynamiquement, je déconseille assez l'utilisation des new[] surtout quand on est novice
* même chose mais en enveloppant le tableau dans un truc qui fonctionne comme auto_ptr<>, mais pour les buffers/tableaux => limite les risques de mauvaise manip de mémoire ; regarder chez boost ou STLsoft (je ne sais plus lequel des deux), ils proposent une telle classe.
* utiliser une classe qui est une abstraction sur les tableaux comme
- std::vector<>, qui permet d'avoir une taile de la zone contenue variable ; par contre copie des 3 éléments aussi je le crains
- std::val_array<> : avec elle, il doit y avoir moyen de limiter les copies inutiles (à condition d'en avoir une implémentation récente et peut-etre de bidouiller un chouila), et en plus elle est adaptée aux petits calculs mathématiques.

Ca, c'était pour renvoyer un tableau. Pour plusieurs éléments hétérogènes, tu les mets dans une structure. Par contre pour ce qui est d'éviter les copies inutiles, c'est un problème intéressant auquel il existe des solutions (chercher un article fort intéressant (pas un article pour débutants) d'Andrei Alexandrescu sur CUJ qui présente une technique qu'il a baptisée MOJO) ; et regarder le support de la RVO pour votre compilateur.

[djacko]

Salut,
J'ai le meme probleme que casala. et Luc propose une solution avec un tableau alloué dynamiquement...
Est ce que je pouurais avoir plus de precision sur la façon de proceder.

est ce que c un truc de ce genre?

double tab = new ???

??? getTab() { return tab;}

Merci pour vos lumiere...
Djacko

[Laurent Gomila]

Luc propose une solution avec un tableau alloué dynamiquement...

Luc déconseille la solution à base de tableau dynamique.

Sinon, ça donne quelque chose de ce genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
double* Fonction()
{
   double* Tab = new double[nombre_de_resultats];
   // ...
 
   return Tab;
}

[djacko]

Ah ok j'avais mal compris

[olap75]

Bonjour,

je débute en C++. Après une recherche sur le web , je suis tombé sur cette discussion, qui date de 2004, mais qui visiblement est encore pertinente puisqu'elle apparait en haut dans les résultats de recherche.

J'ai une question par rapport à ce qui a été dit, par Luc Hermitte le 10/01/04 :

"std::vector<>, qui permet d'avoir une taille de la zone contenue variable ; par contre copie des 3 éléments aussi je le crains"
Au niveau de la crainte : C'est à dire que les 3 éléments de retour sont créés puis passés ensuite à des variables au niveau de l'appel de fonction ? C'est-à dire : par exemple, on a :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
int retour f1() {
retour=3;
return retour; 
}

et dans le main:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int a=f1();

Alors on a 2 entiers qui sont créés : retour et a.

En revanche si on fait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
void f1 (int &retour) {
retour=3;
}

puis dans le main :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
int a;
int &b=a;
f(b);

Alors dans ce deuxième cas on ne crée qu'un objet de type int : a .
C'est ce que voulait dire Luc Hermitte ?


2ème point : je trouve qu'au niveau de la lecture c'est pas super agréable: on passe en argument ce qu'on aimerait avoir en sortie : c'est bizarre comme logique, non ?

MErci pour vos retours !

PS : désolé, je n'ai pas encadré le code par des balises adaptées, je ne vois pas ces balises dans l'interface d'édition de message !

[Iradrille]

C'est ce que voulait dire Luc Hermitte ?


2ème point : je trouve qu'au niveau de la lecture c'est pas super agréable: on passe en argument ce qu'on aimerait avoir en sortie : c'est bizarre comme logique, non ?

Pour le code, il y à l'icone #, ou les balises [ code] [ /code]

Sinon, oui dans l'idée c'est ce qu'il voulait dire. Dans tes exemples par contre, il n'y aura pas de copie.

Pour les arguments par référence, c'est assez fréquent en C++, une habitude à prendre mais rien de bizarre.
Une autre solution qui n'a pas été donné c'est l'utilisation de tuple

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
std::tuple<int, int, int> foo(int n) {
   return std::make_tuple(n+1, n+2, n+3);
}
 
auto t = foo(42);
assert(std::get<0>(t) == 43);
assert(std::get<1>(t) == 44);
assert(std::get<2>(t) == 45);

[Bousk]

Depuis 2004 ils ont ajouté la move-semantic, et le retour ne se fait plus forcément par copie mais peut utiliser ce nouveau procédé.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
int a;
int &b=a;
f(b);

On écrira

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
int a;
f(a);

On peut aussi utiliser un pointeur.

Une autre solution qui n'a pas été donné c'est l'utilisation de tuple

Ou bien "à l'ancienne" : une structure.

[olap75]

Merci pour vos réponses Iradrille et Bousk.

Iradrille, juste une remarque, tu écris :

Dans tes exemples par contre, il n'y aura pas de copie.

Dans le premier exemple, dans le main, il n'y a pas une copie de la variable locale 'retour' dans la variable 'a' ?

Ce que je retiens, après aussi une discussion avec un collègue expérimenté en C++ :
le passage par référence de la valeur à une fonction qui existe pour retourner cette valeur n'est pas super lisible mais est plus performant : elle évite la création d' objets temporaires dans la fonction.
Après tout dépend du contexte, c'est un arbitrage à faire entre lisibilité et performance.

[oodini]

Renvoyer par valeur une structure ou un tuple, en tablant sur la (N)RVO.

[Iradrille]

Dans le premier exemple, dans le main, il n'y a pas une copie de la variable locale 'retour' dans la variable 'a' ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
int foo() {
   int ret = 3;
   return ret;
}
// et
int foo() { return 3; }

C'est strictement équivalent. Donc pas de copie supplémentaire ici.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
int foo() { return 3; }
int a = foo();
// et
int foo(int& a) { a = 3; }
int a;
foo(a);

C'est aussi équivalent, dans les deux cas la fonction sera inline et le tout sera équivalent à int a = 3;.
Il y à de rare cas où la première forme forcera une copie supplémentaire par contre.

[JolyLoic]

Ce que je retiens, après aussi une discussion avec un collègue expérimenté en C++ :
le passage par référence de la valeur à une fonction qui existe pour retourner cette valeur n'est pas super lisible mais est plus performant : elle évite la création d' objets temporaires dans la fonction.
Après tout dépend du contexte, c'est un arbitrage à faire entre lisibilité et performance.

Ton collègue est peut-être expérimenté, mais pas forcément au courant des évolutions des dernières années :
- Déjà, si la fonction est inlinée, la question ne se pose pas...
- Ensuite, il y a pas mal de cas où ce retour sera totalement optimisé, mieux que si tu avais passé un argument par référence (ce qui a aussi un coût : créer une variable et l'initialiser sans lui donner la bonne valeur).
- Et dans les autres cas, pour peu que le reste du code soit bien fait, il n'y aura pas copie d'un gros objet, mais plutôt déplacement. Donc un entier sera copié (ce qui est quasi gratuit), et un vector sera déplacé.

Aujourd'hui, on peut donc avoir lisibilité et performances.

[jblecanard]

Bonjour

Pour plusieurs éléments hétérogènes, tu les mets dans une structure.

Pas forcément. C++11 a apporté le support des tuples, qui servent notamment à faire ce genre de choses sans avoir à définir de structure. Exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <iostream>
#include <string>
#include <tuple>
 
std::tuple<std::string, int, double> f() {
  return std::make_tuple(std::string("Roger"), 5, 1.2);
}
 
int main() {
  std::string val1;
  int val2;
  double val3;
  std::tie(val1, val2, val3) = f();
  std::cout << val1 << " " << val2 << " " << val3 << std::endl;
  return 0;
}

D'un point de vue purement technique, on ne renvoie qu'une valeur, un tuple. D'un point de vue sémantique, on renvoie trois valeurs distinctes qui n'ont pas nécessairement de relation entre elles.

[Bousk]

C++11

10/01/2004, 14h13

Btw, utiliser les "anciens procédés" est parfois obligatoire. Et fonctionnent aussi. Hélas, toutes les entreprises n'utilisent pas les dernières technos.

[jblecanard]

En effet, je n'avais pas vu qu'il s'agissait d'un déterrage en règle ^^. Du reste, je ne contredis pas la validité de l'ancienne méthode. Il y a même des boîtes qui interdisent l'usage de la STL (pour du dev destkop, je parle pas de code industriel embarqué) :p.

[olap75]

Iradrille , j'essaie de faire le point sur ce que tu as écrit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
int foo() {
   int ret = 3;
   return ret;
}
// et
int foo() { return 3; }

C'est strictement équivalent. Donc pas de copie supplémentaire ici.

c'est équivalent parce que 3 est reconnu comme un objet de type int j'imagine: Dans le deuxième cas, même si on écrit "return 3;" uniquement, ça sous-entend la création d'un objet de type int, et finalement ça revient au même que le premier cas. vrai ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
int foo() { return 3; }
int a = foo();
// et
int foo(int& a) { a = 3; }
int a;
foo(a);

C'est aussi équivalent, dans les deux cas la fonction sera inline et le tout sera équivalent à int a = 3;.

Je suppose, pour la 2ème déclaration de foo, que tu voulais déclarer foo plutôt comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void foo(int& a) { a = 3; }

Supposons que la fonction ne soit pas inline. Les équivalences sont encore valables. Vrai ? Dans tous les cas, un objet de type int est créé temporairement dans la fonction.

Il y à de rare cas où la première forme forcera une copie supplémentaire par contre.

En fait je ne comprends plus trop du coup la remarque de Luc Hermitte à l'époque, sur la copie des 3 éléments :

- std::vector<>, qui permet d'avoir une taile de la zone contenue variable ; par contre copie des 3 éléments aussi je le crains.

Que voulait-il dire à l'époque ?

J'ai d'autres questions sur les réponses de JolyLoic, jblecanard, mais là faut je bosse. J'ai un peu peur aussi d'abuser de votre temps et de vous polluer avec plein de messages ! Ca m'intéresse !

Merci encore

[Iradrille]

Je suppose, pour la 2ème déclaration de foo, que tu voulais déclarer foo plutôt comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void foo(int& a) { a = 3; }

Oui, erreur de copié / collé.

Supposons que la fonction ne soit pas inline. Les équivalences sont encore valables. Vrai ? Dans tous les cas, un objet de type int est créé temporairement dans la fonction.

Ca reste proche, mais pas forcément équivalent. Un int temporaire n'est pas forcément créer : se sera au maximum l'utilisation d'un registre.

Non inline, la première ressemblera à

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
enter // int foo() { (vui enter n'est pas utilisé, mais plus clair)
mov eax, 3 // return 3
leave // } (pareil que enter)
mov a, eax // a = foo(); -> peut être éviter si a est utilisé directement après

La deuxième devrait être

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
enter
mov a, 3 // a = 3;
leave

En fait je ne comprends plus trop du coup la remarque de Luc Hermitte à l'époque, sur la copie des 3 éléments :


Que voulait-il dire à l'époque ?

Un vector est crée dans la fonction, puis copié lors du return.
Des optimisations existent pour éviter cette copie (RVO).
Mais si le compilo n'arrive pas à appliquer cette optimisation le vector sera copié.

Maintenant (depuis C++11), il est possible de ne pas copier ce vector, mais de la déplacer : cette une opération beaucoup plus légère que la copie (mais pas gratuite) mais ça rend le vector source invalide (ici le vector source est temporaire et sera de toute façon détruit).

[foetus]

Iradrille , j'essaie de faire le point sur ce que tu as écrit :


c'est équivalent parce que 3 est reconnu comme un objet de type int j'imagine: Dans le deuxième cas, même si on écrit "return 3;" uniquement, ça sous-entend la création d'un objet de type int, et finalement ça revient au même que le premier cas. vrai ?

C'est une optimisation compilateur que je connais depuis les années 2000 ... mais je ne connais pas tous les détails et peut-être que cela à changer depuis

En gros lorsque tu codes un truc comme cela: MyObject get_object() { /*...*/ return object; }
Le compilateur va créer un objet temporaire pour stocker le return -> MyObject tmp = object; (note la belle recopie )
Mais (il me semble) avec les types atomiques (entiers, flottants, etc..) et les références il ne fait pas d'objet temporaire;
Donc un return 3 avec un appel a = f(a); équivaut à a = 3;

Tout cela semble très très logique