Funkcje/zmienne statyczne

[admin]

Modyfikator static sprawia, że obiekt w danej funkcji jest umieszczany w tej samej pamięci, co zmienna globalna i nie jest usuwany wraz z zakończeniem funkcji.

int licznik()
{
  static int a;
  a++;
  return a;
}
 

int main()
{
  cout<<"Wywoluje funkcje licznik"<<licznik();
  cout<<"\n...drugi raz "<< licznik();
 
}

Zmienna statyczna nawet lokalna nie jest usuwana. Będzie cały czas pamiętała swoją poprzednią wartość.
Porównaj jak działa zmienna statyczna i dynamiczna

#include <cstdlib>
#include <iostream>

using namespace std;
class drzewo
{public:
      virtual void pien(){cout<<"drzewo"<<endl;}};
class krzaczek :public drzewo
{public: void pien(){cout<<"krzaczek"<<endl;}};
int licznik(){static int a;
a++;
return a;};
int licznik1(){int b;
b++;
return b;}
int main(int argc, char *argv[])
{
cout<<"Wywolanie funkcji licznik "<<licznik()<<endl;
cout<<"Wywolanie drugi raz funkcji licznik "<<licznik()<<endl;

cout<<"Wywolanie funkcji licznik1 "<<licznik1()<<endl;
cout<<"Wywolanie drugi raz funkcji licznik1 "<<licznik1()<<endl;   
system("PAUSE");
    return EXIT_SUCCESS;
}

[admin]

Zmienne statyczne w klasach.
Statyczne pola klasy definiuje sie podobnie do zmiennych lokalnych, poprzez użycie słowa kluczowego static:

class samochod
{
  private:
    // dane opisujace samochód
  public:
    static int predkosc;
};
int samochod::predkosc;

Podobnie jak zmienna statyczna lokalna, statyczne pole klasy jest tworzone tylko raz, w tym samym obszarze co zmienne globalne i cały czas pamięta swoją ostatnią wartość. Pole statyczne jest tworzone zanim zostanie utworzony pierwszy obiekt danej klasy. Zazwyczaj - tworzone są już na samym starcie programu.

Tak jak zmienna lokalna pamięta swoją wartość pomiędzy kolejnymi wywołaniami, tak pole statyczne klasy pamięta swoją wartość "pomiędzy obiektami". Nie ważne z jakiego obiektu się do niego odwołasz, wartość będzie ta sama, wspólna dla wszystkich obiektów.

samochod ford, fiat, volvo;  //stworzenie 3 obiektow
fiat.predkosc = 100;
cout << ford.predkosc << endl;  //wypisze 100
volvo.predkosc = 120;
cout << fiat.predkosc << endl;  //wypisze 120

/////////////////////// ---Cały program---////////////////////////////////////////////////////////////////
#include <cstdlib>
#include <iostream>

using namespace std;

class samochod
{
public:
        static int predkosc;
        };
int samochod::predkosc;
int main(int argc, char *argv[])
{
   
samochod ford, fiat, volvo;
fiat.predkosc=100;
cout<<"ford "<<ford.predkosc<<endl;
volvo.predkosc=120;
cout<<"fiat "<<fiat.predkosc<<endl;

system("PAUSE");
    return EXIT_SUCCESS;
}

///////////////////-- kolejny program pokazujący ,że statyczne zmienne działają tylko dla potomków tylko tej samej klasy --//////////////////////////

#include <cstdlib>
#include <iostream>

using namespace std;

class samochod
{
public:
        static int predkosc;
        };
int samochod::predkosc;
class motor
{
public:
        static int predkosc;
        };
int motor::predkosc;
int main(int argc, char *argv[])
{   
samochod ford, fiat, volvo;
motor nsu, bmw, yamaha;
fiat.predkosc=100;

cout<<"ford "<<ford.predkosc<<endl;
cout<<"nsu "<<nsu.predkosc<<endl;
volvo.predkosc=120;
cout<<"fiat "<<fiat.predkosc<<endl;

system("PAUSE");
    return EXIT_SUCCESS;
}

[admin]

Metody statyczne
Metody statyczne klasy to metody, które są uruchamiane w kontekście danej klasy, tak jak zwykłe metody są uruchamiane w kontekście konkretnego obiektu. Oznacza to, że o ile zwykłe metody potrzebują obiektu do prawidłowego działania, to metody statyczne - można wywołać bez podawania jakiegokolwiek obiektu. Ma to jednak swoją cenę - metody statyczne mają dostęp jedynie do innych zmiennych statycznych i metod statycznych tej klasy.

//....
class rysio
{
  private:
    int a, b;
    static int c;
  public:
    static void dzialaj()
    {
      c=10;
      // b=10;     - błąd! 'b' nie jest statyczne! nie ma do niego dostępu
      // this->a = 10;  - błąd!! w metodach statycznych 'this' nie istnieje!!
    }

this - w C++, słowo kluczowe odnoszące się w niestatycznych metodach klasy do obiektu na rzecz którego dana metoda została wywołana.
Do obiektów odwołujemy się poprzez kropkę lub poprzez -> np.:
inaczej this : słowo kluczowe oznaczające referencję do obiektu, z którego wywołano metodę (inaczej mówiąc – oznacza referencję do samego siebie). Oczywiście nie można używać this wewnątrz metod statycznych (one nie są wywoływane na rzecz obiektu).

class Punkt
{
   int x;
   int y;
  public:
   int kolor;
   void pozx(int xx){x=xx;}
   void pozy(int y){y=yy;}
   void kolor(int kk){kolor=kk;}
};

main(void)
{
   Punkt p1;     //obiekt stworzony statycznie
   p1.kolor=10;      //odwołanie do pola przez kropkę
   p1.pozx(20);   //odwołanie do funkcji przez kropkę

   Punkt *wsk;   //wsk - wskaznik na obiekt klasy TPunkt

    wsk = new Punkt;   //operator new

   wsk->kolor=10;      //odwołanie do pola przez ->
   wsk->pozx(20);   //odwołanie do funkcji przez ->

   delete wsk;   //operator delete
}