Discussion :

[elmcherqui]

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 :

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

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 :

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
 
#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 .

[elmcherqui]

sujet resolu , j'ai trouve comment faire

[elmcherqui]

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

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
 
#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 .

[freecircus]

Code :

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

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

Ok.

Code :

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

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 :

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

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

Ok.

[droggo]

Poa,

Code :

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

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à.

[elmcherqui]

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.

[droggo]

Moe,

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.

[Sve@r]

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
#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 :

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
#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

[elmcherqui]

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 :

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
 
#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 .

[freecircus]

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 :-)

[elmcherqui]

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

[jeroman]

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