Discussion :

[jose.hello]

Bonjour,

J'avais fait un autre post, mais avec le mauvais titre, j'ouvre donc un nouveau topic. Pour une meilleure recherche parmi les topic

j'aimerai faire un tableaux dynamique de char *

j'ai ce code pour l'instant

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
39
40
41
 
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
void main()
{
	int i = 0;
	char **tab;
	char *element = "ici";
	char *test2;
	int taille = 4;
	char test01[7]="lool01\0";
	char test02[7]="lool02\0";
	char test03[7]="lool03\0";
	char test04[7]="lool04\0";
 
	tab = (char **) malloc(taille * sizeof(char *));
	for(i=0;i<taille;i++)
	{				
		*(tab+i)=test01;
		if(i==2)
			*(tab+i)=test02;		
	}
	// allocation de 20 cases en plus
//	for(i=0;i<20;i++)
//	{
//		tab = (char **) realloc(tab,(taille+i+1) * sizeof(char *));
//		*(tab+i)=test04;
//	}
	tab = (char **) realloc(tab,(taille+i) * sizeof(char *));
 
	*(tab+i)=test04;
 
	for(i=0;i<taille+1;i++)
	{
	 	printf("%d - %s\n",i,*(tab+i));
	}
	free(tab);
}

il fonctionne très bien voici la sortie :
0 - lool01
1 - lool01
2 - lool02
3 - lool01
4 - lool04


mais si on dé-commente la boucle for comme ici

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
39
40
41
 
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
void main()
{
	int i = 0;
	char **tab;
	char *element = "ici";
	char *test2;
	int taille = 4;
	char test01[7]="lool01\0";
	char test02[7]="lool02\0";
	char test03[7]="lool03\0";
	char test04[7]="lool04\0";
 
	tab = (char **) malloc(taille * sizeof(char *));
	for(i=0;i<taille;i++)
	{				
		*(tab+i)=test01;
		if(i==2)
			*(tab+i)=test02;		
	}
	// allocation de 20 cases en plus
	for(i=0;i<20;i++)
	{
		tab = (char **) realloc(tab,(taille+i+1) * sizeof(char *));
		*(tab+i)=test04;
	}
//	tab = (char **) realloc(tab,(taille+i) * sizeof(char *));
 
//	*(tab+i)=test04;
 
	for(i=0;i<taille+16;i++)
	{
	 	printf("%d - %s\n",i,*(tab+i));
	}
	free(tab);
}

La sortie n'est plus correcte
0 - lool04
1 - lool04
2 - lool04
3 - lool04
4 - lool04
5 - lool04
6 - lool04
7 - lool04
8 - lool04
9 - lool04
10 - lool04
11 - lool04
12 - lool04
13 - lool04
14 - lool04
15 - lool04
16 - lool04
17 - lool04
18 - lool04
19 - lool04


alors qu'au début on devrai avoir cela :
0 - lool01
1 - lool01
2 - lool02
3 - lool01
4 - lool04
....

Ce n'est pas le cas
De plus, le tableau ne comporte que 20 cases au lieu de 24.
(Si j'affiche jusqu'a 24 cases alors le prog fait un segmentation Erreur)


D'autre part j'utilise le même principe dans un projet plus conséquent et j'obtient cette erreur :
*** glibc detected *** ./my_pc: realloc(): invalid next size: 0x08aab710 ***

+Backtrace et memory map ...


Je pense fortement que mon realloc ne fonctionne pas.

Merci pour les réponses

CDLT

[Sve@r]

Salut

Je ne pige pas vraiment ce que tu cherches à faire. Donc déjà je vais commencer par te dire ce qui ne va pas...

Code c :

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

void main()

ok, super. Ca veut faire du pointeur et ça n'a même pas lu B-A BA du langage...

Code c :

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

1
2
3
4
char test01[7]="lool01\0";
char test02[7]="lool02\0";
char test03[7]="lool03\0";
char test04[7]="lool04\0";

Ca ce n'est absolument pas bon. Parce que le compilo, quand il voit des quottes ("), il rajoute lui-même un '\0' au tableau mais il ne modifie pas l'espace prévu (ici 7 ce qui est donc insuffisant). Donc normalement, il faudrait écrire ceci

Code c :

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

1
2
3
4
char test01[8]="lool01\0";
char test02[8]="lool02\0";
char test03[8]="lool03\0";
char test04[8]="lool04\0";

Toutefois le compilo, s'il n'y a pas de taille aux chaines, calcule lui-même la taille qu'il faut. Donc on peut alors écrire ceci

Code c :

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

1
2
3
4
char test01[]="lool01\0";
char test02[]="lool02\0";
char test03[]="lool03\0";
char test04[]="lool04\0";

Et enfin, comme le compilo met lui-même le '\0', inutile de le mettre toi ce qui donne alors

Code c :

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

1
2
3
4
char test01[]="lool01";
char test02[]="lool02";
char test03[]="lool03";
char test04[]="lool04";

Ensuite, je ne pige pas ceci

Code c :

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

1
2
3
4
5
6
for(i=0;i<taille;i++)
{				
	*(tab+i)=test01;
	if(i==2)
		*(tab+i)=test02;		
}

