Discussion :

[Ark Kre]

Bonjour à tous, alors voilà j'avais un problème avec la transmission d'un tableau bidirectionnel en argument d'une fonction, j'ai résolu le problème grâce à la FAQ cependant je n'ai pas compris la solution.
Voila mon code(il est pas terminé mais c pour servir de support):

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
#include <iostream>
 
using namespace std;
 
void remplissage(char *Espace2D, int N, int M, int iLig1, int iCol1, int iLig2, int iCol2, char couleur)
{
    for(int ligne = iLig1; ligne < iLig2; ligne++)
        for(int colonne = iCol1; colonne < iCol2; colonne++)
            Espace2D[iCol2 * ligne + colonne] = couleur;
}
 
int main()
{
    int nbLignes(0);
    int nbColonnes(0);
    cin >> nbLignes;
    cin >> nbColonnes;
    char Espace2D[nbLignes][nbColonnes];
    int N = sizeof(Espace2D) / sizeof(Espace2D[0]), M = sizeof(Espace2D[0]) / sizeof(Espace2D[0][0]);
    remplissage(*Espace2D, N, M, 0, 0, nbLignes, nbColonnes, '.');
    for(int ligne = 0; ligne < nbLignes; ligne++)
    {
        for(int colonne = 0; colonne < nbColonnes; colonne++)
        {
            cout << Espace2D[ligne][colonne];
        }
        cout << "\n";
    }
 
 
    int nbRectangles(0);
    cin >> nbRectangles;
 
 
 
 
    return 0;
}

Alors si je comprend bien les variables N et M que j'ai initialisé corresponde en réalité à nbLignes et nbColonnes (dites le moi si je dit une connerie).
Le passage que je comprend vraiment pas c'est ça:

Code :

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

Espace2D[iCol2 * ligne + colonne] = couleur;

je vois pas comment ça représente une case de mon tableau, si qqn veut bien m'expliquer ça serait sympa
Merci d'avance

[Médinoc]

Cette ligne part de la supposition que iCol2 n'est pas seulement la colonne "maximale" à remplir, mais aussi la largeur de ton tableau 2D (le nombre total de colonnes).
Bien que dans le cas actuel ce soit le cas, c'est probablement une erreur.

De plus, ceci n'est pas censé marcher en C++:

Code :

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

1
2
3
4
5
    int nbLignes(0);
    int nbColonnes(0);
    cin >> nbLignes;
    cin >> nbColonnes;
    char Espace2D[nbLignes][nbColonnes];

Ici, Espace2D est déclaré comme un Variable-Length Array, une fonctionnalité qui ne fait pas partie du standard C++ (elle fait partie des standards C récents).
En fait, ce code ressemble à un mélange impie de C et C++: En C++ on utiliserait un vecteur de taille nbLignes * nbColonnes, conjointement avec la formule monVecteur[ iLigne*nbColonnes + iColonne ] pour accéder aux différentes cases...

[Matt_Houston]

Code :

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

Espace2D[iCol2 * ligne + colonne] = couleur;

je vois pas comment ça représente une case de mon tableau, si qqn veut bien m'expliquer ça serait sympa

En dehors des évidents défauts techniques justement pointés par Médinoc, je voudrais traiter cette question : comment un tableau unidimensionnel peut-il faire référence aux données d'une matrice bidimensionnelle ?

J'imagine qu'il s'agit de faire du traitement d'image, ou quelque chose de la sorte. Visualisons donc cela de manière graphique. Voici un bloc de plusieurs éléments contigüs en mémoire (on dira tableau pour simplifier), avec leurs adresses :

Code :

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

1
2
3
4
          0   1   2   3   4   5   6   7   8   9  10  11
        +---+---+---+---+---+---+---+---+---+---+---+---+
        |   |   |   |   |   |   |   |   |   |   |   |   |
        +---+---+---+---+---+---+---+---+---+---+---+---+

