Envoyé par
m0ul3sh0t
char *tab = malloc (x * sizeof *tab);
pour le cas d'un char * on m'avait expliqué qu'il fallait d'abord déclarer la variable (char *tab) et après faire l'allocation (tab = malloc(x * sizeof *tab))
Il est techniquement possible de séparer les instructions, mais je trouve plus clair (et plus sûr) de les regrouper quand c'est possible.
Si j'ai bien comprit on alloue à tab x fois la taille du type char
On alloue rien du tout à tab...
malloc() demande au système d'allouer un bloc d'une certaine taille, si l'allocation est possible, l'adresse du début du bloc est retournée.
Pour des raisons évidentes d'utilisation par la suite, cette adresse est stockée. Evidemment, on utilise un pointeur (un pointeur, c'est fait pour stocker une adresse) et on le définit du même type, ce qui permet son usage.
Donc, si je veux créer une variable de type T :
1 - je définis un pointeur de type T :
T *p
2 - je demande l'allocation d'un bloc de type T
malloc(sizeof (T))
ou
malloc(sizeof *p)
3 - je stocke l'adresse :
p = malloc(...)
Ce que je fais en une opération :
T *p = malloc(sizeof *p);
évidemment, malloc() pouvant échouer, on ne fera rien sans avoir testé la valeur de l'adresse retournée :
1
2
3
4
5
|
T *p = malloc(sizeof *p);
if (p != NULL)
{
/* utilisation */ |
et bien sûr, quand c'est terminé, je libère le bloc alloué :
free (p);
et je force le pointeur à NULL pour bien signifier qu'il est invalide
p = NULL;
ce que je recommande de faire comme ceci :
1
2
3
4
5
6
7
8
9
10
|
T *p = malloc(sizeof *p);
if (p != NULL)
{
/* utilisation */
/* fin */
free (p), p = NULL;
} |
Pour créer un tableau, on multiplie la taille demandée par le nombre d'éléments :
1
2
3
4
5
6
7
8
9
10
|
T *p = malloc(sizeof *p * n);
if (p != NULL)
{
/* utilisation */
/* fin */
free (p), p = NULL;
} |
Nota : T représente le type de l'utilisateur.
Répondre avec citation
Partager