Discussion :

[Dunkhan]

Bonjour,

Je cherche a faire une fonction pour exécuter un malloc sur différents types de structures.

Dans mon code, j'ai des malloc a faire sur de nombreuses structures de types différents, et pour "gagner du temps", je me suis dis que ca serais sympas de faire une fonction a laquelle je pourrais passer la structure en paramètre, faire mon malloc et retourner la structure.

La ou je suis bloqué, c'est que je suis, a ma connaissance, obligé de passer le type de la structure un peu partout..

Code :

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

1
2
3
4
typedef struct str
{
	char *string;
}t_str

Code :

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

t_str* new_struct(void);

Code :

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

1
2
3
4
5
6
t_str* new_struct()
{
	t_str* this = malloc(sizeof(t_str));
	if (!this) return NULL;
	return this;
}

Y aurait il un moyen (détourner?) de faire qui me permettrais de réutiliser la fonction pour n'importe quelle type de structure???

[Sve@r]

Bonjour

Y aurait il un moyen (détourné?) de faire qui me permettrais de réutiliser la fonction pour n'importe quelle type de structure???

Hum...en passant par un void* qui sert justement à uniformiser des pointeurs disparates...

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
typedef struct {
	char tab[10];
}t_strA;
 
typedef struct {
	char tab[20];
}t_strB;
 
void *allocate(size_t n) {
    void *this;
    this=malloc(n);
    return this;
}
 
t_strA *ptA;
t_strB *ptB;
ptA=(t_strA*)allocate(sizeof(*ptA));
ptB=(t_strB*)allocate(sizeof(*ptB));

Mais tu remarqueras assez vite (j'espère) que cette façon de faire rend alors cette fonction totalement inutile...

Code c :

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

1
2
3
4
t_strA *ptA;
t_strB *ptB;
ptA=malloc(sizeof(*ptA));
ptB=malloc(sizeof(*ptB));

[Dunkhan]

Pq c'est plus rapide de l’écrire directement de que passer par une fonction??
Et qu'aussi, il faudra que je passe la taille de la structure en paramètre (donc une ligne de code en plus pour la connaitre et l'affecter a une variable).

Mais je suis censé faire un gestionnaire d'erreurs qui capture toutes les interactions qui sont supposées "possible" d'en provoquer.

Du coups, je pensais inclure mon gestionnaire d'erreurs dans la fonction new_struct()


Merci pour la réponse

[Sve@r]

Pq c'est plus rapide de l’écrire directement de que passer par une fonction??

Attention, je n'ai pas dit de ne pas passer par une fonction. Mais malloc() c'est déjà une fonction et elle est faite justement pour ça. Et, si tu regardes bien, ta fonction (tout comme la miennne d'ailleurs) ne font rien de plus et peuvent même se simplifier

Code c :

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

1
2
3
4
5
6
7
t_str* new_struct() {
	return malloc(sizeof(t_str));
}
 
void *allocate(size_t n) {
	return malloc(n);
}

Donc passer par une seconde fonction qui (pour l'instant) ne fait rien de plus que malloc, ça ne sert à rien.

Et qu'aussi, il faudra que je passe la taille de la structure en paramètre (donc une ligne de code en plus pour la connaitre et l'affecter a une variable).

Ah ben ça reste incontournable. Soit ta fonction est du type "pointeur sur structure" et donc elle connait implicitement la taille de ladite structure, soit elle est de type "pointeur universel" et comme elle ne connait plus la taille de la structure il faut la lui passer à un moment ou à un autre...

Mais je suis censé faire une gestionnaire d'erreurs qui capturent toutes les interactions qui sont supposées "possible" d'en provoquer
Du coups, je pensais inclure mon gestionnaire d'erreurs dans la fonction new_struct()

Ok. A ce moment là, effectivement la fonction commence à avoir un sens et une utilité. Mais si tu veux "une seule fonction universelle" tu es obligé de travailler en "universel" donc en "void *". Et là tu peux y inclure ton gestionnaire d'erreurs. Mais tu ne pourras pas éviter d'avoir à lui passer la taille de la structure en paramètre. On n'a rien sans rien et ça reste valable en informatique aussi

[Dunkhan]

Ok, merci pour les précisions..
J'avais pensé proposer le type générique void*, mais c'est qlq chose que l'on vient de juste voir au cours et je n'ai pas encore compris toute l’étendue des possibilités..

[Matt_Houston]

Le C n'offre qu'un éventail de possibilités très limité / contraignant pour faire de la généricité. On peut le résumer à :

• void * à l'exécution :
  

  Code :

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

  1
  2
  3
  4
  5
  6
  typedef struct vector {
      size_t capacity,
             count, // element count
             size;  // element size
      void *data;
  } vector_t;

• les macros à la compilation :
  

  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
  #define CONCAT_(a, b) a ## b
  #define CONCAT(a, b) CONCAT_(a, b)
   
  /* ... */
   
  #define TYPEDEF_VECTOR(type, suffix) \
  typedef struct CONCAT(vector_, suffix) { \
      size_t capacity,                   \
             count; /* element count */  \
      type *data;                         \
  } CONCAT(CONCAT(vector_, suffix), _t);
   
   
  TYPEDEF_VECTOR(double, double)
  TYPEDEF_VECTOR(unsigned long, ulong)
   
   
  int main(int argc, char *argv[]) {
      vector_double_t v0;
      vector_ulong_t v1;
   
      // ...