Quelques questions sur des macro

Bonjour
J'ai besoin de comprendre les macro suivantes ainsi que leur structure

Code:

---

#define NewValue(ts) ((VALUE (*)(void)) (ts->New))()

---

Cette macro prend un argument ts (le type de cet argument n'est pas important).
Le corps de cette macro est: ts->New (Oui?)
A quoi servent les parenthèses vides à la fin?
Je ne comprends pas non plus le code de typage:
VALUE (*)(void)
Cela ressemble à des pointeurs sur fonctions. In fine, cette macro est-elle un pointeur sur fonction?


je ne comprends pas du tout cette macro suivante (la deuxième partie, après les :

Code:

---

1 2 3

#define ToStrValue(vc,flagShort) \   ((vc)->ts == NULL ? "" : \   ((char * (*)(struct value *, char)) ((vc)->ts->ToStr)) ((VALUE) vc,flagShort))

---

Merci

Citation:

---

Code:

---

#define NewValue(ts) ((VALUE (*)(void)) (ts->New))()

---

---

1. (ts->New) est casté en VALUE (*)(void)
2. VALUE (*)(void) c'est le type "pointeur de 'fonction qui prend void comme argument et qui retourne un VALUE''.
3. Une fois le cast fait, on appelle la fonction. Si tu ne comprends pas, note f = (VALUE (*)(void)) (ts->New). L'écriture est ensuite (f)(), qui est bien un appel de fonction.

Citation:

---

Code:

---

(char * (*)(struct value *, char)) ((vc)->ts->ToStr)) ((VALUE) vc,flagShort)

---

---

1. (vc)->ts->ToStr est casté en char * (*)(struct value *, char)
2. char * (*)(struct value *, char) est le type "pointeur de 'fonction qui prend un struct value * et un char comme arguments et qui retourne un char *'".
3. Une fois le cast fait, la fonction est appelée en lui passant évidemment les arguments requis. D'après le code, VALUE est donc un typedef de struct value *.

Voir aussi : [Tutoriel] Les déclarations complexes.

Ok, c'est pas tout a fait ce que je croyais.
En fait, comme il nous arrive de caster des objets ou des variables, il nous arrive aussi de caster des fonctions.

Citation:

---

L'écriture est ensuite (f)(), qui est bien un appel de fonction.

---

Oui, mais ici f ne prend pas d'arguments? Cela reviendrait à écrire (f)(void)?



Dans mon exemple, peut-on dire que la fonction ToStrValue est une référence de la fonction ToStr

Citation:

---

Envoyé par deubelte

Oui, mais ici f ne prend pas d'arguments? Cela reviendrait à écrire (f)(void)?

---

Non, parce que l'usage de la macro est, par exemple : VALUE v = NewValue(s); Ce qui va être transformé lors de la compilation en VALUE v = (f)();

Quand tu appeles une fonction qui prend void comme argument, tu écris ma_fonc(); ou ma_fonc(void); ? C'est la première bien sûr.

Code:

---

1 2 3 4

#define NumExtractValue(vc,arg) \   (((vc)->ts == NULL ? ((*((vc)->sendMessage))(vc,NumExtractMsge,arg)) : \   ((vc)->ts->NumExtract == NULL ? NULL : \   (*((void * (*)(struct value *,void **)) ((vc)->ts->NumExtract))) ((VALUE) (vc),(void **) (arg)))))

---

j'ai une dernière question sur le code ci-dessus, après les :

On a une fonction: vc->ts->NumExtract, qui est casté en *((void * (*)(struct value *,void **)), et qui prend en argument (VALUE) (vc),(void **) (arg).

((void * (*)(struct value *,void **)) est un pointeur sur fonction qui prend en argument struct value et void**.

Donc *((void * (*)(struct value *,void **)) permet de déférencer. Donc NumExtractValue n'est cette fois-ci pas un pointeur de fonction mais une fonction réelle?
Ok?

Exact. Mais il faut également savoir qu'en C, ça ne sert absolument à rien de déréférencer un pointeur de fonction. Explications.

j'ai moi-même fait un test:

Code:

---

1 2 3 4 5 6 7

#define f3(x) ((char* (*)(char *))(fchar))(x)   #define f4(x) (*(char* (*)(char *))(fchar))(x)   char *fchar(char* x){ return x; }

---

et f4 et f3 renvoient exactement la même chose. Cela confirme bien que cela ne sert à rien de déférencer des fonctions?

Oui !!!

Code:

---

1 2 3 4 5

(&printf)("Bonjour.\n"); (printf)("Bonjour.\n"); printf("Bonjour.\n"); (*printf)("Bonjour.\n"); (**printf)("Bonjour.\n");

---

Tout ça aussi c'est la même chose, comme indiqué dans le lien que tu n'a pas suivi.