Comment retourner plus d'une valeur d'une fonction C ++?

Question

Je suis intéressé si je peux revenir plus d'une valeur d'une fonction. Par exemple, considérons une telle fonction: algorithme d'Euclide étendu. L'étape de base est décrit par cette L'entrée est entiers positifs a et b; sortie est un triplet (d, i, j) de telle sorte que d=gcd(a,b)=i*a+j*b. Juste pour clarifier le but de ma question, je vais écrire un code court récursive:

 if (b==0)  return (a,1,0)
      q=a mod b;

soit r telle que a=r*b+q;

(d,k,l)=extendedeuclidean(b,q);
  return (d,l,k-l*r); 

Comment peut-on revenir un triplet?

Answer 1

Il suffit de créer une structure de données appropriée tenant les trois valeurs et le retourner.

struct extmod_t {
    int d;
    int i;
    int j
    extmod_t(int d, int i, int j) : d(d), i(i), j(j) { }
};

…

extmod_t result = extendedeuclidean(b, q);
return extmod_t(result.d, l, k - l * r);

Answer 2

Vous pouvez créer un std::tuple ou boost :: tuple (si vous ne l'utilisez C ++ 0x) de votre paire triple et le retourner.

Answer 3

Comme il a été suggéré par Tony Le Tigre, vous pouvez utiliser tuple. Il est inclus dans C ++ 11 compilateurs standard et nouveau support déjà. Il est également mis en œuvre dans boost . Pour mon compilateur ibm xlC tuple est dans namespace std :: tr1 (essayé pour MSVC10 - il est dans namespace std).

#include <cstdio>
#include <tuple>

// for MSVC
using namespace std;

// for xlC 
//using namespace std::tr1;

// for boost
// using namespace boost;

typedef tuple<int, float, char> MyTuple;
MyTuple f() {
    return MyTuple(1, 2.0f, '3');
}

int main() {
    MyTuple t = f();
    printf("%i, %f, %c\n", get<0>(t), get<1>(t), get<2>(t));
}

compilation xlC pour TR1:

xlC -D__IBMCPP_TR1__ file.cpp

compilation xlC pour boost:

xlC file.cpp -I/path/to/boost/root

Answer 4

Soit créer une classe qui encapsule le triplet puis retourner l'instance de cette classe, ou 3 paramètres par référence.

Answer 5

Je trouve généralement que quand je dois retourner deux paramètres d'une fonction, il est utile d'utiliser le STL de std::pair.

Vous pouvez toujours empiler les paires dans un autre (par exemple std::pair <int, std::pair <int, int> >) et aider votre auto avec typedef-s ou définit pour le rendre plus accessible, mais chaque fois que je tente de faire ce à mes fins de coder en désordre et peu pratique pour la réutilisation .

Pour plus de deux paramètres, cependant, je vous recommande de faire propre structure de données spécifique qui contient les informations dont vous avez besoin (si vous retournez plusieurs valeurs, il y a une forte probabilité qu'ils sont fortement logiquement connectés en quelque sorte et que vous pourriez finir par utiliser la même structure à nouveau).

par exemple. Je besoin d'une fonction qui retourne la pente de la ligne (1 param) et qui était très bien. Ensuite, je devais développer pour retourner les paramètres de la représentation paramétrique de la ligne (y = k*x + l). Deux paramètres, toujours très bien. Puis je me suis souvenu que la ligne peut être verticale et que je devrais ajouter un autre paramètre pour indiquer que (pas de représentation paramétrique alors) ... À ce stade, il est devenu trop compliqué d'essayer de faire avec des types de données existants, donc je tapais mon propre structure de ligne et a fini par utiliser la même structure sur mon projet plus tard.