fonction sans argument typé

Version imprimable

27/07/2010, 08h42
deubelte

fonction sans argument typé
Bonjour

J'ai vu qu'on pouvait avoir des fonctions dont l'argument était typé mais pas déclaré dans la fonction:
Exemple:
Code:

1 2 3 4 5 6 7 8 9 10 void f(bool,int){ __formal; int o=3; } int main(){ bool p=true; f(p,2); }
Mais j'ai vu dans les variables locales qu'il y a un argument qui est en fait caché, et qui s'appelle __formal.
Pourriez vous svp me donner quelques explications sur ce genre de fonction?
Notamment comment utiliser __formal?

Je vous remercie
27/07/2010, 09h36
white_tentacle

Ça ressemble à une extension propre à ton compilateur (le double underscore indique généralement ceci). Je te conseillerai plutôt de ne pas l'utiliser, donc ;).

Ce lien peu t'aider.

http://publications.gbdirect.co.uk/c...ion_types.html

Tu peux effectivement faire une déclaration de ce type

Code:

1
2
 
double sq_root(double);

Cela sert à définir un prototype et indiquer au compilateur que tu va te servir d'une fonction que tu va implémenter plus tard.

Cependant hormis des algorithme récursif, il y'a toujours moyen de s'arranger pour que ta fonction soit définie avant son utilisation.

Exemple:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
#include <stdio.h>
#include <stdlib.h>
#define DELTA 0.0001
main(){
      double sq_root(double); /* prototype */
      int i;
 
      for(i = 1; i < 100; i++){
              printf("root of %d is %f\n", i, sq_root(i));
      }
      exit(EXIT_SUCCESS);
}
 
double
sq_root(double x){      /* definition */
      double curr_appx, last_appx, diff;
 
      last_appx = x;
      diff = DELTA+1;
 
      while(diff > DELTA){
              curr_appx = 0.5*(last_appx
                      + x/last_appx);
              diff = curr_appx - last_appx;
              if(diff < 0)
                      diff = -diff;
              last_appx = curr_appx;
      }
      return(curr_appx);
}

Peux tout aussi bien s'écrire

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
#include <stdio.h>
#include <stdlib.h>
#define DELTA 0.0001
 
 
double sq_root(double x){      /* definition */
      double curr_appx, last_appx, diff;
 
      last_appx = x;
      diff = DELTA+1;
 
      while(diff > DELTA){
              curr_appx = 0.5*(last_appx
                      + x/last_appx);
              diff = curr_appx - last_appx;
              if(diff < 0)
                      diff = -diff;
              last_appx = curr_appx;
      }
      return(curr_appx);
}
 
main(){
      int i;
      for(i = 1; i < 100; i++){
              printf("root of %d is %f\n", i, sq_root(i));
      }
      exit(EXIT_SUCCESS);
}

27/07/2010, 13h20
3DArchi

Citation:

Envoyé par deubelte

Mais j'ai vu dans les variables locales qu'il y a un argument qui est en fait caché, et qui s'appelle __formal.
Pourriez vous svp me donner quelques explications sur ce genre de fonction?
Notamment comment utiliser __formal?

En C++, si tu ne donnes pas de nom aux paramètres de tes fonction, alors tu ne peux pas les utiliser dans le corps de celle-ci. Ces paramètres sont parfois nécessaires (par exemple pour les fonctions virtuelles qui doivent avoir la même signature) même si non utilisés.
__formal est une extension de Visual C++ qui me semble non documentée (pour du debug ?). Tu dois l'avoir vu uniquement dans du code spécifique au compilateur. Je ne peux que vivement te déconseiller d'utiliser __formal. Ce n'est pas utilisable avec d'autres compilateurs. Et même avec Visual, ça n'est peut être pas pérenne d'une version sur l'autre.

Il existe des cas où tu dois écrire une fonction en suivant un prototype bien défini, mais tu te rends compte que tu ne te sers pas des paramètres de cette fonction. Un exemple classique : une callback dont tu te moques des arguments, ou une fonction de gestion d'un thread.

Un exemple certes un peu idiot, mais qui montre ce dernier cas.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 // prototype normal de la fonction: int threadfunc(void* data) // mais je sais que je ne passe pas de paramètre "data", donc je // me moque de la valeur. Si je rajoute le nom de la variable, mon // compilateur va se plaindre parce que la variable n'est pas // utilisée dans le code. Donc autant ne pas le mettre... int my_thread(void*) { while (true) { int c = read_kdb(); if (c == KBD_ESCAPE) break; } } int main() { thread t = create_thread(/*threadfunc=*/ my_thread, /*data=*/ NULL); wait_for_termination(t); }