tableau 2 dimensions qui stockent des tableau[2]

Version imprimable

Bonjour,

Je n'arrive pas à stocker des tableaux de 2 cases dans un tableau 2 dimensions pourtant j'ai vérifié la taille des éléments en mémoire et elles sont correctes.

voici mon code :
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 <stdio.h> # include <stdlib.h> void init(int size1, int size2) { int*** tab; int* tab2 = (int*)malloc(2*sizeof(int)); int i, j; printf("case : taille %ld ", sizeof(tab[0][0])); printf("tab : taille %ld \n", sizeof(tab2)); printf("\n"); for (i=0;i<size1;i++) { printf("indice_i %d\t", i); for (j=0;j<size2;j++) { printf("indice_j %d ", j); /*core dumped*/ tab[i][j] = tab2; // core dumped tab[i][j] = (int*)malloc(2*sizeof(int)); } printf("\n"); } printf("\n"); } int main() { init(2, 2); exit(0); }
j'obtiens à chaque fois une erreur 'core dumped', pourriez me dire ce qui cloche svp ?

14/12/2017, 15h49
Médinoc

À aucun moment tu n'as alloué tab.

effectivement mais j'ai toujours la même erreur après allocation :cry:

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 <stdio.h>
# include <stdlib.h>
 
void init(int size1, int size2) {
	int*** tab = (int***)malloc(size1*size2*sizeof(int));
	int* tab2 = (int*)malloc(2*sizeof(int));
	int i, j;
	printf("case : taille %ld ", sizeof(tab[0][0]));
	printf("tab : taille %ld \n", sizeof(tab2));
	printf("\n");
	for (i=0;i<size1;i++) {
		printf("indice_i %d\t", i);
		for (j=0;j<size2;j++) {
			printf("indice_j %d ", j);
			/*core dumped*/ tab[i][j] = tab2;
			// core dumped tab[i][j] = (int*)malloc(2*sizeof(int));	
		}
		printf("\n");
	}
	printf("\n");
}
 
int main() {
	init(2, 2);
	exit(0);
}

14/12/2017, 16h16
ternel

Tu n'as pas non plus alloué les tableaux intermédiaires.
Et tu dois tout supprimer proprement.

Ton erreur n'est pas "core dump" (ca, c'est la conséquence), mais "segmentation fault" ou "SEGFAULT".

J'ai l'impression que tu n'as pas compris la différence entre un pointeur et les allocations dynamiques.
Que signifient pour toi ces deux expressions?

je ne comprend pas ce que je veux dire allouer les tableaux intermédiaires ... parceque les tab[2] que je stocke je les avais alloué pourtant

Oui je n'ai pas libérer la mémoire mais çà ne change rien à mon problème :(
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 # include <stdio.h> # include <stdlib.h> void init(int*** tab, int size1, int size2) { int i, j; printf("\n"); for (i=0;i<size1;i++) { printf("indice_i %d\t", i); for (j=0;j<size2;j++) { printf("indice_j %d ", j); //core dumped tab[i][j] = (int*)malloc(2*sizeof(int)); } printf("\n"); } printf("\n"); } int main() { int size1 = 2; int size2 = 2; int*** tab = (int***)malloc(2*2*sizeof(int)); init(tab, size1, size2); int i, j; /* core dumped for (i=0;i<size1;i++) { for (j=0;j<size2;j++) { free(tab[i][j]); } }*/ free(tab); exit(0); }
Citation:

Ton erreur n'est pas "core dump" (ca, c'est la conséquence), mais "segmentation fault" ou "SEGFAULT"

oui tu as raison j'ai omis

Citation:

Que signifient pour toi ces deux expressions

pointeur: c'est une adresse qui pointe sur l'emplacement mémoire d'une variable
allocations dynamiques : c'est le fait de réserver de la mémoire selon ses besoins avec malloc()

est ce bien çà ?

14/12/2017, 16h36
Médinoc

J'ai retrouvé ce vieil exemple de code pour une allocation de tableau 3D:
~~https://www.developpez.net/forums/d5...t/#post3319896~~
https://www.developpez.net/forums/d5...t/#post3323244

