Pourquoi les pointeurs de fonction et les pointeurs de données sont-ils incompatibles en C / C ++?

J'ai lu que la conversion d'un pointeur de fonction en un pointeur de données et vice versa fonctionne sur la plupart des plates-formes mais n'est pas garantie de fonctionner. pourquoi est-ce le cas? Les deux ne devraient-ils pas être simplement des adresses dans la mémoire principale et donc être compatibles?

Une architecture n'a pas à stocker le code et les données dans la même mémoire. Avec une architecture Harvard, le code et les données sont stockés dans une mémoire complètement différente. La plupart des architectures sont des architectures Von Neumann avec du code et des données dans la même mémoire, mais C ne se limite pas à certains types d'architectures si possible.

Certains ordinateurs ont (avaient) des espaces d'adressage séparés pour le code et les données. Sur un tel matériel, cela ne fonctionne tout simplement pas.

Le langage est conçu non seulement pour les applications de bureau actuelles, mais pour lui permettre d'être implémenté sur un grand nombre de matériels.

Il semble que le comité du langage C n'ait jamais voulu void*être un pointeur vers une fonction, il voulait juste un pointeur générique vers des objets.

La justification du C99 dit:

6.3.2.3 Les pointeurs
C ont maintenant été implémentés sur une large gamme d'architectures. Alors que certaines de ces architectures comportent des pointeurs uniformes qui ont la taille d'un certain type entier, le code portable au maximum ne peut pas supposer la correspondance nécessaire entre les différents types de pointeurs et les types entiers. Sur certaines implémentations, les pointeurs peuvent même être plus larges que n'importe quel type entier.

L'utilisation de void*(«pointeur vers void») comme type de pointeur d'objet générique est une invention du Comité C89. L'adoption de ce type a été stimulée par le désir de spécifier des arguments de prototype de fonction qui convertissent discrètement des pointeurs arbitraires (comme dans fread) ou se plaignent si le type d'argument ne correspond pas exactement (comme dans strcmp). Rien n'est dit sur les pointeurs vers des fonctions, qui peuvent être incommensurables avec les pointeurs d'objet et / ou les entiers.

Remarque Rien n'est dit sur les pointeurs vers des fonctions dans le dernier paragraphe. Ils peuvent être différents des autres indicateurs, et le comité en est conscient.

Pour ceux qui se souviennent de MS-DOS, de Windows 3.1 et des versions antérieures, la réponse est assez simple. Tous ces éléments étaient utilisés pour prendre en charge plusieurs modèles de mémoire différents, avec différentes combinaisons de caractéristiques pour les pointeurs de code et de données.

Ainsi par exemple pour le modèle Compact (petit code, grandes données):

sizeof(void *) > sizeof(void(*)())

et inversement dans le modèle Medium (grand code, petites données):

sizeof(void *) < sizeof(void(*)())

Dans ce cas, vous n'aviez pas de stockage séparé pour le code et la date, mais vous ne pouviez toujours pas convertir entre les deux pointeurs (à moins d'utiliser des modificateurs __near et __far non standard).

De plus, il n'y a aucune garantie que même si les pointeurs sont de la même taille, ils pointent vers la même chose - dans le modèle de mémoire DOS Small, le code et les données sont utilisés près des pointeurs, mais ils pointent vers des segments différents. Ainsi, la conversion d'un pointeur de fonction en pointeur de données ne vous donnerait pas un pointeur ayant une quelconque relation avec la fonction, et par conséquent, une telle conversion n'était pas utile.

Les pointeurs vers void sont censés pouvoir accueillir un pointeur vers n'importe quel type de données - mais pas nécessairement un pointeur vers une fonction. Certains systèmes ont des exigences différentes pour les pointeurs vers des fonctions et les pointeurs vers des données (par exemple, il existe des DSP avec un adressage différent pour les données par rapport au code, le modèle moyen sur MS-DOS utilise des pointeurs 32 bits pour le code mais uniquement des pointeurs 16 bits pour les données) .

En plus de ce qui est déjà dit ici, il est intéressant de regarder POSIX dlsym():

