Considérations sur les pointeurs de fonctions

Bonjour,

D'après ce que j'ai compris, on peut considérer une fonction comme une variable qui possède sa propre adresse mémoire, puisque chaque morceaux de code occupe une place mémoire. J'ai voulu comprendre comment traiter les pointeurs sur les fonctions en s'appuyant sur les pointeurs sur variables. en fait, une fonction serait plus une référence, puisque f et &f ont la même adresse mémoire.

(Je n'ai pas vu cela dans les livres que j'ai lui, mais je trouve que c'est clair comme ca)


De la même manière que l'on déclare une variable

Code:

---

1 2

int o;

---

on déclare une fonction comme ceci par exemple:

Code:

---

1 2	int f(int);

---

Supposons qu'on ait une fonction:

Code:

---

1 2 3

int f(int o){ return o+1;}

---

Maintenant, on peut faire passer cette fonction "par valeur" comme n'importe quelle variable. On peut considérer que la fonction suivante est une composition de fonction f°g(x), où x est l'entier r.

Code:

---

1 2 3 4 5

int main(){ int f1(int ft(int),int r){ int ff=ft(r); return ff+10; }

---

Mais on peut aussi faire ceci:

Code:

---

1 2 3 4 5

int f2(int ft(int o),int r){ int ff=ft(r); return ff+20; }

---

Quelle est d'ailleurs la différence avec le code précédent?

Comme les variables, on peut faire passer les fonctions par références:

Code:

---

1 2 3 4 5

int f3(int (&ft)(int o),int r){ int ff=ft(r); return ff+30; }

---

et on aura:

Code:

---

1 2 3 4

int main(){ int o3=f3(f,2); }

---

Même question: quelle est la différence avec les cas précédents? Parce qu'ici, on ne cherche pas a modifier la fonction

Enfin, comme pour les variables, on a les pointeurs sur fonctions, avec un code spécifique:

Code:

---

int (*fct)(int c)=&f;

---

Donc fct est un pointeur sur la fonction f. Pour l'utiliser, on la déférence comme cela:

Code:

---

1 2 3 4 5

int f4(int (*ft)(int o),int r){ int ff=(*ft)(r); return ff+40; }

---

et on l'utilise comme cela:

Code:

---

1 2	int o4=f4(fct,4);

---

où comme cela:

Code:

---

1 2 3

int (*g)(int)=&f; o=(&f)(5);

---

Je voudrais savoir s'il est possible de faire qqch comme cela:

Code:

---

1 2 3 4 5 6

int g(int)=f;   //ou   int g(int)=f(int);

---

parce qu'apparement ca fait planter le compilateur, g ne peut pas être initialisé.


D'après ce que j'ai vu, un pointeur sur fonction permet d'aller plus vite et d'économiser de la place mémoire, puisqu'on ne recrée pas de variables. Cela permet aussi de créer des "variables de fonctions" que l'on peut réutiliser dans le code.

Merci

Edit:
Bien sur, tout cela n'est que pur spéculation, j'attends vos corrections, commentaires, ajouts... avec remerciements de ma part.

Ah ben t'es pas au bout de tes peines, là ;)

Une fonction est un bout de code en mémoire en un endroit fixé. Le point d'entrée de ce code est une adresse mémoire, c'est-à-dire un... pointeur.
Je crois qu'il ne faut pas chercher plus loin que ça.

Tiens, petit exercice pour toi (:aie:)
Ecris une "fonction" qui reçoit un paramètre et dont le résultat est un booléen, vrai si le paramètre est un pointeur, faux sinon.
Si si, on peut faire ça en C++ :mouarf:

On a droit à une classe de trait? :roll:

Citation:

---

Ecris une "fonction" qui reçoit un paramètre et dont le résultat est un booléen, vrai si le paramètre est un pointeur, faux sinon.
Si si, on peut faire ça en C++

---

hmm pas je regarderai.

En attendant, j'ai vu qu'on pouvais déférencer autant de fois un pointeur sur fonction (je ne sais plus pourquoi d'ailleurs), cela ne changera pas le résultat.

Sinon, j'essaye de faire des conversions de fonctions. Par exemple, on a bien une conversion avec le code suivant, a cause du double en parenthèse.

[code]
int o=3;
double g=(double)o;
[CODE]

Si on a une fonction g qui prend un int et qui renvoie un int,
Est-il possible de convertir un pointeur de fonction qui prend un entier en argument et qui renvoie un entier en un pointeur de fonctions qui prend un entier en argument et qui renvoie un double.
Je pensais à faire qqch comme:

Code:

---

1 2 3 4 5

int (*)(f)(int)=&g; double (*w)(int)=int (*)(f)(int); //ou double (*w)(int)=(double) (int (*f)(int));

---

enfin qqch comme
Pt2=(double) Pt1

Mais cela ne fonctionne pas.