Par contre, les trois dimensions s'en retrouvent fixes, vu qu'il s'agit d'un tableau 3D et non pas d'un tableau 2D de tableaux.
14/12/2017, 16h56
ternel

Tu n'es pas très loin.
Un pointeur d'un type donné est une variable contenant une adresse mémoire, supposée désigner un objet du type du pointeur.

L'allocation dynamique est le mécanisme par lequel le système alloue une partie de la mémoire (du tas heap) au programme, à sa demande.

malloc est une fonction qui demande au système d'allouer au programme un bloc mémoire d'une taille donnée.
Elle retourne l'adresse du bloc alloué (ou NULL en cas d'erreur, ce qui est à surveiller).
Elle n'initialise pas ce bloc mémoire.

Dans ton cas, (int***)malloc(size1*size2*sizeof(int)); tu demandes l'allocation d'un bloc de la taille correspondant à size1 * size2 entiers.
Cela devrait pouvoir s'utiliser comme un int[size1*size2], et pas autrement.
Ce n'est pas un int***.

Dans ta boucle, tu écris tab[i][j] = bidule. tab[i] n'a pas été initialisé. Il n'est pas utilisable comme pointeur (donc par [])

Plus amusant, chaque tab[i][j] est affecté avec le meme pointeur, donc désigne le meme morceau de mémoire.

merci de vos réponses même si je ~~commence~~ continue à être perdu perdu :calim2:

