local variable

Angol

Főnév

local variable (tsz. local variables)

1. (informatika) A lokális változó (angolul: local variable) egy olyan változó a C++ programozási nyelvben, amely egy adott blokkhoz vagy függvényhez tartozik, és csak azon belül érhető el. Ez azt jelenti, hogy a változó élettartama és láthatósága korlátozott arra a helyre, ahol deklarálták.

1. Lokális változó deklarációja

A lokális változókat általában egy függvényen vagy kódrészleten belül hozzuk létre:

#include <iostream>

void myFunction() {
    int x = 10; // Lokális változó
    std::cout << "x értéke: " << x << std::endl;
}

int main() {
    myFunction();
    // std::cout << x; // HIBA! Az 'x' változó nem létezik itt
    return 0;
}

Ebben a példában az x változó csak a myFunction() függvényen belül létezik. Amint a függvény befejezi a futását, az x változó megszűnik.

2. Élettartam és hatókör (scope)

A lokális változók élettartama az adott blokk (legtöbbször egy függvény vagy ciklus) végéig tart. A hatókör (scope) határozza meg, hogy egy változó honnan érhető el.

void example() {
    int a = 5; // a csak ebben a függvényben létezik

    if (true) {
        int b = 10; // b csak ebben az if-blokkban létezik
        std::cout << "b: " << b << std::endl;
    }
    // std::cout << b; // HIBA! 'b' kívül van a hatókörén
}

3. Árnyékolás (Shadowing)

Ha egy belső blokkban újra deklarálunk egy változót azonos névvel, az a külső változót “elfedi”:

void shadowingExample() {
    int x = 100;

    {
        int x = 50; // Árnyékolja a külső x változót
        std::cout << "Belső x: " << x << std::endl;
    }

    std::cout << "Külső x: " << x << std::endl;
}

Kimenet:

Belső x: 50
Külső x: 100

4. Automatikus változók és a auto kulcsszó

Minden lokális változó alapértelmezés szerint automatikus változó (azaz auto tárolási osztályú). Az auto kulcsszó lehetővé teszi a változó típusának automatikus meghatározását:

void autoExample() {
    auto x = 3.14; // x típusa double
    auto y = 42;   // y típusa int
    std::cout << x << ", " << y << std::endl;
}

5. Statikus lokális változók (static)

A static kulcsszóval deklarált lokális változók megőrzik az értéküket a függvényhívások között:

void staticExample() {
    static int counter = 0; // Értéke megmarad minden hívás után
    counter++;
    std::cout << "Hívások száma: " << counter << std::endl;
}

int main() {
    staticExample();
    staticExample();
    staticExample();
    return 0;
}

Kimenet:

Hívások száma: 1
Hívások száma: 2
Hívások száma: 3

6. Lokális változók memóriaterülete

A C++ program memóriájában a lokális változók általában a veremben (stack) tárolódnak. Mivel a verem egy gyorsan növekvő és csökkenő memória, a változók automatikusan törlődnek, amikor a hatókörükből kilépünk.

Ezzel szemben a static változók és a globális változók a data szegmensben vannak tárolva, míg a dinamikusan foglalt memória a heapen helyezkedik el.

7. Lokális változók és függvényparaméterek

A függvények paraméterei szintén lokális változók, és a függvényen belül érhetők el:

void printSum(int a, int b) { // 'a' és 'b' lokális változók
    int sum = a + b;
    std::cout << "Összeg: " << sum << std::endl;
}

A printSum(5, 7); meghíváskor az a = 5 és b = 7 lokálisan létrejön, majd a függvény végén megszűnik.

8. Lokális változók inicializálása

A lokális változókat mindig inicializálni kell, különben a tartalmuk nem definiált:

void uninitializedExample() {
    int x; // Nincs inicializálva!
    std::cout << x << std::endl; // Véletlenszerű érték!
}

Ezért mindig adjunk kezdőértéket:

void initializedExample() {
    int x = 0; // Biztonságos inicializálás
    std::cout << x << std::endl;
}

9. Lokális változók és const

A const kulcsszóval megakadályozhatjuk a változó módosítását:

void constExample() {
    const int value = 10;
    // value = 20; // HIBA! A const változó nem módosítható
    std::cout << value << std::endl;
}

10. Lokális változók előnyei

• Gyors hozzáférés: A verem nagyon gyorsan működik.
• Memóriahatékonyság: A változók csak akkor léteznek, amikor szükség van rájuk.
• Adatok izolálása: Nem befolyásolják a program más részeit.

Összegzés

A lokális változók fontos szerepet játszanak a C++ programokban. Hatékonyan kezelik az adatokat, segítenek elkerülni a globális változók által okozott problémákat, és garantálják a kód modularitását. Mindig figyeljünk az élettartamukra, inicializálásukra és az esetleges árnyékolásra!

További információk

• local variable - Szótár.net (en-hu)
• local variable - Sztaki (en-hu)
• local variable - Merriam–Webster
• local variable - Cambridge
• local variable - WordNet
• local variable - Яндекс (en-ru)
• local variable - Google (en-hu)
• local variable - Wikidata
• local variable - Wikipédia (angol)