type variable de variable

Version imprimable

Bonjour à tous,

Toujours dans le cadre de mon projet, j'aurais besoin de pouvoir "forcer" l'utilisation d'un double dans une fonction, sachant que l'on peut envoyer en fait n'importe quel type.

Par exemple, le bout de code suivant :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 double fonction(double *tab) { double i = tab[0]*tab[1]; return i; } char utab[5][30] = {{0}}; // j'utilise un char ici, mais ça pourrait être aussi un int ou unsigned short int par exemple double v = fonction( &(utab[3]) ); // ceci ne marche bien évidemment pas...
Voilà, je n'ai pas mis le code original pour éviter d'avoir à tout apurer, mais l'idée est celle-ci.

Puis-je par exemple, réaliser un truc du genre avant de l'envoyer dans ma fonction ?

Code:

utab = (double)utab;

D'avance, merci pour vos retours !

En C, aucune chance. Le mieux que tu puisses faire est ceci:

Code:

1
2
3
4
har utab[5][30] = {{0}};    // j'utilise un char ici, mais ça pourrait être aussi un int ou unsigned short int par exemple
 
double doubles[2] = { utab[3][0], utab[3][1] };
double v = fonction( doubles );

En C++, c'est une autre histoire.

Si tu peux le faire :mrgreen:, mais d'une façon qui n'est pas trop appréciée :mrgreen: :mrgreen:

Code non compilé :

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
32
33
34
35
36
37
38
39
typedef enum e_TAB_TYPE {
    TAB_TYPE_UNKNOWN = 0,
    TAB_TYPE_DOUBLE,
    TAB_TYPE_CHAR,
    TAB_TYPE_INT
// ...
} TAB_TYPE;
 
 
double fonction(void* tab, TAB_TYPE tab_type) {
    double result;
 
    if (tab != NULL) {
        switch(tab_type) {
        case TAB_TYPE_DOUBLE:
            result = ((double*) tab)[0] * ((double*) tab)[1];
            break;
        case TAB_TYPE_CHAR:
//          result ....
            break;
        case TAB_TYPE_INT:
//          result ....
            break;
        default, case TAB_TYPE_UNKNOWN:
            result = 0.0;
            break;
        }
    } else {
        result = 0.0;
    }
 
    return result;
}
 
 
// and maybe
// double fonction_int(void* tab) { return fonction(tab, TAB_TYPE_INT); }
// or
// double fonction_int(void* tab) { return ((tab != NULL)? fonction(tab, TAB_TYPE_INT): 0.0); }

07/12/2017, 23h30
BioKore

Bonjour,

Je vous remercie pour ce retour ! Effectivement, j'ai bidouillé un peu, et j'en suis finalement arrivé à la même conclusion que Médinoc.
Quant à la solution de foetus, effectivement, je n'avais pas trop pensé à ça... Mais vu que mon utilisation reste pour le moment limitée à un cas particulier, je préfère éviter ce fonctionnement "trop lourd" à mon goût ; mais j'y reviendrais probablement un jour.

Merci encore ; sujet résolu :)