Discussion :

[cewein]

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

Code :

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

1
2
3
4
int chiffre(ifstream x, int y[][250])
{
 
}

dans mon main() il y a :

Code :

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

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

[Bousk]

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

[cewein]

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

[koala01]

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 :

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

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 :

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

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 :

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

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 :

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
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 :

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

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 :

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

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;
        }
    }
}