Come copiare la variabile locale sulla variabile globale se entrambi hanno lo stesso nome in C senza utilizzare una terza variabile?

Question

Ho una variabile globale e una variabile locale con gli stessi nomi. Posso copiare la variabile locale nella variabile globale (assign) senza prima assegnare il valore della variabile globale ad una variabile temporanea (usando extern) e quindi assegnare la variabile temporanea alla variabile globale? Ho bisogno di fare qualcosa di simile:

#include<stdio.h> 
int myVariable = 50; 
void myFunction() 
{ 
    int myVariable; 
    myVariable /*global*/ = myVariable /*local*/; 
} 

C'è qualche modo in C per farlo (senza l'utilizzo di variabili temporanee (o puntatori in caso di array))? Ho trovato che è possibile in C++, Java o C# utilizzando parole chiave come questa, super, di base, ecc, ma non riusciva a trovare una soluzione in C.

Ho già accennato al How can I access a shadowed global variable in C?

Answer 1

In C99 non è possibile specificare l'ambito specifico della variabile/costante che si desidera utilizzare. Si riferirà automaticamente all'ambito più interno quando si fa riferimento a una variabile/costante.

Dalla C99 standard di 6.2.1.4:

... Se un identificatore designa due entità diverse nello stesso spazio dei nomi, gli scopi potrebbero sovrapporsi. In tal caso, l'ambito di una entità (l'ambito interno) sarà un sottoinsieme rigoroso dell'ambito dell'altra entità (l'ambito esterno). All'interno dell'ambito interno, l'identificatore designa l'entità dichiarata nello scope interno; l'entità dichiarata nello scope esterno è nascosta (e non visibile) all'interno dell'ambito interno ...

Quindi, come potrei aggirare questo?

Semplice, cambiare il nome della variabile ambito più interno :)

Answer 2

Che cosa si sta facendo sta "oscurando" la variabile globale. Per cancellarlo in un blocco locale, dichiararlo nel suo blocco annidato con extern.

void myFunction() 
{ 

    int myVariable 
    { 
    extern int myVarible; 
    //modify myVariable global here; 

    } 
    //modify myVariable localhere 
} 

Answer 3

Does un conteggio struct come un'altra variabile?

#include<stdio.h> 

struct Global { 
    int myVariable; 
} g; 

void myFunction() 
{ 
    int myVariable = 50; 
    g.myVariable /*global*/ = myVariable /*local*/; 
} 

Questo dovrebbe fare qualcosa come chiedi informazioni.

Answer 4

1) utilizzare il valore restituito:

#include<stdio.h> 
int myVariable = 50; 

int myFunction1() 
{ 
    int myVariable; 
    return myVariable; 
} 

2) utilizzare un puntatore:

void myFunction2(int * pp) 
{ 
    int myVariable; 
    *pp = myVariable; 
} 

utilizzati:

int main(void) { 

myVariable = myFunction1(); 

/* or ... */ 
myFunction2 (&myVariable); 

return 0; 
} 

}

Answer 5

Questo è orribile, ma in GNU C, puoi farlo con:

* ({ extern int myVariable; &myVariable; }) = myVariable; 

Vieni a pensarci bene, che potrebbe servire in serie C con una funzione di supporto:

static int * GlobalMyVariable(void) { return &myVariable; } 
… 
*GlobalMyVariable() = myVariable; 

Naturalmente, è chiesto alcun variabili temporanee, e questo non usa una variabile temporanea, ma lo fa, a prima vista, aggiungi "cose" al tuo eseguibile. Tuttavia, ho compilato un semplice utilizzo di questo con l'ottimizzazione, e la funzione helper è completamente scomparsa nel codice di assembly generato. Quindi non significa nessun codice o dati aggiuntivi, quando il compilatore si ottimizza correttamente.

Answer 6

Aggiungere un puntatore int costante globale.

OP: Come copiare la variabile locale sulla variabile globale se entrambi hanno gli stessi nomi di matrice in C senza utilizzare una terza variabile?
Ho barato e non sto usando una terza variabile ma una costante. (mi sono intrufolato nella porta?)

OP: senza prima assegnare il valore della variabile globale a una variabile temporanea (utilizzando extern) e quindi assegnando la variabile temporanea alla variabile globale?
Appare passare questo test - nessuna variabile temporanea utilizzata.

OP: in qualche modo in C per farlo (senza utilizzare variabili temporanee (o puntatori nel caso di matrici))?
Beh, non usare un temporaneo, dato che i globals sono permanenti. E non sta usando un puntatore tramite un array. è utilizzando un puntatore.

int myVariable = 50; 
int *const myVariableAddress = &myVariable; 

void myFunction() { 
    // Could be here instead with 
    // static int *const myVariableAddress = &myVariable; 
    { 
    int myVariable; 
    *myVariableAddress = myVariable /*local*/; 
    } 
} 

Answer 7

questo funziona, ma il codice deve essere in un oggetto condiviso, o il programma deve essere compilato in un modo che lascia l'eseguibile vedere i propri simboli globali (nel GCC, si utilizza il flag -rdynamic) :

int myVariable = 50; 

void myFunction() { 
    int myVariable = 10; 
    *(int *)dlsym(0, "myVariable") = myVariable; 
} 

Answer 8

::myGlobal = myLocal 

Questo dovrebbe essere in grado di accedere alla variabile dal campo di applicazione globale.