Pointeur sur tableau a double dimension

Sujet résolu

Anonyme

14 juillet 2007 à 13:51:23

Bonjours chers codeur,
Aujourd'hui j'ai besoin de votre aide pour créer un pointeur sur un tableau a double dimension. Si j'entre le code suivant le debugueur me dit que le pointeur et l'adresse du tableau n'ont pas la meme dimension :

int carte[10][10000];
int *p_carte[10][10000];
p_carte=&carte;

Je pensai alors a créer un pointeur sur un tableau a une dimension et créer une boucle for mais je m'enbrouille un peu est-ce un tableau de pointeur.
Alors si quelqu'un pouvez m'aider, merci d'avance.

TylerDurden

14 juillet 2007 à 14:05:48

Si mes souvenirs sont bons (mais ça fait un moment que j'ai pas utilisé de tableaux à 2D ^^), il faut que ton pointeur pointe sur la première case de la deuxième dimension de la première case, autrement dit sur [0][0]. Il te faut donc un pointeur sur pointeur.

Anonyme

14 juillet 2007 à 14:09:07

ben si ca pointe sur [0][O] C juste un int pas un tableau non ?

lmghs

14 juillet 2007 à 14:16:39

Pose ta question dans la forum C. Ils sont plus habitués à ce genre de choses.

** Phil **

14 juillet 2007 à 14:24:51

Tu fais d'abord un tableau de pointeur du nombre de lignes dont tu as besoin.

Puis pour chaque ligne, tu alloues le nombre de colonnes souhaitées

int **tableau = new int *;
for(int x = 0; x < nombreLigne; x++)
{
tableau[x] = new int[nombreColonne];
}

Ne pas oublier de libérer la mémoire

for(int x = 0; x < nombreLigne; x++)
{
delete [] tableau[x];
}
delete tableau;

lmghs

14 juillet 2007 à 14:33:28

Le type qu'il manipule n'est pas un pointeur vers un tableau de pointeurs, mais un tableau typé 2D précisément dimensionné.

Il y a des parenthèses à rajouter quelques part, je ne me souviens jamais où. Le forum C, et les messages d'erreurs du compilo peuvent te mettre sur la piste.

Accessoirement, pourquoi un niveau d'indirecton supplémentaire ? Que cherches-tu à faire ? Je soupçonne que tu te compliques inutilement la vie.

Anonyme

14 juillet 2007 à 14:38:30

ca que je veux c'est de pouvoir modifier mon tableau après sa modification dans une fonction d'ou le pointeur
je vais essayer phil merci

lmghs

14 juillet 2007 à 15:01:20

void f( int t[10][10000]) {
t[2][42] = 5;
}
...
int t[10][10000] = {0};
f(t);
std::cout << t[2][42];

Par contre, je doute fortement que tu puisses allouer un truc aussi gros sur la pile.

Anonyme

14 juillet 2007 à 15:18:49

le double tableau n'est pas le seul argument de ma fonction alors soit je trouve comment le pointer soit j'arrive a trouver comment la fonction peut retourner un double tableau

lmghs

14 juillet 2007 à 15:26:00

Rajoute un argument. Où est le problème ?

Anonyme

14 juillet 2007 à 15:33:04

ben le void ne modifie pas mon tableau si ya plusieur argument mon tableau avant et après est le meme

lmghs

14 juillet 2007 à 15:55:51

quoi?
Ma fonction f au dessus modifie le tableau.

TylerDurden

14 juillet 2007 à 15:57:36

Le tableau de pointeurs me paraît être une bonne solution. Tu crées un tableau de 10 int*, et chacun pointe vers carte[0][0], carte[1][0] etc., ensuite pour accéder aux divers éléments, par exemple carte[2][3], tu n'as qu'à écrire *(p_carte2+3) = 90.
Pour le faire passer dans la fonction, tu crées un pointeur pointant vers ton tableau de pointeurs et le tour est (devrait être) joué.

** Phil **

14 juillet 2007 à 18:43:47

Pour que nous puissions aller plus loin, il nous faudrait plus de détails sur ce que tu veux faire.

Mais, si tu passes un pointeur en argument à ta fonction, il modifie directement la zone de mémoire allouée au tableau. Tu n'as donc aucun retour à faire concernant le tableau.

Pour t'en convaincre, essaie ce petit exemple

#include <iostream>

using namespace std;

void fonction(int **tableau, int nombreLigne, int nombreColonne);

int main()
{
int nombreLigne = 0, nombreColonne = 0;

int valeur = 0;

cout << "___________________________________________________" << endl << endl;
cout << "Allocation dynamique d'un tableau a deux dimensions" << endl;
cout << "___________________________________________________" << endl << endl;

cout << "Saisie des dimensions du tableau" << endl << endl;
cout << "Nombre de lignes = ";
cin >> nombreLigne;
cout << "Nombre de colonnes = ";
cin >> nombreColonne;
cout << endl << endl;

//________________________________

// Allocation dynamique du tableau
//________________________________
int **tableau = new int *;
for(int x = 0; x < nombreLigne; x++)
{
tableau[x] = new int[nombreColonne];
}

//____________________

// Un petit traitement
//____________________

fonction(tableau, nombreLigne, nombreColonne);

cout << "____________________________________________" << endl << endl;
cout << "Affichage du tableau (" << nombreLigne << " lignes, " << nombreColonne << " colonnes)" << endl;
cout << "____________________________________________" << endl << endl;

for(int x = 0; x < nombreLigne; x++)
{
cout << "ligne " << x + 1 << " : ";
for(int y = 0; y < nombreColonne; y++)
{
cout << tableau[x][y] << " ";
}
cout << endl;
}

//_________________________

// Libération de la mémoire
//_________________________
for(int x = 0; x < nombreLigne; x++)
{
delete [] tableau[x];
}
delete tableau;

return 0;
}

void fonction(int **tableau, int nombreLigne, int nombreColonne)
{
int valeur = 0;

for(int x = 0; x < nombreLigne; x++)
{
for(int y = 0; y < nombreColonne; y++)
{
tableau[x][y] = valeur++;
}
}
}

Tu peux voir que le tableau est modifié dans la fonction et l'affichage dans le main tient bien compte des modifications