Discussion :

[hbx360]

Bonjours, je souhaite créer une fonction qui permettra de créer un tableau à 2 dimension en ayant un type void en paramètre et qui retournera un pointeur void.

Le problème c'est que j'ai un message d'erreur : "imcompatible pointeur type, assignement from incompatible pointeur type".
Je n'arrive pas a trouver la solution pour que mon code marche. Pour un tableau a une dimension sa marche mais pour 2 impossibles.

voici mon code :

Dans le main :

Code :

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

1
2
3
4
 
    char **tab=NULL;
 
    tab=alloc_2d(tab,10,10);

Dans mon .h

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
 
void **alloc_2d(void **_ptr,int size1,int size2)
{
  int i;
  void **ptr=(void**)_ptr;/*cette ligne est pour que le compilo accepte le void pour 1 tableau a
                                 une dimenssion sa marche en enlevant 1 étoile (void *ptr=(void*)_ptr;)*/
 
assert(size1>0);
assert(size2>0);
 
  ptr=malloc(size1*sizeof(ptr));
  if(malloc_error(ptr)==NULL)  /*malloc_error est une fonction qui envoi un message d'erreur et qui retourne le pointeur envoyer*/
    {
      free_alloc(ptr); 
      return ptr;
    }
 
  for(i=0;i<size1;i++)
    {
      ptr[i]=malloc(size2*sizeof(ptr[i]));
      if(malloc_error(ptr[i])==NULL)
	{
	  for(i=i-1;i>=0;i--)
	    free_alloc(ptr[i]);
	  free_alloc(ptr);
	  return ptr;
	}
    }
  return ptr;
}

[CodeurPlusPlus]

Bonjours, je souhaite créer une fonction qui permettra de créer un tableau à 2 dimension en ayant un type void en paramètre et qui retournera un pointeur void.

Bonjour. Je ne suis pas sûr de comprendre. Souhaitez-vous créer un tableau (à deux dimensions) de void* ?

Le problème c'est que j'ai un message d'erreur : "imcompatible pointeur type, assignement from incompatible pointeur type".

A quelle ligne ?

Dans mon .h

Code :

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

1
2
3
4
5
 
