retour deux tableaux créés dans C++

Question

Salut, je dispose d'un fichier texte contenant deux tableaux et une valeur (tous les entiers) comme celui-ci

3 90 22 5 60 33 24 

Lorsque le premier numéro signifie combien entiers à lire. I peut lire dans tout cela en une seule fonction. Ai-je besoin de plusieurs fonctions pour pouvoir utiliser les différentes matrices et la première variable? Ci-dessus est le code que j'ai jusqu'ici et cela fonctionnerait dans la fonction principale. Dois-je écrire trois fonctions pour lire cette information afin de pouvoir l'utiliser dans mon programme ou est-ce que je pourrais par exemple envoyer trois pointeurs à une fonction?

I would like A to be 90 22 5 
B to be 60 33 24 
And VAR to be 3 

Merci

Answer 1

Chaque fois que vous voulez regrouper les éléments de données, utiliser une classe ou d'une structure. Par exemple, pour passer trois entiers comme x, y et z les coordonnées ,:

struct Coord { 
    int x, y, z; 
}; 

et passer ensuite la structure à la fonction:

void f(Coord & c) { 
} 

va de même pour les tableaux, mais dans votre cas, vous rendrait la structure contenant des pointeurs.

Votre question ouvre réellement de vastes zones de programmation C++ dont vous ne connaissez pas l'existence. Certaines choses que vous devriez lire avant de d'aller plus loin:

• le concept de structures, comme indiqué ci-dessus
• constructeurs et destructeurs pour les structures
• quand et quand ne pas utiliser l'allocation dynamique de la mémoire
• utilisation de conteneurs de la bibliothèque standard de C comme std :: vector

Cela peut sembler beaucoup, mais une fois que vous avez une prise en main claire sur ces derniers, vous trouverez la programmation C++ beaucoup, beaucoup plus facile et plus sûr.

Answer 2

Le plus simple est de définir un type, par exemple un struct, qui représente les données d'une ligne:

struct MyMatrix 
{ 
    int size; 
    int *a; 
    int *b; 
}; 

Ensuite, écrire une fonction qui lit un tel cas à partir d'une ligne de texte:

struct MyMatrix load_matrix(std::ifstream& stream) 
{ 
    MyMatrix m; 

    stream >> m.size; 

    m.a = new int[m.size]; 
    for(int i=0 ;i < m.size; i++) 
     stream >> m.a[i]; 

    m.b = new int[m.size]; 
    for(int i=0 ;i < m.size; i++) 
     stream >> m.b[i]; 

    return m; 
} 

Ce code ne comporte pas de vérification d'erreur, mais vous pouvez l'ajouter. N'oubliez pas que l'allocation de mémoire peut échouer.

Answer 3

Ou simplement utiliser les paramètres par référence.

int theFunction(int*& arrayA, int*& arrayB){ 
    int size; 
    // ... 
    arrayA = new int[size]; 
    arrayB = new int[size]; 
    // ... 
    return size; 
} 

Answer 4

Lorsque vous voulez retourner plusieurs éléments que vous pouvez utiliser les paramètres de sortie supplémentaires dans vos fonctions (passés par référence) ou retourner un tuple. J'ai tendance à préférer l'option plus tard car il en résulte un code plus lisible.Au lieu de gérer manuellement la mémoire de vos baies avec new et delete[], vous pouvez utiliser std::vector pour obtenir un comportement équivalent. Chaque vecteur stocke sa propre taille de sorte que vous n'avez pas besoin de retourner une variable supplémentaire pour cela.

En résumé, dans ce cas, vous pouvez simplement retourner un tuple de deux vecteurs. Dans la bibliothèque standard, les tuples à deux éléments sont représentés avec la classe std::pair. Par conséquent, votre fonction renverra une paire de vecteurs: std::pair<std::vector<int>, std::vector<int> >. Puisque c'est beaucoup à taper, il vaut mieux utiliser un typedef.

Ceci est une implémentation possible de votre fonction. Notez que vous pouvez éviter les boucles écrites manuellement grâce à la norme istream_iterator classe:

typedef std::pair<std::vector<int>, std::vector<int> > Data; 
Data read(std::ifstream & ifs) 
{ 
    int n; 
    ifs >> n; 
    typedef std::istream_iterator<int> in_it; 

    std::vector<int> a(n); 
    std::copy(in_it(ifs), in_it(), a.begin()); 

    std::vector<int> b(n); 
    std::copy(in_it(ifs), in_it(), b.begin()); 

    return Data(a, b); 
} 

Et voici comment vous utiliserez votre fonction. Remarquez comment vous ne renvoyez pas la taille implicitement mais vous pouvez la récupérer facilement via std::vector::size().

int main() { 

    std::ifstream ifs("SOMEFILE.txt"); 
    Data data = read(ifs); 

    unsigned int n = data.first.size(); 
    std::vector<int> & a = data.first; 
    std::vector<int> & b = data.second; 

    return 0; 
} 

EDIT: suggestion de Neil d'utiliser un struct dédié échelles mieux et conduit à un code plus lisible, donc vous devriez certainement considérer que aussi bien. Dans ce cas, votre struct serait:

struct Data { 
    std::vector<int> a, b; 
}; 

Et votre fonction main serait identique sauf que vous devez remplacer first et second avec a et b.