Pointeur sur un tablea de int

Pascal <teapa5@B022-05.fr> writes:

Bonjour,

Le code suivant ne marche pas :

void intncpy(int ***dest, int **src)
{
int i, j;

for (i = 0; i < g_nbTerminaux; ++i)
for (j = 0; j < g_nbConcentrateur; ++j)
*dest[i][j] = src[i][j];

(*dest)[i][j]
blabla precedence des operateurs blabla
sinon blabla vector blabla reference blabla
blabla besoin de vacances blabla


--
js

Pascal wrote:

Bonjour,

Le code suivant ne marche pas :

void intncpy(int ***dest, int **src)
{
int i, j;

for (i = 0; i < g_nbTerminaux; ++i)
for (j = 0; j < g_nbConcentrateur; ++j)
*dest[i][j] = src[i][j];
}

Je l'appelle comme ça : intncpy(&dest, src).
Ca segfaut des que i = 1. Pour i = 0, ça marche.
Pourquoi?

pas certain que ce soit ca, mais j'ai souvent vu ce genre d'erreur quand
les indices sont inversés. cad i varie suivant le nb de Terminaux alors
qu'il doit correspondre a un numero de concentrateur.
ca se traduit dans ton cas par remplacer [i][j] par [j][i]

Pascal <teapa5@B022-05.fr> wrote:

Bonjour,

Le code suivant ne marche pas :

void intncpy(int ***dest, int **src)
{
int i, j;

for (i = 0; i < g_nbTerminaux; ++i)
for (j = 0; j < g_nbConcentrateur; ++j)
*dest[i][j] = src[i][j];
}

Je l'appelle comme ça : intncpy(&dest, src).
Ca segfaut des que i = 1. Pour i = 0, ça marche.
Pourquoi?

(*dest)[i][j] = src[i][j];

Mais une fonction du type

void intncpy(int **dest, int **src)

suffirait. Appel intcspy(dest,src)

Dans ce cas remplacer

*dest[i][j] = src[i][j];

par

dest[i][j] = src[i][j];

--
Horst

--
Lâche pas la patate!

Pascal wrote:

Le code suivant ne marche pas :

void intncpy(int ***dest, int **src)
{
int i, j;

for (i = 0; i < g_nbTerminaux; ++i)
for (j = 0; j < g_nbConcentrateur; ++j)
*dest[i][j] = src[i][j];
}

Je l'appelle comme ça : intncpy(&dest, src).
Ca segfaut des que i = 1. Pour i = 0, ça marche.
Pourquoi?

Sans voir les définitions des paramètres, c'est impossible à
savoir. Pour ce que tu as écrit, il faut que tu comme dest un
tableau de pointeurs à des pointeurs, et en source, un tableau
des pointeurs. Si tu as quelque chose comme :

int * d[ N ][ M ] ;
int s[ N ][ M ] ;

par exemple, il faudrait écrire plutôt :
void intncpy( int* dest[][ M ], int src[][ M ] ) ;
ce qui équivaut :
void intncpy( int* (*dest)[ M ], int (*src)[ M ] ) ;
Et qui ne marche que si M est une constante.

Note bien qu'en général, un pointeur n'est pas un tableau, ni
vice versa. Un tableau se convertit en pointeur dans beaucoup de
contextes, et une déclaration d'un tableau comme paramètre de
fonction revient à une déclaration d'un pointeur, mais...
formellement, les tableaux de plusieurs dimensions n'existent
pas en C ; on a plutôt des tableaux de tableaux. Alors, en tant
que paramètre, un tableau de tableaux se convertit en un
pointeur à un tableaux, mais alors, le paramètre n'est plus un
tableau, mais un pointeur, et il n'y a plus de conversions.
Donc, une déclaration du type int** ne vaut pas pour un tableaux
de deux dimensions.

En passant, je n'ai pas compris les commentaires de certains
autres. Ils avaient l'air de dire que ton expression était
l'équivalent de (*dest)[i][j], ce qui n'est pas du tout le cas.
Les précédances donne bien *((dest[i])[j]).

Je fais ça parce que :
j'ai une fonction int **f();

Car quand je fais dest = f(src), ça ne marche pas. Le contenu
de dest reste inchangé...

J'ai une idée. Laisse tomber ces tableaux de type C, et utilise
std::vector. C'est un type comme un autre, sans sémantique
spéciale, et donc sans toutes les surprise que te réservent les
tableaux de type C.

--
James Kanze GABI Software
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34