Wstecz: 7.3 Klasy pamięci W górę: 7. Zmienne Dalej: 7.5 L-wartości

---

• 7.4.1 Zmienne ulotne
• 7.4.2 Stałe

7.4 Modyfikatory typów

Modyfikatory volatile i  const są tzw. modyfikatorami typu (ang. type qualifier): nie wpływają na sposób przydziału pamięci czy linkowania, ale zmieniają typ deklarowanej zmiennej (choć reprezentacja bitowa pozostaje taka sama).

7.4.1 Zmienne ulotne

Zmienne ulotne deklarowane są z modyfikatorem volatile, np.:

       volatile double x;

Stosowanie volatile rzadko bywa potrzebne w „normalnych” programach. Pamiętać też warto, że nieuzasadnione deklarowanie zmiennych jako ulotnych obniża wydajność programu: utrudnia kompilatorowi optymalizację i powoduje narzuty czasowe podczas wykonania.

Nie jest również prawdą, że używanie zmiennych ulotnych przydaje się przy pisaniu programów wielowątkowych, bowiem szczegóły ich użycia są (i mają prawo być) zależne od implementacji i jako takie są nieprzenośne.

7.4.2 Stałe

Stałe (zmienne ustalone) są używane często i w wielu kontekstach.

Zmienną każdego typu, zarówno „zwykłego”, jak i wskaźnikowego, można ustalić deklarując ją z modyfikatorem typu const przed lub za nazwą typu.

Jedynym sposobem na nadanie stałej jej wartości jest inicjalizacja podczas jej definiowania, bezpośrednio w instrukcji deklaracyjnej:

       const double PI = 3.1415926536;

       const double PI;
       PI = 3.1415926536; // NIE !!!

Niektóre stałe mogą mieć nadane wartości już na etapie kompilacji. Aby tak było, stała musi być zainicjowana wyrażeniem, którego wartość może być obliczona na etapie kompilacji, a więc składającego się z literałów, innych stałych wyliczalnych na etapie kompilacji i prostych operacji arytmetycznych na liczbach całkowitych. Inne stałe wyliczane są dopiero podczas wykonania.

       #include <cmath>
       // ...
       const double x1 = 2*11;
       const double x2 = x1 / 5.0;
       const double x3 = sin(x2);

Zmienna zadeklarowana jako stała ma inny typ niż zmienna nieustalona. Tak więc typem zmiennej x1 z poprzedniego przykładu jest nie double, ale const double — są to różne typy. Na przykład poniższy fragment jest nielegalny

       const int i = 25;
       int *pi = &i; // NIE !!!

Przypisanie odwrotne jednak jest legalne: można do wskaźnika do ustalonej zmiennej przypisać adres zmiennej nieustalonej. Takie zachowanie jest korzystne i często się stosuje przy przekazywaniu argumentów wskaźnikowych do funkcji: wysyłamy do funkcji adres zmiennej nieustalonej, ale odpowiednim parametrem funkcji jest wskaźnik do stałej. Zapobiega to przypadkowym zmianom wartości zmiennej wewnątrz funkcji. W następującym przykładzie

      1.  #include <iostream>
      2.  using namespace std;
      3.  
      4.  int fun(const int * pi) {
      5.      //*pi = 2 * (*pi); // NIE !!!
      6.      return *pi;
      7.  }
      8.  
      9.  int main() {
     10.      int i = 2;
     11.      int res = fun(&i);                ➊
     12.      cout << "res = " << res << endl;
     13.  }

wykomentowana linia byłaby nielegalna. Do funkcji posłaliśmy co prawda adres zwykłej zmiennej typu int (➊), ale funkcja o tym nie wie; parametr zadeklarowany jest jako const int*, więc kompilator nie zgodzi się na zmianę wartości zmiennej wskazywanej przez pi. Tak więc wewnątrz funkcji zmienna skojarzona z parametrem typu ustalonego jest traktowana jako stała niezależnie od tego czy odpowiedni argument wywołania był czy nie był ustalony.

Z drugiej strony, takie zachowanie może prowadzić do pewnych niejasności. Na przykład w programie

      1.  #include <iostream>
      2.  using namespace std;
      3.  
      4.  int main() {
      5.      int i = 2;
      6.      const int *pi = &i;                ➊
      7.  
      8.      i = 2*i;                           ➋
      9.      cout << "  i = " <<   i << endl;
     10.      cout << "*pi = " << *pi << endl;
     11.      //*pi = -1;
     12.  }

zmienna i nie jest ustalona. Ale pi (linia ➊) jest wskaźnikiem typu const int*, czyli zmienna wskazywana przez pi jest traktowana jako ustalona. Tą zmienną wskazywaną jest ta sama zmienna i. Czy zatem i jest, czy nie jest ustalona? Otóż jest, jeśli odwołujemy się do niej poprzez wskaźnik pi — dlatego wykomentowana ostatnia linia jest nielegalna. Z drugiej strony, jeśli odwołujemy się do tej samej zmiennej poprzez nazwę i, to wartość tej zmiennej możemy zmienić (linia ➋), bo ta zmienna wcale nie była zadeklarowana jako stała. Dlatego program jest prawidłowy i drukuje

      i = 4
    *pi = 4

Pewnej uwagi wymaga staranne rozróżnianie wskaźników do stałych od stałych wskaźników. W przykładach, które rozpatrywaliśmy, to wskazywana zmienna była ustalona, a nie wskaźnik. Zatem to wartości wskazywanej zmiennej nie można było zmienić; nic nie stało jednak na przeszkodzie, aby zmienić wartość wskaźnika, czyli zapisany w nim adres. Ilustruje to następujący przykład:

      1.  #include <iostream>
      2.  using namespace std;
      3.  
      4.  int main() {
      5.      const int i = 2, j = 3;
      6.  
      7.      const int *p = &i;              ➊
      8.      cout << "*p = " << *p << endl;
      9.  
     10.      p = &j;
     11.      cout << "*p = " << *p << endl;
     12.  }

