Discussion :

[sandball22]

Bonjour,

j'aimerais créer une fonction dont un paramètre est de type variable.
A savoir, dans certains cas ce sera un int, dans d'autres cas un float.....

je ne me souviens plus comment il faut déclarer ce paramètre dans ce cas: dans les parenthèses de la fonction ainsi que dans le corps de la fonction.

Merci.

[ManusDei]

les unions ?

[sandball22]

un exemple? car je ne vois pas trop.
Merci.

[sandball22]

il n'y a pas d'autres moyens que les unions?

[maleaume]

les templates

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
/ function template
#include <iostream>
using namespace std;
 
template <class T>
T GetMax (T a, T b) {
  T result;
  result = (a>b)? a : b;
  return (result);
}
 
int main () {
  int i=5, j=6, k;
  long l=10, m=5, n;
  k=GetMax<int>(i,j);
  n=GetMax<long>(l,m);
  cout << k << endl;
  cout << n << endl;
  return 0;
}

EDIT: oups on est en C

[sandball22]

J'ai ce bout de code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
sint16 parametrage_ecriture(uint8 u8_Id, uint32 u32_Valeur)

il s'agit de ma fonction.
or l'argumetn valeur peut etre un int, un float.

Comment dois je déclarer le u32_valeur dans ma fonction pour obtenir la bonne valeur quand il s'agit d'un float?

j'ai casté en faisant (float)u32_Valeur mais j'ai pas la bonne valeur.

[sandball22]

Désolé maleaume, je n'ai pas le droit d'utiliser ce genre de codage.

[maleaume]

un code comme ca marche en C. surcharge de fonction

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
using namespace System;
 
int max(int a, int b)
{
	return a>b? a: b;
}
 
float max(float a, float b)
{
	 return a>b?  a:  b;
}
 
int main(array<System::String ^> ^args)
{
	int a = max(1,2);
	float b = max(1.5f,5.2f);
 
    return 0;
}

apres si tu veux toujours te ramener a un des deux cas (float ou int) tu peux imaginer kk chose comme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
int max(int a, int b)
{
	return a>b? a: b;
}
 
float max(float a, float b)
{
	return (float)max( (int)a, (int)b ); 
}

EDIT: dans ton cas

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
sint16 parametrage_ecriture(uint8 u8_Id, uint32 u32_Valeur)
{

}

sint16 parametrage_ecriture(uint8 u8_Id, float u32_Valeur)
{
}

[sandball22]

Je ne peux pas avoir deux fonctions qui se nomment pareilles mais qui ont des arguments différents.
Je veux utiliser la même fonction mais avec un des arguments qui a son type qui diffère.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
sint16 parametrage_ecriture(uint8 u8_Id, uint32 u32_Valeur)
{

}

Comment fait on pour cela?

[maleaume]

..

[sandball22]

et si je passe par pointeur?
de ce genre?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
sint16 parametrage_ecriture(uint8 u8_Id, void* u32_Valeur)
{
 
}

[maleaume]

et dans ta fonction comment tu va connaitre le type pour recaster?
la surcharge de fonction est le mieux je pense.
et que fait ta fonction exactement?

[sandball22]

je vais connaitre le type grâce au paramètre u8_Id.
en effet, pour chaque u8_Id, je peux savoir le type.

[maleaume]

dans ta fonction

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
sint16 parametrage_ecriture(uint8 u8_Id, uint32 u32_Valeur)
{
 
}

si tu passe un float a u32_Valeur logiauement il doit etre caster en uint32.
donc j au du mal a voir en fait ton probleme tu te moques du type d entree la fonction l auto castera elle meme.
ou alors tu veux faire kkchose de different fonction du type?
dans ce cas surcharge de fonction...

[maleaume]

passe toi de cette arguement suaf si necessaire absolue dans le code , mais si il sert juste a faire un test sur le type prefere :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
 
 
sint16 parametrage_ecriture(uint32 u32_Valeur)
{
 
}
 
sint16 parametrage_ecriture(float u32_Valeur)
{
 
}

ca fait le travail pour toi va pas reinventer la roue

[sandball22]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
sint16 parametrage_ecriture(uint8 u8_Id, uint32 u32_Valeur)
{
 
}

En fait ce que ce je veux, c'est avoir al valeur flottant quadn il s'agit d'un flottatn et non la valeur en int.

par exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
parametrage_ecriture(01, 400);
parametrage_ecriture(01, 0.565588);

Je veux donc pouvoir récupérer la valeur 400 dans le cas 1 et la valeur 0.565588 dans le cas 2 et non la valeur en int.

