[c/c++] differenza tra "auto" e "static"

[Iena87]

Sto studiando la guida al c++ di Shildt, e volendone spulciare di tutto di più da essa, la sto seguendo passo passo, parola dopo parola, e sono arrivato a dei dubbi, o meglio delle precisazioni:
Il libro in ocasione delle variabili locali parla di variabili spesso definitie come automatiche, ma in che senso vengono definite automatiche??? perchè sono automatiche????
Poi continua dicendo che esiste nel C, come nel C++, una parola chiave, auto , che serve per la definizione di vriabili locali, proprio perchè queste devono essere automatiche, ma nn capisco cosa vuol dire "variabile automatica"....continua dicendo che di solito nn è mai utilizzata poichè quasi tute le variabili nn globali sono automatiche........mi potreste far capire cosa intende con automatiche????


Poi sempre riferendosi alle variabili locali, dice che, è questa è cosa normale, non conservano il loro valore tra una chiamata e un'altra, ma è possibile chiedere al compilatore di conservarne il valore attraverso il modificatore static

Ho provato a scrivere qualcosa in C, per accertarmi del funzionamento di static ma nn ho avuto esiti positivi, questo è ciò che ho scritto:

#include <stdio.h>
#include <stdlib.h>
#include <iostream.h>
#include <conio.h>
#include <climits>

void f1(void);
void f2(void);

int main (){
    f1();
    f2();
    getch();
    return 0;
}

void f1(void){
    static int i;
    i=20;
    printf("%d", i);
    i=i-10;
}

void f2(void){
    int i;
    printf("%d", i);
}

Adesso ciò che vi chiedo è se gentilmente mi fareste capire il significato di "variabile automatica", come si usa la parola chiave auto e come static.

Grazie mille in anticipo

[Xadoom]

Per static si indica una variabile di tipo locale che però conserva il suo valore anche all'esterno della porzione di codice in cui è valida, ad esempio:

void funz1(){
 static int var = 0;
 var++;
 cout << var;
}
void funz2(){
 int var = 0;
 var++;
 cout << var;
}

La funzione due ogni volta che è chiamata stampa 0 (la variabile var è creata daccapo ad ogni chiamata della funzione), la funzione1 stampa ogni volta var incrementata di 1 perchè var "ricorda" il suo valore della chiamata precedente.
Spero di essere stato chiaro e, sopratutto, corretto!

[Iena87]

Originariamente inviato da Xadoom
Per static si indica una variabile di tipo locale che però conserva il suo valore anche all'esterno della porzione di codice in cui è valida, ad esempio:

void funz1(){
 static int var = 0;
 var++;
 cout << var;
}
void funz2(){
 int var = 0;
 var++;
 cout << var;
}

La funzione due ogni volta che è chiamata stampa 0 (la variabile var è creata daccapo ad ogni chiamata della funzione), la funzione1 stampa ogni volta var incrementata di 1 perchè var "ricorda" il suo valore della chiamata precedente.
Spero di essere stato chiaro e, sopratutto, corretto!

a dir la verità nn tanto....forse nella spiegazione che mi hai fornito hai confuso la funzione con la due...io cmq da quello che hai scritto vdo che all'inizio nella prima funzione, viene creata la variabile var che è contemporaneamente inizializzata a 0, successivamente incrementata, quindi arriva a 1, e nel momento in cui la visualizziamo, vediamo sullo schermo il valore 1...finisce la pirma funzione e inizia la seconda....viene creata la variabile var, che così facendo dovrebbe avere valore 1, in quanto con static conserva il suo valore anche al di fuori del suo blocco, quindi nella seconda funzione nel momento in cui scriviamo int var si dovrebbe generare una variabile var contenente il valore 1, o almeno questio ho capito, ma azzerandola vale 0, quindi la incrementiamo e nel momento in cui la visualizziamo abbiamo 1.....dove ho sbagliato????

