Comment envelopper la fonction existante en C

J’essaie d’envelopper la fonction existante.

le code ci-dessous est parfaitement travaillé.

#include int __real_main(); int __wrap_main() { printf("Wrapped main\n"); return __real_main(); } int main() { printf("main\n"); return 0; }

commander:

 gcc main.c -Wl,-wrap,main

sortie:

 Wrapped main main

J’ai donc changé de fonction principale avec temp. mon but est d’envelopper la fonction temp ().

Ci-dessous le code

temp.c

 #include int temp(); int __real_temp(); int __wrap_temp() { printf("Wrapped temp\n"); return __real_temp(); } int temp() { printf("temp\n"); return 0; } int main() { temp(); return 0; }

commander:

 gcc temp.c -Wl,-wrap,temp

sortie:

 temp

La température enveloppée n’imprime pas. S’il vous plaît, guidez-moi pour envelopper funciton temp.

La page de manuel de ld dit:

  --wrap=symbol Use a wrapper function for symbol. Any undefined reference to symbol will be resolved to "__wrap_symbol". Any undefined reference to "__real_symbol" will be resolved to symbol.

Le mot clé ici n’est pas défini.

Si vous placez la définition temp dans la même unité de traduction que le code qui l’utilise, elle ne sera pas indéfinie dans le code qui l’utilise.

Vous devez diviser la définition de code et le code qui l’utilise:

 #!/bin/sh cat > user.c <<'EOF' #include int temp(void); int __real_temp(void); int __wrap_temp() { printf("Wrapped temp\n"); return __real_temp(); } int main() { temp(); return 0; } EOF cat > temp.c <<'EOF' #include int temp() { printf("temp\n"); return 0; } EOF gcc user.c -Wl,-wrap,temp temp.c # OK ./a.out

La scission de la compilation en deux compilations distinctes rend peut-être cela plus clair:

 $ gcc -c user.c $ gcc -c temp.c $ nm user.o temp.o temp.o: U puts 0000000000000000 T temp user.o: 0000000000000015 T main U puts U __real_temp U temp 0000000000000000 T __wrap_temp

Maintenant que temp est indéfini dans user.c , l’éditeur de liens peut faire sa magie __real_ / __wrap_ .

 $ gcc user.o temp.o -Wl,-wrap=temp $ ./a.out Wrapped temp temp

La réponse proposée par PSCocik fonctionne parfaitement si vous pouvez séparer la fonction que vous souhaitez remplacer de la fonction qui l’appellera. Cependant, si vous voulez garder l’appelé et l’appelant dans le même fichier source, l’option --wrap ne fonctionnera pas.

Au lieu de cela, vous pouvez utiliser __atsortingbute__((weak)) avant la mise en œuvre de l’appelé afin de permettre à quelqu’un de le réimplémenter sans que GCC ne crie à propos de plusieurs définitions.

Par exemple, supposons que vous souhaitiez vous moquer de la fonction world dans l’unité de code hello.c suivante. Vous pouvez préfixer l’atsortingbut afin de pouvoir le remplacer.

 #include "hello.h" #include  __atsortingbute__((weak)) void world(void) { printf("world from lib\n"); } void hello(void) { printf("hello\n"); world(); }

Et vous pouvez ensuite le remplacer dans un autre fichier d’unité. Très utile pour les tests unitaires / moqueurs:

 #include  #include "hello.h" /* overrides */ void world(void) { printf("world from main.c"\n); } void main(void) { hello(); return 0; }