deux façons de créer un tableau de pointeurs

bonjours ,
j'aimerais creer un tableau de pointeur de deux facon differentes .
pour la premiere facon on cree un tableau statique .
(corrigez moi les commentaires si j'ai faux s'il vous plait ).
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 #include <stdio.h> #include <stdlib.h> int main(void) { int *p[100],i=0; for(i=0;i<100;i++){ p[i] = malloc(5*sizeof(int));// p[i] est de type (int*) ? } // p est maintenant de type (*p)[5] ) ? p[90][4]=3; //juste ? p[85][25]=6;//faux ? return 0; }
mais qu'en ai t'il si je ne sais pas combien de pointeur je veux creer ?

ce qui nous amene a la deuxieme methode je ne sais pas si on peut le faire , j'ai teste et sa marche pas .
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 #include <stdio.h> #include <stdlib.h> int main(void) { //je veux creer un tableau de 100 pointeurs sur int //et chaque tableau pointe sur 5 elements int **p = NULL,i=0,*temp; p= malloc(100 *sizeof(int)); temp = *p; for(i=0;i<5;i++){ temp = malloc(5*sizeof(int)); temp++; } //p[50][3]=5; //p[3][50]=4; // les deux compilent mais segfaultent je ne sais pas pourquoi ? return 0; }
voila j'espere avoir ete clair , merci de m'aider .

sujet resolu , j'ai trouve comment faire :)

voila la solution au cas ou des gens se poseraient la question
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 #include <stdio.h> #include <stdlib.h> int main(void) { int **p = NULL,i=0; p = malloc(100 *sizeof(int)); for(i=0;i<100;i++) p[i] = malloc(5*sizeof(int)); printf("%d",p[50][3]=5);//VRAI !!!!! return 0; }
par contre j'aimerais savoir si ce que j'ai ecrit en commentaire dans le premier code est juste , merci .

Code:

1 2 3 4 5 int *p[100],i=0; /*...*/ p[i] = malloc(5*sizeof(int));// p[i] est de type (int*) ?
Ok.
Code:

1 2 3 4 5 int *p[100],i=0; /*...*/ // p est maintenant de type (*p)[5] ) ?
Non. Avec les parenthèses tu modifies la priorité des opérateurs, du coup on n'a plus la même chose :
(*p)[5] est un pointeur sur tableau.
*p[5] est un tableau de pointeur (ce qui correspond en l'occurence à la déclaration de p).
Code:

1 2 p[90][4]=3; //juste ? p[85][25]=6;//faux ?
Ok.

Poa,
Citation:
Envoyé par elmcherqui
Code:

1 2 3 4 5 6 7 ... int **p = NULL,i=0; /* la ligne ci-dessous est fausse */ p = malloc(100 *sizeof(int)); ...
Pourquoi fausse ?

Car rien ne garantit que sizeof(int) = sizeof(*int).

Ça a marché car pour ton compilateur et la configuration pour laquelle tu compiles, ces valeurs sont égales.
Mais il ne faut pas partir du principe que c'est obligatoirement le cas, loin de là. :)

Citation:

Envoyé par droggo

Poa,

Pourquoi fausse ?

Car rien ne garantit que sizeof(int) = sizeof(*int).

Ça a marché car pour ton compilateur et la configuration pour laquelle tu compiles, ces valeurs sont égales.
Mais il ne faut pas partir du principe que c'est obligatoirement le cas, loin de là. :)

sur mon bouquin c'est la methode qu'ils utilisent pour allouer de la memoire .
si tu a la bonne methode portable je suis preneur.

Moe,

Citation:

Envoyé par elmcherqui

sur mon bouquin c'est la methode qu'ils utilisent pour allouer de la memoire .
si tu a la bonne methode portable je suis preneur.

Je pensais que ça ressortait clairement de mon message.

Il suffit de réserver en fonction de la taille d'un pointeur vers int, donc sizeof (*int), et pas pour la taille d'un int.

Ce n'est pas la même chose, et si ton bouquin assimile ces 2 valeurs, jette-le. :)

Encore mieux

Code:

1
2
3
p = malloc( 100 * sizeof *p );
 
p[i] = malloc( 5 * sizeof *p[i]);

Citation:

Envoyé par elmcherqui

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
#include <stdlib.h>

int main(void)
{   int *p[100],i=0; 
	for(i=0;i<100;i++){
		p[i] = malloc(5*sizeof(int));// p[i] est de type (int*) ?
    }
    // p est maintenant de type (*p)[5] ) ?
	p[90][4]=3; //juste ?
	p[85][25]=6;//faux ?
    // Attention, chaque p[i] ne peut recevoir que 5 int => ton 25 dépasse !!!

	for(i=0;i<100;i++)
		free(p[i]);
    return 0;
}

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
#include <stdio.h>
#include <stdlib.h>


int main(void)
{   //je veux creer un tableau de 100 pointeurs sur int
    //et chaque tableau pointe sur 5 elements
    int **p = NULL,i=0,*temp;
    p= malloc(100 *sizeof(int*));
    // tu veux allouer dans p l'espace de 100 pointeurs et non 100 int !!!
    temp = *p;
    for(i=0;i<5;i++){
        temp = malloc(5*sizeof(int));
        temp++;
    }
    // Houla pas bon. Tu écris temp=x puis temp=y puis temp=temp+1. Tu es certain de ton résultat ???
    for(i=0, temp=p;i<5;i++, temp++){
        *temp = malloc(5*sizeof(int));
    }
    // Et bien sûr remplacer ce "int *temp" déclaré tout en haut par "int **temp" !!!

    
    //p[50][3]=5;
    //p[3][50]=4;    => idem remarque précédente

	for(i=0;i<100;i++)
		free(p[i]);
	free(p);

    return 0;
}

Voir ce que j'ai mis en rouge

merci les gars je comprend un peu plus maintenant les pointeurs .
donc en conclusion le bon code pour allouer de la memoire dynamiquement est celui la :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 #include <stdio.h> #include <stdlib.h> int main() { int **p,i=0; p = malloc(100*sizeof(int*)); for(i=0;i<100;i++) p[i]= malloc(5*sizeof(int)); p[50][3]=5; // juste for(i=0;i<100;i++) free(p[i]); return 0; }
Cependant il reste une question .
qu'elle est le type du pointeur p apres les allocations ?
Merci .

Citation:

qu'elle est le type du pointeur p apres les allocations ?

Toujours le même, le typage est static. p est et sera toujours un int**

edit : tu as oublié de libérer p :-)