@Medinoc
j'ai essayé de comprendre l'exemple(j'avais remarqué celui corrigé) mais je n'ai pas réussi à coder la AllocateTable2D() pourtant j'ai essayé :
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 52 53 54 55 # include <stdio.h> # include <stdlib.h> typedef char ElemType; ElemType *** AllocTable2D(size_t sizeX, size_t sizeY) { size_t const sizeXY = sizeX * sizeY; ElemType *** pppMatX = NULL; ElemType ** ppMatXY = NULL; /* On vérifie qu'il n'y a pas d'overflow */ if(sizeXY / sizeX != sizeY) return NULL; /* Une allocation par dimension */ pppMatX = calloc(sizeof *pppMatX, sizeX); /* Tableau de pointeurs de pointeurs */ ppMatXY = calloc(sizeof *ppMatXY, sizeXY); /* Tableau 2D de pointeurs */ if(pppMatX != NULL && ppMatXY != NULL) { /* On affecte les pointeurs */ size_t x; for(x=0 ; x<sizeX ; x++) { size_t y; pppMatX[x] = &ppMatXY[x*sizeY]; /*for(y=0 ; y<sizeY ; y++) { ppMatXY[x*sizeY + y] = &ppMatXY[(x*sizeY+y)]; }*/ } } else { /* Au moins une alloc a échoué: On libère celles qui ont réussi */ free(pppMatX), pppMatX=NULL; free(ppMatXY), ppMatXY=NULL; } return pppMatX; } int main() { AllocTable3D(4, 4, 4); ElemType*** monTab = AllocTable2D(4, 4); int* tab = (int*)malloc(2*sizeof(int)); int i, j; for (i=0;i<4;i++) { for (j=0;j<4;j++) { printf("%d", ElemType[i][j]); } } exit(0); }
Mais j'ai noté plusieurs choses :
-la fonction AllocateTable3D() crée un tableau3D qui renvoie un var*** et moi je suis en 2D et j'utilise un var*** aussi ... je dois avoir une erreur à ce niveau
-les allocations se font dimensions par dimensions ... ceux que j'ai vraiment du mal à comprendre :weird:
-et quand on arrive là /* On affecte les pointeurs */ je ne peux plus comprendre et je pense à mon javascript :no:
-le pikachu et le zeldat était déjà là en 2008 :ptdr:

il faudrait vraiment que je m'y replonge dans ce code .

@ternel

Citation:

Cela devrait pouvoir s'utiliser comme un int[size1*size2], et pas autrement.

pourrais tu m'expliquer comment stp parceque je ne comprend pas du tout.
ma faible intelligence me fait comprendre que pour avoir tab[0][1] on fait tab[0*1] mais bon non.

Citation:

tab[i] n'a pas été initialisé. Il n'est pas utilisable comme pointeur (donc par [])

je suis désolé je ne comprend toujours pas pk ... pourtant j'ai fait mon malloc()

Citation:

chaque tab[i][j] est affecté avec le meme pointeur

Je crois m'être rendu compte de çà et donc j'avais changé :

Code:

tab[i][j] = tab2

par

Code:

tab[i][j] = (int*)malloc(2sizeof(int))

Citation:

Ce n'est pas un int***

merci je viens de comprendre, donc cela me retourne l'adresse du tableau donc un simple int* si je comprend bien

J'ai modifié mon code en conséquence mais bon j'ai une nouvelle erreur subscripted value is neither array or pointer nor vector
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 # include <stdio.h> # include <stdlib.h> void init(int* tab, int size1, int size2) { int i, j; printf("\n"); for (i=0;i<size1;i++) { printf("indice_i %d\t", i); for (j=0;j<size2;j++) { printf("indice_j %d ", j); tab[i][j] = (int*)malloc(2*sizeof(int)); } printf("\n"); } printf("\n"); } int main() { int size1 = 2; int size2 = 2; //int* tab = (int*)malloc(2*2*sizeof(int)); int tab[sizeof(size1)*sizeof(size2)]; init(tab, size1, size2); int i, j; /* core dumped for (i=0;i<size1;i++) { for (j=0;j<size2;j++) { free(tab[i][j]); } }*/ //free(tab); exit(0); }
@All

:(

je pense avoir trouvée mais n'en suis pas vraiment sur ...

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
# include <stdio.h>
# include <stdlib.h>
 
int** init(int** tab, int size1, int size2) {
 
    int val=99;
    int i;
    int j;
    tab = (int ** ) malloc (size1 * sizeof (int));
    for (i=0;i<size1;i++)
    {
    tab[i]=(int *)malloc(size2 * sizeof(int));
    }
    for (i = 0; i < size1; i = i + 1)
    {
        for (j = 0; j < size2; j = j + 1)
        {
            tab[i][j] = val;
            val--;
        }
    }
    return tab;
}
 
void display(int* tab) {
    int i;
    for(i=0;i<2;i++) {
        printf("val %d\n", tab[i]);
    }
    printf("\n");
}
 
int main() {
    int ** tab;
    int i, j;
    int size1=2;
    int size2=2;
    tab = init(tab, size1, size2);
 
    for (i=0;i<size1;i++) {
        display(tab[i]);
        //printf("size %ld\n", sizeof(tab[i]));
        for (j=0;j<size2;j++) {
            //printf("%d\n", tab[i][j]); 
 
        }
    }
 
    free (tab);
}

çà compile et fonctionne mais je n'arrive pas à savoir si j'ai vraiment ce que je voulais ... c'est à dire un tableau de tableau[2].

Quelqu'un pourrait il me le confirmer svp ?

Bonjour,

C'est beaucoup mieux, mais il y a une 'petite' erreur, il manque une étoile

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int** init(int size1, int size2) {
    int   val = 99;
    int**  tab = malloc( size1 * sizeof (int*) ); // on alloue 'size1' pointeurs
    for ( int i = 0 ; i < size1 ; ++i ) {
        tab[i] = malloc( size2 * sizeof(int) );
    }
    for ( int i = 0 ; i < size1 ; ++i ) {
        for ( int j = 0 ; j < size2 ; ++j ) {
            tab[i][j] = val;
            val--;
        }
    }
    return tab;
}

Et vérifie ta libération, il doit aussi y avoir autant de free() qu'il y a eu de malloc().

Attention, si la seconde dimension a une taille fixe, on peut faire plus simple

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#define SIZE2 2
typedef   int  ArrSize2[SIZE2];
 
ArrSize2* init(int size1) {
    int   val = 99;
    ArrSize2  *tab = malloc( size1 * sizeof (ArraySize2) ); // on alloue 'size1' tableaux de SIZE2 int
    for ( int i = 0 ; i < size1 ; ++i ) {
        for ( int j = 0 ; j < SIZE2 ; ++j ) {
            tab[i][j] = val;
            val--;
        }
    }
    return tab;
}

15/12/2017, 12h13
regma

merciii :D