passage de valeurs de fonction a fonction

salut à tous,

Je débute en c++ et je n'arrive pas à faire le truc de base. En fait dans ma fonction principale je rentre le nom d'un fichier puis je dis d'appliquer la fonction read (fonction perso) à ce fichier. Dans cette fonction read les données sont stockées sous forme de tableau.

Question : Comment réutiliser ce tableau dans la fonction principale ??

Merci de votre aide.
Ci-dessous le code en question.

---

#include <cstdio>
#include <iostream>
#include <fstream>

using namespace std;

char read (ifstream & f);

int main ()
{
    ifstream file("test.txt", ios::binary); //flux d'entrée
    read(file);
   
   
    system ("PAUSE");
    return EXIT_SUCCESS;
}

char read (ifstream & f)
{
     //taille du fichier d'entrée
    f.seekg(0, ios::end);
    int sizeOfArray = f.tellg();
    f.seekg(0, ios::beg);
   
    char array[sizeOfArray]; //tableau de la taille du fichier
   
    //lecture
    for (int position = 0; position < sizeOfArray; position++)
    {
        char valeur = f.get();
        array[position] = valeur;
        cout << position << " : " << array[position] << endl;
    }
}

Tu peux allouer ton tableau array dans la fonction read:
array = new char[sizeOfArray];

Tu le retournes à la fin de read() par return array. Du coup read() a pour type char * un non char.
Dans main: char * main_array = read(file);

Tu peux aussi déclarer ou allouer ton tableau dans main et le passer par référence à read().

J'ai un plantage au moment de la compilation sur la commande array = new char[sizeOfArray] à savoir que array n'est pas déclaré. Je comprend pas bien étant donné que cette ligne est une déclaration non ?

Pour déclarer mon tableau dans main et le passer à read j'ai un pb : pour déclarer un tableau il faut avoir sa taille. Or ici la taille du tableau est définie dans read. Est-ce que je suis obligé de faire une fonction "taille" séparée ?

Non ce nest pas une déclaration mais une allocation.
Tu dois d'abord écrire char * array;

Effectivement, la taille est définie dans read, donc seule la premiere solution marche à savoir une allocation dans read et main récupère le pointeur sur le tableau:

main()
{
 ...
 char * array;
 array = read(file);
 ...
}

THEwarrior333, tu pourrais au moins lui dire que le pointeur renvoyé par la fonction doit etre liberé quand on en a plus besoin, sinon je t'explique pas les fuites mémoires !

Il vaut mieux allouer le tableau de le main et le passer à read, l'appelant doit maitriser la mémoire.

Le problème ici est que la lecture du fichier n'est pas appropriée. Imagine que le fichier passé à read fait 2Go ??? La mémoire explose !

Une meilleure solution est de garder le fichier ouvert et de naviguer à l'interieur selon les besoins ... Enfin tour ça depend de ce que tu veux faire.

D@runia

A priori je n'aurais pas ces problème de mémoire. Autrement, mon code a cette tête maintenant :

#include <cstdio>
#include <iostream>
#include <fstream>

using namespace std;

char read (ifstream & f);

int main ()
{
    ifstream file("test.txt", ios::binary); //flux d'entrée
    char * array;
    array = read(file);
       
    system ("PAUSE");
    return EXIT_SUCCESS;
}


char read (ifstream & f)
{
     //taille du fichier d'entrée
     f.seekg(0, ios::end);
     int sizeOfArray = f.tellg();
     f.seekg(0, ios::beg);
    
     //lecture
     array = new char[sizeOfArray];
     for (int position = 0; position < sizeOfArray; position++)
     {
         int valeur = f.get();
         array[position] = valeur;
        
         cout << position << " : " << array[position] << endl;
     }
     return array;
}

J'ai 2 erreurs de compilation :

• invalid conversion from 'char' to 'char*' à la ligne array = read(file)
• 'array' undeclared à la ligne array = new char[sizeOfArray]

C'est vrai je n'ai pas dit qu'il fallait libérer la mémoire après, toutes mes excuses J'imaginais que binoua connaissait l'allocation et que sa question ne concernait que la maniere de passer un tableau en parametre:
delete [] array dans le main permet de détruire le tableau. N'oublies pas les [] qui correspondent à la désallocation d'un tableau d'objets et non d'un seul objet.

Sinon l'allocation peut tres bien se faire dans read, je ne vois pas le probleme. Il y a des tas de fonctions qui effectuent l'allocation elles-mêmes et c'est au programmeur de faire gaffe à bien gérer la mémoire. (cf DirectX par exemple.)

binoua: ta fonction read ne doit plus etre du type char mais char * car elle renvoie un char *.
char * read(ifstream & f);

et tu as oublié encore de déclarer array dans read():
char * array;
array = new char[sizeOfArray]];

youpi ça marche !!!

Oui en fait je savais pour les histoires de mémoire mais comme vous avez pu le constater, je débute avec les pointeurs !

Encore merci
++

De rien.

Une question que je me posais (peut-être le sais-tu Darunia):
est-ce une bonne idée d'effectuer la boucle de remplissage du tableau avec comme critère d'arrêt la taille du fichier déterminée en début de fonction?
Car si le fichier est modifié pendant la lecture, ca risque de planter. Alors que si la boucle est effectuée tant que le curseur n'est pas en fin de fichier on n'a pas ce problème:

position = 0;
int valeur;
while( f.good() )
{
    valeur = f.get()
    array[position] = valeur;       
    cout << position << " : " << array[position] << endl;
    position++;
}

oui ce que tu dis est vrai mais d'un autre côté si il faut rajouter

if (position > taille) {break}

parce que sinon tu risques de rentrer trop de données par rapport à la capacité du tableau.
Donc dans un soucis de simplicité je suis partis du principe que le fichier ne serait pas modifié pendant la lecture et j'ai donc fait la boucle que l'on connait.