[Luc@s]

static è usato per una var che assomiglia a una globale.
Es

 
struct Es
{
  static unsigned int Es_cnt; // contatore
};
static unsigned int Es::Es_cnt = 0;

Se incrementi la var avra lo stesso valore x tutte le istanze della sruct Es.

Spero di averti chiarito.

P.S: lo shildt è sconsigliatissimo da tutti gli esperti di C/C++

[Xadoom]

No, allora le due funzioni non sono chiamate una dopo l'altra, è solo per farti vedere il diverso comportamento, prova a compilare:

#include <iostream>
#include <stdlib.h>

using namespace std;

void funz1();
void funz2();

int main(int argc, char *argv[])
{
  for(int i=0;i<10;i++)funz1();
  for(int i=0;i<10;i++)funz2();
  system("PAUSE");	
  return 0;
}

void funz1(){
 static int var = 0;
 var++;
 cout << var;
}
void funz2(){
 int var = 0;
 var++;
 cout << var;
}

allora funz1() ti stamperà 1,2,3,...,10 in quanto ogni volta che la chiami la variabile var tiene memoria del valore della chiamata precedente a funz1() (delle chiamate ad altre funzioni non può tenere memoria in quanto è una variabile locale di funz1().
Funz2 ti stamperà sempre 1 in quanto ad ogni chiamata la variabile è reistanziata; c'è da osservare che una variabile di tipo static viene inizializzata solo una volta, la prima volta che viene chiamata la funzione, ecco perchè non si riazzera ogni volta che richiamo la funzione.
Spero ora di aver chiarito meglio.

[LeleFT]

Originariamente inviato da Iena87
a dir la verità nn tanto....forse nella spiegazione che mi hai fornito hai confuso la funzione con la due...io cmq da quello che hai scritto vdo che all'inizio nella prima funzione, viene creata la variabile var che è contemporaneamente inizializzata a 0, successivamente incrementata, quindi arriva a 1, e nel momento in cui la visualizziamo, vediamo sullo schermo il valore 1...finisce la pirma funzione e inizia la seconda....viene creata la variabile var, che così facendo dovrebbe avere valore 1, in quanto con static conserva il suo valore anche al di fuori del suo blocco, quindi nella seconda funzione nel momento in cui scriviamo int var si dovrebbe generare una variabile var contenente il valore 1, o almeno questio ho capito, ma azzerandola vale 0, quindi la incrementiamo e nel momento in cui la visualizziamo abbiamo 1.....dove ho sbagliato????

Xadoom intendeva dire che con chiamate successive alla funzione funz1 la variabile var non perde il suo valore, mentre nella funz2 sì. Ed ha ragione.
Prova questo codice:

#include <iostream>
using namespace std;

void funz1() {
   static int var = 0;
   var++;
   cout << var << endl;
}

void funz2() {
   int var = 0;
   var++;
   cout << var << endl;
}

int main() {
   funz1();
   funz2();
   funz1();
   return 0;
}

L'output è il seguente:

1
1
2

Ciao.

[LeleFT]

Dannata lentezza momentanea intrinseca della rete... :gren:


Ciao.

[Xadoom]

Originariamente inviato da LeleFT
Dannata lentezza momentanea intrinseca della rete... :gren:


Ciao.

:adhone:
Mica è una gara no? :tongue:
Comunque carino....abbiamo scritto praticamente lo stesso codice come esempio!!

[LeleFT]

L'ho notato... infatti sembrava che l'avessi copiato... E' per questo che ho messo l'appunto sulla velocità... :gren:


Ciao.

[Iena87]

Grazie raga provo subito, ma ancora nn mi avete detto che vuol dire variabile automatica, se poi nn ho letto io,pardon



X Luc@s: forse gli esperti lo sconsigliano perchè è Shildt (Ovvimanete dopo Stroustup o come si chiama) il maggiore esperto di C++