La norme ISO C n'exige pas que les pointeurs vers les fonctions puissent être convertis en pointeurs vers des données. En effet, la norme ISO C n'exige pas qu'un objet de type void * puisse contenir un pointeur vers une fonction. Les implémentations prenant en charge l'extension XSI, cependant, nécessitent qu'un objet de type void * puisse contenir un pointeur vers une fonction. Le résultat de la conversion d'un pointeur vers une fonction en un pointeur vers un autre type de données (à l'exception de void *) n'est cependant toujours pas défini. Notez que les compilateurs conformes à la norme ISO C sont tenus de générer un avertissement si une conversion d'un pointeur void * en un pointeur de fonction est tentée comme dans:

 fptr = (int (*)(int))dlsym(handle, "my_function");

En raison du problème noté ici, une version future peut soit ajouter une nouvelle fonction pour renvoyer des pointeurs de fonction, soit l'interface actuelle peut être déconseillée au profit de deux nouvelles fonctions: l'une qui renvoie des pointeurs de données et l'autre qui renvoie des pointeurs de fonction.

C ++ 11 a une solution à la discordance de longue date entre C / C ++ et POSIX en ce qui concerne dlsym(). On peut utiliser reinterpret_castpour convertir un pointeur de fonction vers / à partir d'un pointeur de données tant que l'implémentation prend en charge cette fonctionnalité.

D'après la norme, 5.2.10 par. 8, "la conversion d'un pointeur de fonction en un type de pointeur d'objet ou vice versa est conditionnellement prise en charge." 1.3.5 définit "pris en charge conditionnellement" comme une "construction de programme qu'une implémentation n'est pas tenue de prendre en charge".

En fonction de l'architecture cible, le code et les données peuvent être stockés dans des zones de mémoire fondamentalement incompatibles et physiquement distinctes.

undefined ne signifie pas nécessairement non autorisé, cela peut signifier que l'implémenteur du compilateur a plus de liberté pour le faire comme il le souhaite.

Par exemple, cela peut ne pas être possible sur certaines architectures - undefined leur permet de conserver une bibliothèque 'C' conforme même si vous ne pouvez pas le faire.

Une autre solution:

En supposant que POSIX garantit que les pointeurs de fonction et de données ont la même taille et la même représentation (je ne trouve pas le texte pour cela, mais l'exemple OP cité suggère qu'ils avaient au moins l' intention de faire cette exigence), ce qui suit devrait fonctionner:

double (*cosine)(double);
void *tmp;
handle = dlopen("libm.so", RTLD_LAZY);
tmp = dlsym(handle, "cos");
memcpy(&cosine, &tmp, sizeof cosine);

Cela évite de violer les règles d'aliasing en passant par la char []représentation, qui est autorisée à aliaser tous les types.

Encore une autre approche:

union {
    double (*fptr)(double);
    void *dptr;
} u;
u.dptr = dlsym(handle, "cos");
cosine = u.fptr;

Mais je recommanderais l' memcpyapproche si vous voulez absolument 100% correct C.

Ils peuvent être de différents types avec des exigences d'espace différentes. L'affectation à un peut découper de manière irréversible la valeur du pointeur de sorte que l'assignation en retour aboutisse à quelque chose de différent.

Je pense qu'ils peuvent être de types différents parce que la norme ne veut pas limiter les implémentations possibles qui économisent de l'espace lorsque ce n'est pas nécessaire ou lorsque la taille pourrait obliger le processeur à faire des conneries supplémentaires pour l'utiliser, etc.

La seule solution vraiment portable consiste à ne pas utiliser dlsympour les fonctions, mais plutôt à utiliser dlsympour obtenir un pointeur vers des données contenant des pointeurs de fonction. Par exemple, dans votre bibliothèque:

struct module foo_module = {
    .create = create_func,
    .destroy = destroy_func,
    .write = write_func,
    /* ... */
};

puis dans votre application:

struct module *foo = dlsym(handle, "foo_module");
foo->create(/*...*/);
/* ... */

Incidemment, c'est de toute façon une bonne pratique de conception, et il est facile de prendre en charge à la fois le chargement dynamique via dlopenet la liaison statique de tous les modules sur des systèmes qui ne prennent pas en charge la liaison dynamique, ou lorsque l'intégrateur utilisateur / système ne souhaite pas utiliser de liaison dynamique.

Un exemple moderne où les pointeurs de fonction peuvent différer en taille des pointeurs de données: pointeurs de fonction membre de classe C ++

Directement cité de https://blogs.msdn.microsoft.com/oldnewthing/20040209-00/?p=40713/

class Base1 { int b1; void Base1Method(); };
class Base2 { int b2; void Base2Method(); };
class Derived : public Base1, Base2 { int d; void DerivedMethod(); };

Il y a maintenant deux thispointeurs possibles .

Un pointeur vers une fonction membre de Base1peut être utilisé comme pointeur vers une fonction membre de Derived, car ils utilisent tous les deux le même this pointeur. Mais un pointeur vers une fonction membre de Base2ne peut pas être utilisé tel quel en tant que pointeur vers une fonction membre de Derived, car le this pointeur doit être ajusté.

Il existe de nombreuses façons de résoudre ce problème. Voici comment le compilateur Visual Studio décide de le gérer:

Un pointeur vers une fonction membre d'une classe à héritage multiple est en réalité une structure.

[Address of function]
[Adjustor]

La taille d'un pointeur vers une fonction membre d'une classe qui utilise l'héritage multiple est la taille d'un pointeur plus la taille d'un size_t.

tl; dr: Lors de l'utilisation de l'héritage multiple, un pointeur vers une fonction membre peut (selon le compilateur, la version, l'architecture, etc.) être stocké comme

struct { 
    void * func;
    size_t offset;
}

qui est évidemment plus grand qu'un void *.

Sur la plupart des architectures, les pointeurs vers tous les types de données normaux ont la même représentation, donc la conversion entre les types de pointeurs de données est un no-op.

Cependant, il est concevable que les pointeurs de fonction nécessitent une représentation différente, peut-être qu'ils sont plus grands que les autres pointeurs. Si void * pouvait contenir des pointeurs de fonction, cela signifierait que la représentation de void * devrait avoir la plus grande taille. Et tous les moulages de pointeurs de données vers / depuis void * devraient effectuer cette copie supplémentaire.

Comme quelqu'un l'a mentionné, si vous en avez besoin, vous pouvez y parvenir en utilisant un syndicat. Mais la plupart des utilisations de void * sont juste pour les données, il serait donc onéreux d'augmenter toute leur utilisation de la mémoire juste au cas où un pointeur de fonction doit être stocké.

Je sais que cela n'a pas été commenté depuis 2012, mais je pensais que ce serait utile d'ajouter que je ne sais une architecture qui a très pointeurs incompatibles pour les données et les fonctions depuis un appel en ce privilège vérifie l' architecture et porte des informations supplémentaires. Aucune quantité de casting n'aidera. C'est le moulin .