ok merci pour la reponse , sujet resolu (enfin ! )

Il faut aussi s'assurer que l'allocation a réussi, en effectuant un test (if).

c'est pas avec mes quelque Ko que l'OS va me refuser . mais merci du conseil c'est une habitude a avoir en programmation .

En fait, en bossant bien, tu peux faire juste une allocation par dimension:
http://www.developpez.net/forums/m1803870-7/

Citation:

Envoyé par Médinoc

En fait, en bossant bien, tu peux faire juste une allocation par dimension:
http://www.developpez.net/forums/m1803870-7/

Dans l'exemple du lien tu dis :

Citation:

Envoyé par Médinoc

L'inconvénient, c'est que si le produit des tailles déborde, je ne sais pas comment le détecter.

Et je me rappelle avoir lu un code venant de toi d'ailleurs, où la vérification était faites ainsi :
Code:

1 2 3 4 5 6 7 8 9 size_t const taille1x2 = taille1*taille2; if( taille1x2/taille1 != taille2 ) return NULL; else { /* ...suite du code ... */ }
:P

Merci de m'y faire penser. Je mettrai à jour quand j'en aurai le temps...

Citation:

Envoyé par elmcherqui

...mais merci du conseil c'est une habitude a avoir en programmation .

... et surtout, en cas de pb intermédiaire, trouver le moyen de libérer ce qui a été alloué

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
#include <stdio.h>
#include <stdlib.h>
 
void freeP(int **p, int n)
{
    int i;
 
    for (i=0; i < n; i++)
        free(p[i]);
    free(p);
}
 
int main()
{
    int **p,i=0;
 
    p = malloc(100*sizeof(int*));
    if (p == NULL)
    {
          ... Gérer le pb mémoire...
          exit(-1);
    }
 
    for(i=0;i<100;i++)
    {
        p[i]= malloc(5*sizeof(int));
        if (p[i] == NULL)
        {
             freeP(p, i);
             exit(2);
        }
    }
 
    p[50][3]=5; // juste 
 
    freeP(p, 100);
 
    return 0;
}

Citation:

Envoyé par elmcherqui

c'est pas avec mes quelque Ko que l'OS va me refuser

Mauvais réflexe. Tu ne peux absolument pas préjuger du comportement de l'OS. Tu ne sais pas ce qui tourne ailleurs... Un malloc() peut toujours échouer. Il faut donc toujours tester le retour de malloc() avant usage.