Fonction avec Ifstream

Bonjours a tous, j'essaye de faire une fonction de se type :
Code:

1 2 3 4 int chiffre(ifstream x, int y[][250]) { }
dans mon main() il y a :
Code:

1 2 3 4 5 6 int main() { int nombre_visible[250][250]; ifstream flux_visible(image_visible.c_str()); chiffre(flux_visible, nombre_visible); }
le problème c'est que dans chiffre(flux_visible, nombre_visible) flux_visible est déclarée comme une erreur du type "Cannot be referenced -- it is a deleted fonction"
je ne comprend pas pourquoi, doit-je passe par un autre moyen ? deplus je suis sous microsoft visual studio 2015 si ça change quelque chose

merci d'avance pour vos réponses!

- Cewein

C'est marqué résolu, mais sinon : std::ifstream n'est pas copiable. Il faut le passer par référence.

oui justement j'avais trouvé la réponse c'est pour cela j'ai mis en résolu! merci quand même pour la réponse

Salut,

Ceci étant dit, les tableaux deux dimensions C style comme tu les utilises, c'est vraiment pas la meilleur idée du jour. Surtout quand quand chaque dimension doit contenir 250 éléments, car cela représente en tout 250 * 250 éléments de type int, soit 62 500 entiers ou -- si l'on considère qu'il faut quatre byte pour représenter un entier en mémoire -- 250 000 bytes qui seront placés sur la pile.

Or, la pile représente une quantité de mémoire particulièrement réduite (rarement plus de quelques Ko / quelques Ko), et, si tu en utilise déjà 250 Ko pour tes données, tu vas rapidement arriver à la saturer, ce qui provoquera des problèmes sans noms.

L'idéal, lorsque l'on a besoin d'autant d'éléments est donc d'avoir recours à "quelque chose" qui placera ces éléments sur "le tas" plutôt que sur la pile. Mais ne vas pas me faire une saloperie du genre de
Code:

1 2 3 4 5 6 7 int main(){ int ** tab = new int[250]; for(size_t i=0; i< 250;++i) tab[i]= new int[250]; /* ... */ return 0; }
Ce serait l'équivalent buggé de ce que l'on fait en C!!!.

Lorsque tu veux pouvoir représenter un "nombre inconnu ou important" d'éléments de manière contigue en mémoire, tu dois avoir recours à une classe expressément créée à cet usage et fournie par n'importe quelle implémentation de la bibliothèque standard, à savoir la classe std::vector

De plus, lorsque l'on définis un tableau à deux dimensions de L lignes et de C colonnes, on se rend compte que, ce que l'on souhaite en réalité, c'est d'avoir l'occasion de représenter L * C éléments, si bien qu'il est souvent préférable de "linéariser" ce tableau à deux dimensions pour le transformer en un tableau à une seule dimension de ... L * C éléments.

Pour accéder à l'élément se trouvant à la ligne line et à la colonne row données, on utilisera alors une formule simple prenant la forme deelement_recherche = line * C + rowTu pourrais donc avoir un code proche de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 int main(){ std::vector<int> nombre_visible(250*250,0); /* depuis l'arrivée de C++11 (il y a déjà 6 ans!!! il serait tout doucement temps * de l'utiliser !!!) * les classes *fstream acceptent une std::string comme nom de fichier */ std::ifstream flux_visible(image_visible); /* la fonction chiffre renvoie un int, autant le récupérer, car * je présumes que ce n'est pas pour rien */ auto recup =chiffre(flux_visible, nombre_visible); }
en modifiant la fonction chiffre pour qu'elle prenne la forme de
Code:

1 2 3 4 5 6 7 /* je transmet le fichier sous la forme d'un std::istream au lieu d'un std::ifstream * pour le cas où le flux ne serait pas un fichier */ int chiffre(std::istream & ifs, std::vector<int> & tab){ }
L'étape suivante consisterait sans doute à se dire que notre std::vector représente la notion de "matrice", et qu'il serait donc utile d'en faire un "type à part entière" qui cacherait notre "formule magique" à celui qui doit l'utiliser.

Comme nous pouvons envisager de l'utiliser avec différents types d'éléments, nous pourrions directement en faire une classe template proche de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 template <typename T> class Matrix{ public: Matrix(size_t lines, size_t rows, T defaultValue=T{}): lines_{lines}, rows_{rows},datas_(lines*rows,defaultValue){ } /* les accès aux différents éléments, en lecture seule et en écriture */ T operator()(size_t l, size_t r) const{ /* la valeur de l et de r doit être inférieure à la valeur respective de * lines_ et de rows_. * si ce n'est pas le cas, c'est une erreur de programmation qui devra * être corrigée */ assert(l < lines_ && "lines index out of bound"); assert(r < rows_ && "rows index out of bound"); return datas_[l*rows_ + r]; } T& operator()(size_t l, size_t r) { /* la valeur de l et de r doit être inférieure à la valeur respective de * lines_ et de rows_. * si ce n'est pas le cas, c'est une erreur de programmation qui devra * être corrigée */ assert(l < lines_ && "lines index out of bound"); assert(r < rows_ && "rows index out of bound"); return datas_[l*rows_ + r]; } /* il est toujours intéressant de connaitre les limites */ size_t lines() const{ return lines_; } size_t rows() const{ return rows_; } private: size_t lines_; size_t rows_; std::vector<T> datas_; };
et nous pourrions modifier une dernière fois notre code d'origine pour lui donner une forme proche de
Code:

1 2 3 4 5 6 7 8 9 int main(){ size_t const MAXLINES{250}; size_t const MAXROWS{250}; Matrix<int> nombre_visible(MAXLINES*MAXROWS); std::ifstream flux_visible(image_visible); auto recup =chiffre(flux_visible, nombre_visible); /* .... */ }
en modifiant la fonction chiffre pour qu'elle prenne la forme de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 /* je transmet le fichier sous la forme d'un std::istream au lieu d'un std::ifstream * pour le cas où le flux ne serait pas un fichier */ int chiffre(std::istream & ifs, Matrix & mat){ /* en modification, la classe Matrix s'utiliserait sous une forme proche de */ for(size_t line=0; line<mat.lines(); ++line){ for(size_t row = 0; row<mat.rows();++row){ mat(line, row)=nouvelleValeur; } } }