Obie zmienne i oraz j są ustalone. Wskaźnik p jest wskaźnikiem do stałej. Natomiast sam wskaźnik nie jest ustalony, a więc może wskazywać zarówno na i jak i na j — jego wartość (przechowywany adres) w trakcie wykonywania programu zmienia się. Zauważmy, że w linii ➊ nie była wcale potrzebna inicjalizacja: linia ta definiuje wskaźnik, a ten ustalony nie jest.

Można jednak ustalić wskaźnik. Modyfikator const stawiamy wówczas za znakiem gwiazdki. A zatem

       const int *pi;

       int const *pi;

       int i;
       int *const pi = &i;

Rozpatrzmy następujący program, ilustrujący dotychczasową dyskusję (program ten jest błędny i nie kompiluje się!):

      1.  #include <iostream>
      2.  using namespace std;
      3.  
      4.  int main() {
      5.      int *p, k = 5, m = 7;
      6.  
      7.      const int stala = 3;       // stała
      8.      const int *q = &k;         // q - wskaźnik na stałą
      9.      int *const r = &k;         // r - stały wskaźnik
     10.      const int tab[] = {1,2,3}; // tablica stałych
     11.  
     12.      p = &stala;    ➊
     13.      stala = 1;     ➋
     14.      *q = m;        ➌
     15.      q = &m;        ➍
     16.      r = &m;        ➎
     17.      k = 10;        ➏
     18.      tab[1] = 9;    ➐
     19.  }

Przeanalizujmy poszczególne fragmenty:

• Linia ➊ jest nielegalna, bo p ma typ int*, a  &stala ma typ wskaźnik do stałej (const int*).
• Linia ➋ to próba zmiany wartości zmiennej ustalonej —  oczywiście nielegalna.
• Linia ➌ to próba zmiany wartości zmiennej, co prawda nieustalonej (q wskazuje na k) ale poprzez odwołanie się do tej zmiennej za pomocą wskaźnika zadeklarowanego jako wskaźnik do stałej.
• Linia ➍: choć q jest wskaźnikiem na stałą, to sam wskaźnik nie jest ustalony: zatem jego zawartość możemy zmienić.
• Linia ➎ jest nielegalna, gdyż r jest ustalonym wskaźnikiem i wskazuje na zmienną k. Tego wskazania zmienić nie można.
• Linia ➏ jest legalna: r jest ustalone i cały czas wskazuje na k, ale samą zmienną k można zmienić, gdyż nie jest stałą.
• Linia ➐: tab[1] jest stałą, bo jest elementem tablicy stałych — nie może być zmienione.

Można też posługiwać się ustalonym wskaźnikiem do stałej:

       int i;
       const int *const pi = &i;

      1.  #include <iostream>
      2.  using namespace std;
      3.  
      4.  int main() {
      5.      int i = 1, m = 2;
      6.      const int *const pi = &i;
      7.  
      8.      cout << "Przed *pi = " << *pi << endl;
      9.      i = 3;                                     ➊
     10.      cout << "Po    *pi = " << *pi << endl;
     11.  
     12.      *pi = 4; // NIE: pi jest wskaźnikiem do stałej
     13.      pi = &m; // NIE: pi jest ustalonym wskaźnikiem
     14.  }

można zmienić wartość zmiennej i odwołując się do niej poprzez nazwę i, gdyż nie jest to stała (linia➊). Natomiast nie jest legalna ani próba zmiany tej samej wartości poprzez odwołanie się do niej za pomocą wskaźnika pi, ani próba zmiany wskazania (adresu) w zmiennej pi (dwie ostatnie linie).

W nowym standardzie C++11 istnieje „silniejsza” wersja określenia stałości — zamiast const używamy przy definiowaniu zmiennej słowa kluczowego constexpr. Znaczy to, że definiujemy coś (wartość całkowitą, zmiennoprzecinkową, obiektową), czego wartość musi dać się obliczyć już na etapie kompilacji. Obliczana wartość może zależeć od wartości literałów, ale też od wartości innych zmiennych, jeśli również są wyrażeniami stałymi (constexpr). Kompilator sprawdzi, czy rzeczywiście potrafi taką wartość wyliczyć i zgłosi błąd, jeśli jest to niemożliwe. W poniższym przykładzie

      1.  #include <iostream>
      2.  using namespace std;
      3.  
      4.  int main() {
      5.      constexpr int hourfee = 7;
      6.      constexpr int tim = 5;
      7.  
      8.      int arr[10 + (tim-1)*hourfee];       ➊
      9.  
     10.      cout << "number of elements in arr "
     11.           << sizeof(arr)/sizeof(arr[0]) << endl;
     12.  }

wyrażenie użyte do wymiarowania definiowanej tablicy jest stałą kompilacji i rzeczywiście jest obliczane na etapie kompilacji — w przeciwnym przypadku program nie skompilowałby się, bo wymiar definiowanej tablicy statycznej musi być znany kompilatorowi (przynajmniej przy kompilacji z opcją '-pedantic').

Zobaczymy w następnych rozdziałach, że wartościami constexpr mogą być też wywołania funkcji, konstrukcje obiektów czy wywołania metod na rzecz obiektów, co było niemożliwe w starym stadardzie.

---

Wstecz: 7.3 Klasy pamięci W górę: 7. Zmienne Dalej: 7.5 L-wartości