Discussion :

[contremaitre]

Bonjour
J'avais créé des fonctions d'allocation pour éviter de refaire a chaque fois les test de succés comme ca :

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
 
//Pour un int par exemple
int allocation_int(int ** pt) {
   *pt = malloc(TAILLE*sizeof(int));
    if(!(*pt)){
 	trace("Error : Allocation memoire\n");
	return 0;
    }
    return 1;
}
 
//et je l'apelle comme ca :
int * test, *test2;
if(!allocation_int(&test) || !allocation_int(&test2)){
...
}

Presenté comme ca, pas grand interet mais pour en allouer plein d'un coup c'est plus pratique.

Je voudrais en faire un générique et j'ai fait :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
int allocation_type (void ** pt) {
    *pt = malloc(TAILLE*sizeof(**pt));
    if(!(*pt)){
 	trace("Error : Allocation memoire\n");
	return 0;
    }
    return 1;
}
 
//que j'apelle comme ca :
if(!allocation_type(&test)

Et j'obtient cette erreur :

warning: passing arg 1 of `allocation_type' from incompatible pointer type

Pourquoi?

merci

[Médinoc]

Un void** n'est pas générique, seul un void* l'est.

[contremaitre]

mais si j'utilise pas un void ** mon pointeur ne sera pas modifié, et l'adresse de test ne pointera donc pas vers la bonne adresse mémoire non?
en tout cas c'est ce qu'il se passait quand je faisait allocation_int(int * pt) : pt était passé par copie et pas modifié.

[souviron34]

mais si j'utilise pas un void ** mon pointeur ne sera pas modifié, et l'adresse de test ne pointera donc pas vers la bonne adresse mémoire non?.

bien sur que si..

void * indique un pointeur void.. Riuen n'empeche que ce pointeur soit lui meme un pointeur..

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
void Fonction ( void *toto )
{
  int **titi = (int **)toto ;
  int     i ;
 
  *titi = malloc ( 8*sizeof(int) );
    if ( *titi != NULL )
      {
         for ( i = 0 ; i < 8 ; i++ )
            (*titi)[i] = i ;
      }
}
 
int main ( void )
{
   int *tab=NULL, i ;
 
   Fonction((void *)&tab);
 
   if ( tab != NULL )
     for ( i = 0 ; i < 8 ; i++ )
       fprintf ( stderr, "\nValeur du tableau a la case %d : %d",i,tab[i]);
 
  return EXIT_SUCCESS ;
}

[DaZumba]

La conversion implicite, c'est entre void * et les pointeurs des autres types. void ** n'est pas un "double pointeur generique". Le plus simple, c'est de renvoyer un void * ou NULL si l'allocation a echoue... mais c'est exactement ce que malloc() fait de toute facon ! Ton wrapper n'est pas utile.

[contremaitre]

La conversion implicite, c'est entre void * et les pointeurs des autres types. void ** n'est pas un "double pointeur generique". Le plus simple, c'est de renvoyer un void * ou NULL si l'allocation a echoue... mais c'est exactement ce que malloc() fait de toute facon ! Ton wrapper n'est pas utile.

Ma fonction permet de faire des tests enchainés sans tester NULL a chaque fois. Et j'ai pas tout mis, car elle initialise à 0 (memset) la mémoire.

[Médinoc]

Tu peux toujours faire une macro qui vérifie que la variable est un pointeur, puis caste...

D'autant que ta fonction ne devrait pas compiler, sizeof(void) est bizarre...

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
int allocation_type (void ** pp, size_t nElts, size_t s) {
    *pt = malloc(nElts*s);
    if((*pt)==NULL){
 	trace("Error : Allocation memoire\n");
	return 0;
    }
    return 1;
}
#define ALLOC(p,n) allocation_type((void**)&(p), (n), sizeof(*(p)))
 
//et appeler comme ca :
int * test, *test2;
if(!ALLOC(test, TAILLE) || !ALLOC(test2, TAILLE)){
...
}

[contremaitre]

D'autant que ta fonction ne devrait pas compiler, sizeof(void) est bizarre...

c'est sizeof du type pointé par void...

[DaZumba]

Il est vraiment difficile de faire un wrapper generique de malloc() qui ait quelque utilite, tout simplement parce qu'il faut de toute facon verifier la valeur de retour du wrapper... Il y a bien la solution type xmalloc() qui exit() si l'allocation a echoue, mais dans la plupart des situations reelles, c'est d'un usage assez douteux. Restent les wrappers dedies a des situations bien determinees pour une application donnee (genre memory manager, memory pools, ou un truc super specifique genre "allouer deux tableaux d'entiers et un tableau de doubles"). Mais un wrapper generique, franchement, je ne suis pas convaincu...

[Emmanuel Delahaye]

Je voudrais en faire un générique et j'ai fait :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
int allocation_type (void ** pt) {
    *pt = malloc(TAILLE*sizeof(**pt));
    if(!(*pt)){
 	trace("Error : Allocation memoire\n");
	return 0;
    }
    return 1;
}
 
//que j'apelle comme ca :
if(!allocation_type(&test)

Et j'obtient cette erreur :
<...>
Pourquoi?

Parce que le type n'est pas bon. Le seul type de pointeur de données générique en C est void *. Le problème, c'est qu'il n'y a pas de vérification.

Tu peux donc faire :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
int allocation_type (void *pt, size_t size) {
void **ppt = pt;
    *ppt = malloc(size);
    if(*ppt==NULL){
 	trace("Error : Allocation memoire\n");
	return 0;
    }
    return 1;
}

mais ça n'a pas un grand intérêt... Ca, peut être...

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define trace(s) printf ("Error : %s at %s:%d\n", s, __FILE__, __LINE__)
 
int allocation_type (void *pt, size_t size)
{
   int ok = 0;
   if (pt != NULL)
   {
      void **ppt = pt;
      if (*ppt == NULL)
      {
         *ppt = malloc (size);
         if (*ppt == NULL)
         {
            trace ("Allocation memoire");
         }
         else
         {
            ok = 1;
         }
      }
      else
      {
         trace ("Deja alloue");
      }
   }
   else
   {
      trace ("Pointeur NULL");
   }
   return ok;
}
 
int main (void)
{
   char *p = NULL;
   int ok;
 
   ok = allocation_type (NULL, 10);
 
   if (ok)
   {
      strcpy (p, "hello");
      printf ("'%s'\n", p);
   }
   ok = allocation_type (&p, 10);
 
   if (ok)
   {
      strcpy (p, "hello");
      printf ("'%s'\n", p);
   }
   ok = allocation_type (&p, 10);
 
   if (ok)
   {
      strcpy (p, "hello");
      printf ("'%s'\n", p);
   }
   return 0;
}

[contremaitre]

Tu peux donc faire :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
int allocation_type (void *pt, size_t size) {
void **ppt = pt;
    *ppt = malloc(size);
    if(*ppt==NULL){
 	trace("Error : Allocation memoire\n");
	return 0;
    }
    return 1;
}

Merci ca semble marcher.
J'ai juste un doute sur le sizeof. Je voudrais pouvoir faire un malloc en fonction de la taille du type sans passer par la taille en parametre.
J'ai essayé sizeof(*ppt) ou sizeof(pt) et ca me donne bien la taille du type, est ce correct?

[Jean-Marc.Bourguet]

Tu peux donc faire :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
int allocation_type (void *pt, size_t size) {
void **ppt = pt;
    *ppt = malloc(size);
    if(*ppt==NULL){
 	trace("Error : Allocation memoire\n");
	return 0;
    }
    return 1;
}

Comportement indefini si on passe a pt autre chose que l'adresse d'un void*. (Penser par exemple qu'on peut avoir sizeof(int*) < sizeof(void*), on se met a ecrire ou on ne peut pas si on passe &mon_int_ptr a allocation_type())

[Emmanuel Delahaye]

Comportement indefini si on passe a pt autre chose que l'adresse d'un void*. (Penser par exemple qu'on peut avoir sizeof(int*) < sizeof(void*), on se met a ecrire ou on ne peut pas si on passe &mon_int_ptr a allocation_type())

Moui, ça remet en cause beaucoup de code générique et de callbacks avec des contextes génériques...

[Jean-Marc.Bourguet]

Moui, ça remet en cause beaucoup de code générique et de callbacks avec des contextes génériques...

Si c'est bien le genre de contextes auxquels je pense, on converti generalement un void* en un pointeur vers une structure, ce qui est valide.

La regle est qu'on ne peut convertir un void* qu'en un pointeur du meme type (aux qualifications cv pres) que celui qui a servi a creer le void*. Exactement comme les unions. Exactement la raison pour laquelle j'aime pas la regle du C qui permet de convertir implicitement un void* en n'importe quel pointeur, devoir mettre un cast incite a reflechir au fait qu'un probleme peut arriver.

On peut considerer que les machines pour lesquelles ca ne marche pas ne sont pas importantes, ce qui n'est pas tout a fait faux. Mais je n'ai aucune idee du bordel qu'un optimiseur peut venir mettre si on ne respecte pas la regle, depuis que j'en ai vu un avoir des effets non causals, je me mefie.