En passant un pointeur représentant un tableau 2D à une fonction en C++

http://www.neilstuff.com/guide_to_cpp/notes/Multi%20Dimension%20Arrays%20and%20Pointer%20Pointers.htm

Selon ce site, je devrais être en mesure d'utiliser le code suivant:

double stuff[3][3];
double **p_stuff;
p_stuff = stuff;

Mais je reçois une plainte que la conversion n'est pas autorisé par la cession.

Je fais quelque chose de mal?

J'ai un extern "C" type de fonction que je veux faire passer ce stuff double[3][3]. Donc, je pense que j'ai besoin de faire un pointeur, non?

Pas la note est mauvaise. double[3][3] ne peut pas être décomposée à double** (il se désintègre à (double*)[3]).
Essayez p_stuff = new double *trucs[3] après la double **p_stuff
Qu'est-ce que la signature de cette fonction C?
Édité question afin de refléter mon intention..obtenir ce stuff double[3][3] pour une fonction C.
Je suis en train d'écrire la fonction C...de sorte que je peux faire de la signature de ce que je veux. Maintenant que je l'ai eu comme (....., double **p_stuff, ...)

OriginalL'auteur Derek | 2011-03-16

  1. 12

    Concernant le montage: pour passer ce double stuff[3][3] à une fonction C, vous pourriez

    1) passer un pointeur à l'ensemble du tableau 2D:

    void dostuff(double (*a)[3][3])
{
//access them as (*a)[0][0] .. (*a)[2][2]
}
int main()
{
    double stuff[3][3];
    double (*p_stuff)[3][3] = &stuff;
    dostuff(p_stuff);
}

    2) passer un pointeur vers le premier 1D array (première ligne) et le nombre de lignes

    void dostuff(double a[][3], int rows)
{
//access them as a[0][0] .. a[2][2]
}
int main()
{
    double stuff[3][3];
    double (*p_stuff)[3] = stuff;
    dostuff(p_stuff, 3);
}

    3) de passer un pointeur vers la première valeur dans la première ligne et le nombre de colonnes et de lignes

    void dostuff(double a[], int rows, int cols)
{
//access them as a[0] .. a[8];
}
int main()
{
    double stuff[3][3];
    double *p_stuff = stuff[0];
    dostuff(p_stuff, 3, 3);
}

    (que cette dernière option n'est pas strictement conforme aux normes, puisqu'elle avance un pointeur vers un élément d'un tableau 1D (la première ligne) - delà de la fin de ce tableau)

    Si ce n'était pas une fonction C, il y avait un peu plus d'options!

    +1, Comme une légère extension à la dernière ligne, en C++, vous pouvez également passer le tableau par référence, et vous pouvez utiliser des modèles pour rendre le code indépendant de la taille des matrices: template <std::size_t N, std::size_t M> void process( double (&a)[N][M] ); si vous voulez être en mesure de travailler avec des tailles différentes. Mélanger et assortir comme vous le souhaitez: si vous souhaitez uniquement pour permettre au carré des tableaux de l'utilisation d'un modèle unique argument.

    OriginalL'auteur Cubbi

  2. 3

    Votre attribué est erronée. p_stuff; est pointeur de pointeur de double alors que stuff est tableau à deux dimensions( tableau de tableaux)

    Une seule dimension de la matrice de désintégrations le pointeur vers son premier élément. 2 dimensions de la matrice de désintégrations de pointeur vers un tableau unidimensionnel.

    Essayer cette

    double stuff[3][3];
double (*p_stuff)[3]; //pointer to array of 3 int
p_stuff = stuff;

    OriginalL'auteur Prasoon Saurav

  3. 1

    double ** p_stuff; correspond à un tableau de pointeur de double. double stuff[3][3] n'ont pas de pointeurs - c'est un tableau 2D de double.

    Édité question afin de refléter mon intention..obtenir ce stuff double[3][3] pour une fonction C.

    OriginalL'auteur Erik

  4. 0

    Ci-dessous est peut-être votre réponse:

    #include <stdio.h>
#include <stdlib.h>

typedef unsigned int uint;
uint m[10][20];
uint **ppm;

int main() {
    int i;

    ppm = (uint **)m;
    for (i =0; i<10; ++i)ppm[i] = (uint *)&m[i];

    m[1][1] = 10;

    printf("0x%x vs 0x%x: %d vs %d\n", ppm,m, m[1][1], *(*(ppm+1)+1));

    return 0;
}

    Le résultat sur l'écran de la console:

    0x6010a0 vs 0x6010a0: 10 vs 10

    OriginalL'auteur Thảo Hoàng Minh

  5. 0

    En plus de Cubbi détaillées de réponse, la façon suivante est tout naturel de passer à 2 dim tableau à une fonction:

    void dostuff(void *a1, int rows, int cols)
{
    double (*a)[cols] = (double (*)[cols]) a1;
    //access them as a[0][0] .. a[rows-1][cols-1];
}
int main()
{
    double stuff[3][3];
    dostuff(stuff, 3, 3);
}

    Vous n'avez pas à les jeter à l'avance, car le nouveau C++ (C++14) prend en charge au moment de l'exécution de la taille des tableaux.

    OriginalL'auteur Simon Woo