Pointeur de char**

Version imprimable

Pointeur de char**

Bonjour,

Malgré mes recherches ("pointeur multi dimensionel") je ne parvient pas à résoudre mon probléme.
J'ai réduit mon code au strict, comment le faire marcher ?

Code:

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
40
41
42
43
44
45
46
47
48
 
#include <stdlib.h>
#include <stdio.h>
 
int main(void)
{
	int i;
	int j;
	const char liste[3][11] = {
		{"azertyuiop"},
		 {"qsdfghjklm"},
		  {"wxcvbn"}
	};
	char **ptr_3;
	char *ptr_10;
 
	// Marche (acces en tableau) :
	/*
	 * azertyuiop
	 * qsdfghjklm
	 * wxcvbn
	 */
	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 10; j++)
		{
			printf("%c", liste[i][j]);
		}
		printf("\n");
	}
 
	// Ne marche pas (acces en pointeur) :
	ptr_3 = (char **)liste;
	for (i = 0; i < 3; i++)
	{
		ptr_10 = *ptr_3;
		// Plantage
		for (j = 0; j < 10; j++)
		{
			printf("%c", *ptr_10); // Plantage
			ptr_10++;
		}
		printf("\n");
		ptr_3++;
	}
 
	return 0;
}

Merci beaucoup de vos réponses.

Bonjour,

Ton tableau liste est particulier, une ne passe pas de la première ligne à la seconde avec un simple ++ :

Code:

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
 
#include <stdlib.h>
#include <stdio.h>
 
#define SHOW_ADDRESS(par) printf(#par ":%p\n", (void*)par)
 
typedef char char_3[3];
 
int main(void)
{
    const char liste[3][11] = {
        {"azertyuiop"},
        {"qsdfghjklm"},
        {"wxcvbn"}
    };
 
    char **ptr = liste;
 
    SHOW_ADDRESS(&liste[0]);
    SHOW_ADDRESS(&liste[1]);
    SHOW_ADDRESS(&liste[2]);
    SHOW_ADDRESS(ptr + 0);
    SHOW_ADDRESS(ptr + 1);
    SHOW_ADDRESS(ptr + 2);
 
    return 0;
}

Ce qui se passe c'est que lorsqu'on passe aux double pointeur, on perd l'information de taille du tableau.
Voici un code qui fait ce que tu attends :

Code:

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
40
41
42
43
44
45
46
47
48
49
50
51
 
#include <stdlib.h>
#include <stdio.h>
 
typedef char char_3[3];
 
int main(void)
{
    int i, j;
    char *ptr_10;
    char **ptr_3;
    const char liste[3][11] = {
        {"azertyuiop"},
        {"qsdfghjklm"},
        {"wxcvbn"}
    };
 
 
    /* méthode simple : on utilise encore liste[i]*/
	for (i = 0; i < 3; i++)
	{
		ptr_10 = liste[i];
 
		for (j = 0; j < 10; j++)
		{
			printf("%c", *ptr_10); 
			ptr_10++;
		}
		printf("\n");
 
	}
 
    /* méthode moins simple : on se décale de la taille de la premiere ligne
       du tableau */
	ptr_3 = (char **)liste;
	for (i = 0; i < 3; i++)
	{
		ptr_10 = ptr_3;
 
		for (j = 0; j < 10; j++)
		{
			printf("%c", *ptr_10); 
			ptr_10++;
		}
		printf("\n");
		ptr_3 = (int)ptr_3 + sizeof *liste;
	}
 
 
    return 0;
}

je confirme l'incrément doit prendre en compte la taille des données du tableau.

En simplifiant un peu, normalement le système va allouer un bloc de mémoire contiguë pour contenir ton tableau (3*10) 30 élément. ton tableau de 3x10 éléments sera considéré comme un tableau de 30 element par le système.

l'adresse du premier élément de ton tableau est la même que celle de la première ligne. Cependant pour avoir l'adresse de la seconde ligne de ton tableau il faut faire un calcul et ajouter la taille mémoire de la première ligne afin de pointer sur le 11ème element du tableau.

du fait de cette arrangement de la mémoire cette écriture:
Code:

1 2 3 4 5 6 7 8 9 10 11 ptr_3 = (char **)liste; for (i = 0; i < 3; i++) { ptr_10 = ptr_3; for (j = 0; j < 10; j++) { printf("%c", *ptr_10); ptr_10++; } printf("\n"); ptr_3 = (int)ptr_3 + sizeof *liste; }
est équivalente à
Code:

1 2 3 4 5 6 7 8 9 10 11 char * ptr_3_10; ... ptr_3_10 = (char *)liste; for (i = 0; i < 3 * 10; i++) { printf("%c", *ptr_3_10); ptr_3_10++; if (((i+1) % 10) == 0) { printf("\n"); } }

08/06/2010, 15h26
mk_____

Merci beaucoup à vous deux pour la description et votre solution.

Le problème majeur est de vouloir imposer au compilateur d'accepter une erreur :
Code:

1 2 3 4 5 6 7 8 char **ptr_3; const char liste[3][11] = { {"azertyuiop"}, {"qsdfghjklm"}, {"wxcvbn"} }; ... ptr_3 = (char **)liste;
puisqu'en aucun cas liste n'est un char **. Ce n'est pas non plus un char*, c'est un char(*)[11].
On devrait avoir (par exemple)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 int i, j; const char liste[3][11] = { {"azertyuiop"}, {"qsdfghjklm"}, {"wxcvbn"} }; const char (*ptr_3)[11]; const char *ptr_10; ptr_3 = liste; for (i = 0; i < 3; i++) { ptr_10 = *ptr_3; for (j = 0; j < 10; j++) { printf("%c", *ptr_10); ptr_10 ++; } printf("\n"); ptr_3++; }
ou si on veut simplifier un peu l'écriture :
Code:

1 2 3 4 5 6 7 8 9 typedef const char Ligne[11]; ... Ligne liste[3] = { {"azertyuiop"}, {"qsdfghjklm"}, {"wxcvbn"} }; Ligne *ptr_3; ...
@mabu : mis à part les const qui manquent dans les définitions de ptr_3 et ptr_10 :
1- on a un cast sauvage de liste pour le faire admettre dans ptr_3,
2- on doit avoir un warning sur ptr_10 = ptr_3, le type des pointeurs est différent (et différent de void*)
3- Le passage par des int pour calculer la nouvelle adresse, pointeur->int->pointeur, est barbare et non portable.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 const char *ptr_10; const char **ptr_3; const char liste[3][11]= .... .... ptr_3 = (const char **)liste; // cast sauvage for (i = 0; i < 3; i++) { ptr_10 = ptr_3; // warning for (j = 0; j < 10; j++) { printf("%c", *ptr_10); ptr_10++; } printf("\n"); ptr_3 = (int)ptr_3 + sizeof *liste; // non portable }
@jabbounet : La méthode esquive un peu la question puisqu'elle consiste à considérer le tableau à deux dimensions comme un tableau à une dimension. Ceci dit, mis à part le const qui manque dans la définition de ptr_3_10, pourquoi conserver le cast sauvage inutile ?
Code:

1 2 3 const char * ptr_3_10; ... ptr_3_10 = liste[0];