« Découpons » mentalement ce tableau rectiligne en blocs de taille fixe et modifions l'agencement de ces.. disons sous-tableaux :

Code :

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

1
2
3
4
5
6
7
8
          0   1   2   3       4   5   6   7       8   9  10  11
        +---+---+---+---+   +---+---+---+---+   +---+---+---+---+
        |   |   |   |   |   |   |   |   |   |   |   |   |   |   |
        +---+---+---+---+   +---+---+---+---+   +---+---+---+---+
                                    |                   |
                        <-----------+                   |
                                                        |
                        <-------------------------------+

Code :

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

1
2
3
4
5
6
7
8
9
    0                   x
      +--------------->                  
      | +---+---+---+---+
      | |   |   |   |   |  <-  0   1   2   3
      | +---+---+---+---+
      | |   |   |   |   |  <-  4   5   6   7
      | +---+---+---+---+
      v |   |   |   |   |  <-  8   9  10  11
    y   +---+---+---+---+

Qu'obtient-on ? Une matrice. Et une image n'est rien d'autre qu'une matrice dont chaque élément représente la couleur du pixel associé. Comment retrouve-t-on l'élément qui stocke les données du pixel aux coordonnées (x, y) sachant que l'adressage mémoire est réalisé sur une seule dimension ?

Réalisons que :

• y est l'index du sous-tableau qui stocke la ligne de pixels qui nous intéresse ;
• x est l'index de l'élément qui stocke le pixel qui nous intéresse, au sein de ce même sous-tableau ;
• le nombre d'éléments d'un sous-tableau correspond à la largeur de l'image.

On en déduit l'index de l'élément qui nous intéresse au sein du grand tableau : i = y * largeur + x .

[Ark Kre]

Merci de vos réponses, en gros si j'ai bien compris un tableau[n][n] n'est rien qu'un tableau[n*n] et on peut y accéder avec les deux formes ??
Je me demandais aussi juste comment par exemple si j'ai un: int tableau[n] si je suis obligé pour l'initialisé avec le flux entrant de faire

Code :

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

1
2
3
int variable;
cin >> variable;
tableau[n] = variable;

où est ce qu'il y a un moyen en une ligne de d'initialiser tableau[n] (n entier quelconque) avec un flux entrant ?

[foetus]

Il faut savoir qu'en C++, new XX[x][y] est interdit il faut le faire ainsi new XX[x*y]

[Matt_Houston]

Merci de vos réponses, en gros si j'ai bien compris un tableau[n][n] n'est rien qu'un tableau[n*n] et on peut y accéder avec les deux formes ??

Oui c'est équivalent, mais pour un tableau multidimensionnel issu d'une déclaration statique uniquement, dont les dimensions sont connues à la compilation. C'est-à-dire pas vraiment ce que tu cherches à faire.

où est ce qu'il y a un moyen en une ligne de d'initialiser tableau[n] (n entier quelconque) avec un flux entrant ?

Code :

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

std::vector<char> v(size);

..ou encore :

Code :

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

1
2
3
4
5
std::vector<char> v;
 
// ...
 
v.resize(size);

[Médinoc]

@Matt_Houston: Tu as oublié la partie "avec un flux entrant".

Il me semble que c'est possible avec les itérateurs...

[Ark Kre]

ok merci à tous, c'est vraiment sympa d'avoir répondu ça m'a pas mal aidé
thx

[Matt_Houston]

@Matt_Houston: Tu as oublié la partie "avec un flux entrant".

J'ai surtout oublié la partie « initialiser » ! Je m'étais focalisé sur l'allocation dynamique du buffer (la partie reserve de resize).

De toute manière je ne sais pas répondre à cette question, j'évite les flux C++ comme la peste.

[Médinoc]

En gros, tu dois pouvoir lire un vecteur en une ligne avec un truc de ce genre:

Code C++ :

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

std::copy_n(std::istream_iterator<int>(std::cin), monVecteurDeInt.size(), monVecteurDeInt.begin());

Note: Je n'ai pas testé.