Twoje Centrum Szkoleniowe

C++: Zasięg zmiennych oraz czas ich życia

Zasięg zmiennej definiuje, w których częściach kodu ta zmienna jest dostępna i może być używana. Z kolei czas życia zmiennej określa, jak długo dana zmienna istnieje w pamięci podczas wykonywania programu.

 

Zasięg zmiennych w funkcjach

Zasięg zmiennych w funkcjach jest ograniczony do bloku kodu, w którym zostały one zadeklarowane. Oznacza to, że zmienne lokalne, zadeklarowane wewnątrz funkcji, są dostępne i mogą być używane tylko w obrębie tej samej funkcji. Zmienne te nie są widoczne ani dostępne poza funkcją, co zapewnia ochronę danych i pomaga w utrzymaniu porządku w kodzie.

 

Deklaracja wewnątrz funkcji

void mojaFunkcja() {
    int lokalnaZmienna = 5; // Zmienna lokalna dostępna tylko wewnątrz mojaFunkcja
    std::cout << lokalnaZmienna << std::endl;
}

 

Dostępność tylko w obrębie bloku kodu

void innaFunkcja() {
    if (true) {
        int zmiennaWBloku = 10; // Zmienna dostępna tylko wewnątrz tego bloku if
        std::cout << zmiennaWBloku << std::endl;
    }
    // std::cout << zmiennaWBloku; // Błąd: zmiennaWBloku nie jest tu dostępna
}

Kod przedstawia funkcję mojaFunkcja, która deklaruje lokalną zmienną lokalnaZmienna i inicjalizuje ją wartością 5. Zmienna ta jest dostępna tylko w obrębie tej funkcji. 

 

Zmienne lokalne w różnych funkcjach

void funkcjaA() {
    int liczba = 20; // Ta zmienna jest dostępna tylko w funkcjaA
}

void funkcjaB() {
    // std::cout << liczba; // Błąd: zmienna liczba z funkcjiA nie jest tu dostępna
}

 

Tym razem mamy dwie funkcje: funkcjaA i funkcjaB. W funkcjaA, deklarowana jest zmienna lokalna liczba z wartością 20, która jest dostępna tylko w obrębie tej funkcji. W funkcjaB, próba dostępu do zmiennej liczba skutkuje błędem, ponieważ ta zmienna nie jest dostępna poza funkcjaA. Kod ten ilustruje zakres (zasięg) i ograniczenia dostępu do zmiennych lokalnych w C++, gdzie każda zmienna lokalna jest widoczna tylko w obrębie funkcji, w której została zadeklarowana.

 

Zmienne globalne i ich zasięg

Zmienne globalne to te, które są zadeklarowane poza wszystkimi funkcjami, zwykle na początku pliku źródłowego. Ich główną cechą jest dostępność w dowolnym miejscu programu, co oznacza, że mogą być używane i modyfikowane przez każdą funkcję.

 

Deklaracja zmiennej globalnej

Deklarując zmienną globalnie, umieszczasz ją na zewnątrz wszystkich funkcji, zazwyczaj na górze pliku źródłowego.

int globalnaZmienna = 10; // Zmienna globalna dostępna w całym programie

 

Dostęp do zmiennej globalnej z różnych funkcji

void zmienGlobalna() {
    globalnaZmienna = 20; // Modyfikacja zmiennej globalnej
}

void wypiszGlobalna() {
    std::cout << globalnaZmienna << std::endl; // Odczyt zmiennej globalnej
}

 

Wady i zalety korzystania ze zmiennych globalnych

• Zalety: Łatwość dostępu z różnych części programu, zachowanie stanu między wywołaniami funkcji.
• Wady: Potencjalne problemy z bezpieczeństwem (np. niekontrolowane modyfikacje), trudności z debugowaniem, utrudnione testowanie, ryzyko kolizji nazw.

 

Statyczne zmienne lokalne

Statyczne zmienne lokalne to specjalny rodzaj zmiennych lokalnych, które zachowują swoją wartość między wywołaniami funkcji. Są one inicjowane tylko raz, przy pierwszym wywołaniu funkcji, a następnie zachowują swoją wartość przez resztę czasu życia programu.

 

Inicjalizacja i zachowanie zmiennych statycznych

void licznik() {
    static int liczbaWywolan = 0; // statyczna zmienna lokalna
    liczbaWywolan++; // zwiększa licznik przy każdym wywołaniu funkcji
    cout << "Liczba wywołań: " << liczbaWywolan << endl;
}

 

Funkcja licznik jest przykładem funkcji wykorzystującej statyczną zmienną lokalną do śledzenia liczby swoich wywołań. Zmienna całkowitoliczbowa jest zmienną statyczną, inicjalizowana, to jest tworzona, jest tylko raz, niezależnie od liczby wywołań funkcji.

Poniżej zobaczmy przykład wykorzystania tej funkcji.

 

Zachowanie między wywołaniami funkcji

#include <iostream>
using namespace std;

void licznik() {
    static int liczbaWywolan = 0; 
    liczbaWywolan++; 
    cout << "Liczba wywołań: " << liczbaWywolan << endl;
}

int main() {

    licznik(); // Liczba wywołań: 1
    licznik(); // Liczba wywołań: 2
    licznik(); // Liczba wywołań: 3

    return 0;
}

 

W tym przykładzie, każde wywołanie funkcji licznik zwiększa wartość zmiennej liczbaWywolan o 1. Ponieważ liczbaWywolan jest zmienną statyczną, jej wartość jest zachowana pomiędzy wywołaniami funkcji, dzięki czemu każde kolejne wywołanie odzwierciedla całkowitą liczbę jej dotychczasowych wywołań.

 

Zobaczmy co dzieje się w naszym programie krok po kroku:

1. Pierwsze Wywołanie Funkcji:

   • Gdy funkcja licznik jest wywoływana po raz pierwszy, wykonuje się instrukcja static int liczbaWywolan = 0;.
   • Słowo kluczowe static sprawia, że zmienna liczbaWywolan jest inicjalizowana tylko raz, niezależnie od liczby wywołań funkcji.
   • Zmienna liczbaWywolan jest inicjalizowana wartością 0 i przechowywana w pamięci statycznej (nie na stosie funkcji).
   • Następnie, liczbaWywolan jest zwiększana o 1 (liczbaWywolan++), więc jej wartość staje się 1.
   • Wyświetlany jest komunikat: "Liczba wywołań: 1".

2. Drugie Wywołanie Funkcji:

   • Przy drugim wywołaniu licznik, instrukcja static int liczbaWywolan = 0; jest pomijana, ponieważ zmienna statyczna już istnieje i została zainicjalizowana podczas pierwszego wywołania.
   • Zmienna liczbaWywolan zachowuje swoją wartość między wywołaniami, więc nadal ma wartość 1.
   • Następnie wartość liczbaWywolan jest znowu zwiększana o 1, co daje wartość 2.
   • Wyświetlany jest komunikat: "Liczba wywołań: 2".

3. Trzecie Wywołanie Funkcji i Kolejne:

   • Każde kolejne wywołanie funkcji licznik powtarza kroki z drugiego wywołania.
   • Instrukcja deklaracji zmiennej statycznej jest ponownie pomijana, ponieważ zmienna już istnieje i ma określoną wartość.
   • Wartość zmiennej liczbaWywolan jest zwiększana o 1 za każdym razem, kiedy funkcja jest wywoływana.
   • Wartość zmiennej jest wyświetlana, pokazując, ile razy funkcja została dotąd wywołana.