Déjà, si i == 2, tu remplis 2 fois la variable *(tab + 2) donc c'est forcément une fois de trop. Ensuite le reste je pige plus. Tu fais du realloc de (taille+i) on sait pas trop pourquoi, tu mets ensuite test04 dans l'adresse 5 (hé oui, tu boucles tant que i < 4 donc quand la boucle se termine, i vaut 4 donc *(tab + i) correspond à la 5° case de tab !!!) bref ici j'arrête de chercher. Je présume que tu veux placer testXX dans la case tabXX mais bon, c'est pas vraiment ça quoi. Surtout que test03 n'est mis nulle part mais il apparait bel et bien à l'affichage (probablement parce qu'il a été déclaré juste après test02 et donc que l'adresse mémoire correspond mais c'est pur hasard !!!)

il fonctionne très bien

Attention à ne pas confondre "le résultat que j'ai à l'écran correspond à ce que j'espère mais c'est peut-être un pur hasard" et "le programme fonctionne très bien" parce que ce que le programme t'affiche ce n'est pas une preuve...

mais si on dé-commente la boucle for comme ici

Et voilà. Il fonctionne "très bien" mais si on enlève un commentaire il part en torche. C'est pas vraiment ce que j'appelle "très bien"...

Voici un code correspondant à peu-près à ce que j'imagine que tu veux faire. Examine-le et si c'est ça et que tu le continues correctement, il fonctionnera alors vraiment comme il faut.

Code c :

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int main()
{
	int i = 0;
	char **tab;
	char *pt;
	int taille = 4;
	char test01[]="lool01";
	char test02[]="lool02";
	char test03[]="lool03";
	char test04[]="lool04";
 
	tab = malloc(taille * sizeof(char *));
	for (i=0;i<taille;i++)
	{
		switch (i)
		{
			case 0:
				pt=test01;
				break;
			case 1:
				pt=test02;
				break;
			case 2:
				pt=test03;
				break;
			case 3:
				pt=test04;
				break;
			default:
				pt=NULL;
				break;
		}
		*(tab+i)=pt;
	}
 
	tab = realloc(tab, (taille + 20) * sizeof(char *));
	for(i=4;i<taille + 20;i++)
		*(tab + i)=NULL;
 
	for(i=0;i<taille + 20;i++)
	{
		if (*(tab + i))
		 	printf("%d - %s\n",i,*(tab+i));
		else
		 	printf("%d - 0x0000\n",i);
	}
	free(tab);
}

[jose.hello]

Merci!

Dans le projet plus conséquent, on ne sait pas combien de case le tableau aura à la fin. J'aimerai donc faire un tableau dynamique comme je sais pas la taille j'avais mis le réalloc un while. Et j'avais incrémenté la taille.

La version que tu me proposes contient un realloc mais pas dans un for ni dans un while... (en finalité c'est un peu comme le premier code ou l'alloue juste une case supplémentaire)

Merci pour les explications sur les chaînes.

[jose.hello]

J'ai essayé le comportement que j'aimerai reproduire mais il fait une erreur de seg

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int main()
{
	int i = 0;
	char **tab;
	char *pt;
	int taille = 4;
	int stop = 20 ;
	char test01[]="lool01";
	char test02[]="lool02";
	char test03[]="lool03";
	char test04[]="lool04";
 
	tab = malloc(taille * sizeof(char *));
	for (i=0;i<taille;i++)
	{
		switch (i)
		{
			case 0:
				pt=test01;
				break;
			case 1:
				pt=test02;
				break;
			case 2:
				pt=test03;
				break;
			case 3:
				pt=test04;
				break;
			default:
				pt=NULL;
				break;
		}
		*(tab+i)=pt;
	}
 
	while (taille != stop)
	{
		taille++;
		tab = realloc(tab, (taille) * sizeof(char *));
		if ( (taille % 2) == 0 )
    		*(tab + i)=test02;
		else
    		*(tab + i)=test01;
	}
 
	//tab = realloc(tab, (taille + 20) * sizeof(char *));
 
 
 
	//for(i=4;i<taille + 20;i++)
	//{	*(tab + i)=NULL;
	//	*(tab + i)=test01;
	//}
 
	for(i=0;i<taille;i++)
	{
 
		if (*(tab + i))
		 	printf("%d - %s\n",i,*(tab+i));
		else
		 	printf("%d - 0x0000\n",i);
	}
	free(tab);
}

voila la sortie
0 - lool01
1 - lool02
2 - lool03
3 - lool04
4 - lool02
Erreur de segmentation

Après plusieurs tests, il y a que 5 cases dans le tableau. Comment faire pour en ajouter??

[diogene]

Code :

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

1
2
3
4
		if ( (taille % 2) == 0 )
    		*(tab + taille-1)=test02;
		else
    		*(tab + taille-1)=test01;

ou si on préfère l'équivalent

Code :

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

1
2
		if (taille % 2 == 0)tab [taille-1]=test02;
		else tab[taille-1]=test01;

[jose.hello]

Oui merci, j'avais aussi constater que ça fonctionnait aussi de cette manière.

Mais quoi qu'il en soit, pour ajouter des éléments dynamiquement ça ne marche toujours pas.