Comment utiliser la variable pour le nom de variable (partielle)? (C)

Question

permet de dire que j'ai la fonction

void do_work (foo?); 

Le? représente un 0 ou un 1 qui sera la valeur de la variable

int bar = 0; 

Il y a aussi les variables

int foo0 = 0; 
int foo1 = 0; 

Je suis en train d'injecter la valeur d'une variable dans le nom d'une autre variable de sorte que la fonction obtient le nom complet de l'une ou l'autre variable en fonction de la logique précédente.

Comment est-ce que je peux faire ceci?

(Dans ce cas, je ne suis pas inquiet au sujet de la pratique bonne ou mauvaise.)

Answer 1

C ne fonctionne pas de la façon dont vous pensez peut-être. Vous ne pouvez pas faire référence de manière dynamique au nom d'une variable à l'exécution, comme vous pouvez l'être dans d'autres langues.

Cela dit, le nom des arguments de la fonction n'est pas pertinent.

void do_work(int arg) 
{ 
} 

Vous ne devez pas correspondre au nom de arg avec foo0 ou foo1. Maintenant, vous pouvez passer soit variable dans la fonction:

int foo0, foo1; 

if (some_condition) 
    do_work(foo0); 
else 
    do_work(foo1); 

Maintenant, la fonction do_work va travailler sur une copie de la variable passée. Donc, si vous changez la valeur de la variable dans la fonction, elle restera la même en dehors de la fonction.Vous pouvez changer cela en retournant une nouvelle valeur:

int do_work(int arg) 
{ 
    return arg + 1; 
} 

foo0 = do_work(foo0); 

Enfin, il semble que vous voulez utiliser un tableau:

int foo[2]; // create two ints: foo[0] and foo[1] 

do_work(foo[0]); 

int i = 1; 
do_work(foo[i]); 

Answer 2

Utilisez un tableau ou un pointeur à la place. Vous y accédez avec, par exemple, foo[ind].

Answer 3

utiliser le tableau:

int foo[2] = {0, 0}; 

et vous pouvez taper

do_work(foo[bar]); 

Answer 4

Pour garder les variables foo1 et foo2 d'origine, vous pouvez configurer un tableau avec des pointeurs vers ces endroits, et lire/écrire aux vairables via les pointeurs dans le tableau.

I.e.

int *fooArray[2]; 
fooArray[0] = &foo0; 
fooArray[1] = &foo1; 

... vous pouvez appeler votre fonction avec:

do_work(*fooArray[bar]); 

Answer 5

tableaux sont conçus pour contenir des valeurs de types de données homogènes et personne n'utilisera foo0, foo1 pour ce genre d'exigence

Answer 6

Puisque vous dites que vous n'êtes pas concerné par une bonne ou une mauvaise pratique, vous pouvez implémenter le comportement que vous voulez sans introduire de nouvelles variables:

if (bar == 0) 
    do_work(foo0); 
else if (bar == 1) 
    do_work(foo1); 
else 
    puts("Uh oh, unexpected bar value!"); 

Answer 7

Sur demande spéciale de @dreamlax:

1) déclarer ces variables comme

__declspec(dllexport) static int foo1; 
__declspec(dllexport) static int foo2; 

2) Utiliser HANDLE this_module = GetModuleHandle(NULL); obtenir le module courant

3) Obtenir le nom de la variable nécessaire:

char vname[100]; 
sprintf(vname, "foo%d", bar); 

4) Recherche:

int* fooX = (int*)GetProcAddress(this_module, vname); 

5) Et enfin, vous pouvez l'utiliser:

do_work(fooX); // or *fooX, as you like 

Answer 8

Voici une mauvaise idée pour vous:

#define foo0 foo[0] 
#define foo1 foo[1] 
#define foobar foo[bar] 

int foo[2]; 
int bar;