[Elijha]

Bonjour,

Pourquoi ne pas créer une fonction variadique et utiliser les macros va_start(), va_arg() et va_end() définie dans stdarg.h ? Voir un exemple ici.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
int maFonction(const char *format, ...)
{
     si format = "%d" --> utiliser en tant que int
     sinon si format = "%f" --> utiliser en tant que float
     sinon ne rien faire
 
     return resultat ;
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
x = maFonction("%d", 558) ;
y = maFonction("%f", 123.456) ;
 
// Et si l'on pousse plus loin ;o)
z = maFonction("%d", 24, 89, 55) ;
t = maFonction("%f", 12.34, 56.78, 90.12) ;

[gangsoleil]

Bonjour,

Et pourquoi ne pas utiliser un type union, qui est fait pour ca ?

Quant a la surcharge de fonction en C, j'ai de gros gros doutes (mais je n'ai pas de compilateur sous la main pour essayer, ni la norme). Peut-etre en C99, et encore - pour moi, c'est uniquement present dans le C++.

[Thierry Chappuis]

Bonjour,

Et pourquoi ne pas utiliser un type union, qui est fait pour ca ?

Quant a la surcharge de fonction en C, j'ai de gros gros doutes (mais je n'ai pas de compilateur sous la main pour essayer, ni la norme). Peut-etre en C99, et encore - pour moi, c'est uniquement present dans le C++.

Non, pas de surcharge des fonctions non plus en C99.
Un pointeur générique et un tag pour
indiquer le type, ou un tableau de pointeurs de fonctions, chaque fonction gérant un type particulier. La vrai question est à mon avis de savoir si une telle fonction est vraiment nécessaire pour résoudre le problème du PO. Quel est le cas d'utilisation pour lequel une telle fonction est nécessaire ici?

Thierry

[diogene]

Si tu veux pouvoir écrire quelque chose comme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
parametrage_ecriture(01, 400);
parametrage_ecriture(01, 0.565588);

et même en supposant que le premier argument caractérise le type du second argument (ce qui n'est pas le cas de ton exemple), tu ne peux pas :

1- utiliser la méthode classique du pointeur sur void, car cela implique que le deuxième argument soit une adresse d'objet donc avoir, par exemple

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
int i = 400;
parametrage_ecriture(01, &i);

2- utiliser une union, 400 ne pouvant être la valeur d'une union.

Il reste la solution proposée par Elijha d'utiliser une forme variadique pour laquelle il n'y a pas de tests de type sur les arguments manquants.
Toutefois, cette solution ne résoud pas forcément ton problème : en effet, le deuxième argument passé à la fonction va subir une conversion automatique par défaut : un entier en int, un flottant en double ... Donc le type réel du deuxième argument est limité à int, double,... et le code de la fonction doit en tenir compte
Il doit également y avoir une parfaite concordance entre le premier argument et le type effectif du deuxième. Par exemple, si 02 désigne un deuxième argument de type double, on ne peut écrire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

parametrage_ecriture(02, 400);

pour récupérer 400.0 . On doit explicitement écrire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

parametrage_ecriture(02, 400.0);

La fonction devra alors être utilisée avec une extrême précaution, car le compilateur ne pourra pas détecter ce genre d'erreurs qui vont provoquer des résultats complètement faux.

Un exemple pour montrer ce que ça pourrait donner :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include <stdio.h>
#include <stdarg.h>
typedef enum {EstInt, EstDouble, EstString , EstPFloat, EstAutre} Type;
void maFonction(Type format, ...)
{
    va_list ap;
    int arg;
    va_start(ap, format);
    switch(format)
    {
      case EstInt :
           {
             int arg = va_arg(ap, int);
             printf("type int %d\n",arg);
             break;
           }
      case EstDouble :
           {
           double arg = va_arg(ap, double);
           printf("type double %f\n",arg);
           break;
           }
      case EstString :
           {
           void* arg = va_arg(ap, void*);
           printf("type string %s\n",arg);
           break;
           }
      case EstPFloat :
           {
           void* arg = va_arg(ap, void*);
           printf("type float %f\n",*(float*)arg);
           break;
           }
      default :
           printf("type inconnu\n",arg);
    }
    va_end(ap);
}
int main(void)
{
   float f = 0.9876f;
   maFonction(EstInt, 12345);
   maFonction(EstDouble, 1.2345);
   maFonction(EstString,"abcde");
   maFonction(EstPFloat,&f);
   return 0;
}