void **alloc_2d(void **_ptr,int size1,int size2)
{
  int i;
  void **ptr=(void**)_ptr;

pourquoi caster un void** en void** ?

ptr=malloc(size1*sizeof(ptr));

euh... ptr est d'abord un cast de _ptr, et ensuite ptr est immédiatement alloué... à quoi sert donc le paramètre _ptr ?

Code :

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

1
2
3
4
5
  if(malloc_error(ptr)==NULL)  /*malloc_error est une fonction qui envoi un message d'erreur et qui retourne le pointeur envoyer*/
    {
      free_alloc(ptr); 
      return ptr;
    }

Je ne connais pas ces fonctions malloc_error et free_alloc, mais j'espère que ptr n'est pas alloué deux fois à la suite vu ce qui précède.

Code :

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

1
2
3
4
 
char **tab=NULL;
 
tab=alloc_2d(tab,10,10);

lors du retour de l'appel à alloc_2d il y aurait donc un cast implicite de void** vers char**... je ne suis pas sûr que le compilateur doivent laisser passer cela :-)

Par ailleurs, si vous faites un tableau 2D de void*, alors :

- void* est le type d'un des éléments stockés dans le tableau ;
- void** est le type d'une des "lignes" du tableau ;
- void*** est le type du tableau, qui est alors bien un tableau de 2D de void*.

Le problème de typage que vous rencontrez viendrait alors de cela.

[dalfab]

Bonjour,

• il s'agit plutôt d'un tableau de tableaux que d'un tableau à deux dimensions.
• ligne 26 du .h, faire plutôt return NULL;
• le code d'une fonction dans un fichier .h !!! Plutôt utiliser char** alloc2D(int,int); et mettre le code dans un fichier .c
• à quoi sert le _ptr passé en paramètre? La fonction alloue le bon pointeur, on devrait appeler char** tab = alloc2D(10,10);
• Pour allouer un tableau la taille de l'élément doit être connue ou passée en paramètre. Dans le corps de la fonction, il faut avoir un char**ptr plutôt qu'un void**ptr, ainsi sizeof(ptr[0]) <=> sizeof(char*) et sizeof(ptr[0][0]) <=> sizeof(char) <=> 1, ou bien veut-on un tableau de tableaux de pointeur?

[hbx360]

Merci pour vos réponses.

A CodeurPlusPlus :

Bonjour. Je ne suis pas sûr de comprendre. Souhaitez-vous créer un tableau (à deux dimensions) de void* ?

En faite je voudrait créer une fonction qui permet de créer un tableau a 2 dimension en passant n'importe quel type, que ce soit un type int, char, double, struct notamment au lieu d'être obliger pour chaque type de faire une fonction.
Ce que je voudrais c'est éviter ceci :

Code :

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

1
2
3
4
char **tab_2d(char** tab, int size1, int size2);
int **tab_2d(int** tab, int size1, int size2);
double **tab_2d(double** tab, int size1, int size2);
float **tab_2d(float** tab, int size1, int size2);

mais plutôt faire une fonction générique qui accepte n'importe quel type et qui retourne un pointeur que je casterait ensuite dans le type que je veux.
Par exemple faire

Code :

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

1
2
3
4
5
6
 
char **tab=NULL;
 tab=(char**)alloc_2d(tab,10,10);
 
/*ma fonction générique qui crée un tableau 2d et qui retourne un void** */
le prototype serai donc void** alloc_2d(void** tab, size1, size2);

Comme ça je n'aurai plus qu'une fonction pour créer n'importe quel type de tableau 2d au lieu d'en avoir une pour chaque type.

pourquoi caster un void** en void** ?

C'était pour éviter que le compilateur me mette un message d'erreur.
J'ai fait une fonction générique qui crée un tableau a une dimension et j'ai fait comme cela pour évité une erreur de ce style incompatible type pointer.

euh... ptr est d'abord un cast de _ptr, et ensuite ptr est immédiatement alloué... à quoi sert donc le paramètre _ptr ?

idem que en haut pour éviter que le compilo rale sa marche pour le tableau à une dimension mais pas pour le 2.

Mon tableau à une dimension celui-ci marche:

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
 
void *alloc(void *_ptr,int size)
{
  void *ptr=(void*)_ptr;
 
  assert(size>0);
 
  ptr=malloc(size*sizeof(ptr));
  if(malloc_error(ptr)==NULL)
    {
      free_alloc(ptr);
      return ptr;
    }
  return ptr;
}

Je ne connais pas ces fonctions malloc_error et free_alloc, mais j'espère que ptr n'est pas alloué deux fois à la suite vu ce qui précède.

Non malloc_error est une fonction que j'ai créé moi; elle met juste un message d'erreur et renvoi le pointeur
Voici le code de malloc_error:

Code :

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

1
2
3
4
5
6
7
8
 
void *malloc_error(void *ptr)
{
  if(ptr==NULL)
    tools_strerror("The allocation failed, the block(s) was released : %s");
 
  return ptr;
}

Pour free_alloc c'est aussi une fonction que j'ai fait moi et qui libère la mémoire.
Voici son code :

Code :

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

1
2
3
4
5
6
7
 
void free_alloc(void *_ptr)
{
  void *ptr = (void*) _ptr;
  free(ptr);
  ptr=NULL;
}

- void* est le type d'un des éléments stockés dans le tableau ;
- void** est le type d'une des "lignes" du tableau ;
- void*** est le type du tableau, qui est alors bien un tableau de 2D de void*.

Merci pour cette info.
Merci pour ton aide.

[hbx360]

A dalfab

[*] le code d'une fonction dans un fichier .h !!! Plutôt utiliser char** alloc2D(int,int); et mettre le code dans un fichier .c

Oui je me suis trompé c'est un .c et non un .h

à quoi sert le _ptr passé en paramètre? La fonction alloue le bon pointeur, on devrait appeler char** tab = alloc2D(10,10);

C'était pour évité que le compilo rale.

Pour allouer un tableau la taille de l'élément doit être connue ou passée en paramètre. Dans le corps de la fonction, il faut avoir un char**ptr plutôt qu'un void**ptr, ainsi sizeof(ptr[0]) <=> sizeof(char*) et sizeof(ptr[0][0]) <=> sizeof(char) <=> 1, ou bien veut-on un tableau de tableaux de pointeur?

J'ai essayé cette méthode mais le problème c'est que si je veux un tableau 2D de int cela ne marche pas.

Merci pour ton aide.

[Matt_Houston]

Il existe ici un malentendu sur le fonctionnement de l'opérateur sizeof.

Le résultat de sizeof(foo) est évalué à la compilation, il ne s'agit pas de RTTI ! Tu écris : ptr=malloc(size*sizeof(ptr));, es-tu bien conscient que c'est équivalent à sizeof(<type de ptr, soit ici void *>) ?

Ce n'est pas un hasard si malloc & co. demandent un paramètre de type size_t : c'est la seule façon de connaître la taille du bloc à allouer. Bases-toi plutôt sur les signatures de fonction de la bibliothèque standard.


Evites aussi de faire taire le compilo avec un cast, gcc est réputé plutôt verbeux mais la plupart du temps il râle tout de même pour de bonnes raisons.

[hbx360]

Merci pour ton aide et tes explications.

Je vois beaucoup de codes même des cours universitaires qui parlent de caster les variables.

Comment faire alors pour créer une fonction générique qui permettrait de créer n'importe qu'elle type de tableau 2d ??

J'ai trouvé la solution mais c'est par des cast sinon je serais obliger pour chaque type de créer une fonction ce que je voulais éviter pour l'instant tant pis je vais rester sur les casts.

Ma solution :

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
 
char **tab=NULL;
tab=(char**)alloc_2d((void**)char,10,10);
 
/*prototype de la fonction générique*/
extern void **alloc_2d(void **ptr,int size1,int size2);
 
 
/*code de la fonction : ce code ne râle pas à la compile*/
void **alloc_2d(void **ptr,int size1,int size2)
{
  int i;
  assert(size1>0);
  assert(size2>0);
 
  ptr=malloc(size1*sizeof(*ptr));
  if(malloc_error(ptr)==NULL)
    {
      free_alloc(ptr);
      return NULL;
    }
 
  for(i=0;i<size1;i++)
    {
      ptr[i]=malloc(size2*sizeof(*ptr));
      if(malloc_error(ptr[i])==NULL)
	{
	  for(i=i-1;i>=0;i--)
	    free_alloc(ptr[i]);
	  free_alloc(ptr);
	  return NULL;
	}
    }
  return ptr;
}

Le compilo ne râle plus je verrai à l'usage si cette façon de faire me cause des problème par la suite.

[dalfab]

Le compilo ne râle plus car tes casts lui masquent l'anomalie.
Il faut éviter les casts, surtout si on n'en comprend pas bien le rôle.

Si la fonction doit allouer des objets de tailles variables, il faut passer en paramètre la taille (en C++ seulement on peut indiquer une adaptation au type).

Le _ptr ne sert à rien hormis tromper le compilateur qui essaie de te prévenir de ton erreur.

Les fonctions d'allocation :

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
 
#include <stdlib.h>   // pour size_t
 
// Allocation d'un tableau de 'nb_lignes' de tableaux de 'nb_colonnes' objets ayant la taille 'taille_element'
void ***alloc_2d( size_t taille_element , int nb_lignes , int nb_colonnes )
{
    void ***ptr = calloc( nb_lignes , sizeof(*ptr) ); // pour un tableau utiliser calloc() plutôt que malloc() qui n'est adapté que pour les char.
    // ...
    for ( int i = 0 ; i < nb_lignes ; i++ )
    {
        ptr[i] = calloc( nb_colonnes , taille_element ); // alloue le nb d'éléments, au bon alignement et à la bonne taille
        // ...
    }
    return ptr;
}
// Allocation d'un tableau de 'nb' objets ayant la taille 'taille_element'
void **alloc_1d( size_t taille_element , int nb )
{
    void **ptr = calloc( nb , taille_element );   // alloue le nb d'éléments, au bon alignement et à la bonne taille
    // ...
    return ptr;
}

Exemples d'utilisation des fonctions d'allocation de tableaux

Code :

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

1
2
3
4
5
6
7
8
double ** toto2d;
float *toto1d;
 
toto2d = alloc_2d( sizeof(**toto2d) , 5 , 10 );
toto2d[4][9] = 1234.5678;
 
toto1d = alloc_1d( sizeof(*toto1d) , 10 );
toto1d[9] = 123.456f;

Quant à ta fonction alloc_1d (),j'ai des doutes sur le fait qu'elle soit ok. Le fait que le compilateur se taise et même que le code semble marcher n'est pas la preuve d'un code valide.
Transmets nous le code de la fonction alloc_1d().

Et n'hésite pas à relire les commentaire de Matt, Codeur++ et les miens, toutes les informations à suivre sont là.

[hbx360]

Merci pour ton aide.

Et les codes que tu as mis cela va bien me servir.
Pour ma fonction 1d la voici :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
void **alloc(void *ptr,int size)
{
  assert(size>0);
  ptr=malloc(size*sizeof(ptr));
  if(malloc_error(ptr)==NULL)
    {
      free_alloc(ptr);
      return ptr;
    }
  return ptr;
}

[dalfab]

Merci pour ton aide.

Et les codes que tu as mis cela va bien me servir.
Pour ma fonction 1d la voici :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
void **alloc(void *ptr,int size)
{
  assert(size>0);
  ptr=malloc(size*sizeof(ptr));
  if(malloc_error(ptr)==NULL)
    {
      free_alloc(ptr);
      return ptr;
    }
  return ptr;
}

Dans la fonction alloc, on voit bien que tu alloues nb_objets * taille_d'un_pointeur, donc la table fonctionnera pour des objets plus petits que des pointeurs (char,int,float,...) mais n'utilise pas la fonction alloc() pour des double!

[hbx360]

OK merci dalfab pour ton aide

[ternel]

Si tu regardes comment s'utilisent malloc, calloc et realloc, il vaudrait probablement mieux que, comme elles, ta fonction prenne en argument la taille du type à allouer.
Ainsi, tu n'aurais pas ce size_of(ptr) qui n'a aucun rapport avec le tableau à générer.

[hbx360]

Merci pour ta réponse leternel je vais faire comme a dit dalfab.
Le seul problème que je rencontre avec le code proposé par dalfab c'est que si je veux passer en argument des type SDL_Rect ou bien SDL_Surface (peut être des struct quelconque aussi) pour faire des tableaux a 1 ou 2 dimension cela ne marche pas.

C'est dingue que les concepteur du langage C n'ont pas prévu pour accéder à une fonction la possibilité de mettre n'importe qu'elle type de variable en argument.

On est presque obliger de faire des fonctions pour chaque type différent.

[ternel]

C'est précisément le cas, parce que tu ne veux pas n'importe quel type, mais un certain nombre.
Et un void* contient précisément une adresse mémoire non typée.

Pour allouer un bloc mémoire de la bonne taille, il suffirait par exemple d'appeler SDL_rect* **rect_grid = allocate2( sizeof(SDL_rect*), 10, 15);.
D'ailleurs c'est à peu près ce que fait calloc.

Un tableau2D étant linéarisable, tu peux très bien te limiter à cette dernière.

[hbx360]

Merci pour ton aide.

[hbx360]

Bon j'abandonne, j'ai eu des fuites de mémoire des valeurs qui ne corresponde pas etc...
Je vais rester sur un type == une fonction ; trop de problème sinon.
Merci a tous pour votre aide

[CodeurPlusPlus]

C'est dingue que les concepteurs du langage C n'ont pas prévu pour accéder à une fonction la possibilité de mettre n'importe quelle type de variable en argument.

Si. C'est précisément à cela que servent les void*. C'est une vision "bas niveau" des choses, donc c'est tout à fait dans l'esprit du C.

Faire des tableaux 2D (ou des tableaux 1D de tableaux 1D) de void*, c'est comme des tableaux 2D d'ints, sauf qu'au lieu d'avoir des int on a des void*. Il peut alors être utile de fournir au constructeur de tels tableaux des pointeurs de fonctions permettant d'afficher, de cloner, de comparer et de désallouer les éléments stockés dans le tableau. Ce n'est pas très dur d'avoir une implémentation efficace et propre d'un tel type de tableau "générique".

Une petite remarque : un tableau 2D ça peut aussi être un tableau 1D avec des champs spécifiant la largeur d'une ligne et le nombre de lignes... et des accesseurs / mutateurs qui font les calculs d'offset eux-mêmes. Plus des primitives de plus bas niveau pour accélérer les parcours quand on doit traiter à la suite des éléments stockés consécutivement dans une même ligne ou dans une même colonne.

[hbx360]

Merci pour ton commentaire, mais j'ai passer presque 2 jours a chercher les erreurs de segmentation ou
les aberrations dans mes variables (style J->img[0].x=30; me donnait 50 alors que c'était des variables qui n'était en aucune façon modifiés) sans comprendre ce qui ce passait (au départ) malgrés vôtres aides et vos conseils j'en est eu marre et j'ai refait tout les malloc avec des type connu les struct aussi.

Ce qui me pose vraiment problème c'est le passage par des fonctions en ayant en arguments des void* j'ai pourtant suivis vos conseille et vos codes mais finalement ça ne mallouait pas correctement l'espace mémoires pour tout les types struct ce qui m'occasionnait des erreurs comme dit plus haut. Sauf me semble t-il pour les type int char, double, float..

Merci encore pour vos conseils et votre aides.