A változóknak minden programozási nyelvben döntő szerepük van. A változókat hatókörük alapján globális változókra és lokális változókra osztják. A fő különbség a globális és a lokális változók között az, hogy a globális változók globálisan elérhetők a teljes programban, míg a lokális változók csak azon a függvényen vagy blokkon belül érhetők el, amelyben meghatározásra kerültek. Ebben a témakörben először megértjük, mik a változók és a hatókör, valamint a lokális változók, a globális változók, majd a két változó közötti különbségek.
java tervezési minta
Mi az a változó?
A változó egy olyan név, amelyet egy memóriahelynek adnak, amely értéket tárol egy számítógépes programban. A programban hivatkozható és manipulálható információk tárolására szolgál.
A változónak tetszőleges nevet választhatunk, de ennek követnie kell a programozási szemantikát. Amilyen lehet , a, b, x, y, z, al, oszt, összesen, átlag stb .
Tegyük fel, hogy két értéket, a 10-et és a 20-at szeretnénk tárolni és használni a programunkban. Ehhez változót kell használnunk, és az alábbi lépéseket hajtjuk végre:
- Először létrehozunk vagy deklarálunk egy megfelelő nevű változót.
- Tárolja ezeket az értékeket a változókhoz.
- Miután ezek az értékek tároltak, ezeket a változókat a nevükkel használhatjuk a programunkban.
A fenti képen látható, hogy két memóriahely van, a 001 és a 002, és ezeket a helyeket A és B néven neveztük el. A 10-et, B pedig 20-at tartalmaz.
A különböző programozási nyelvek eltérő módon deklarálják a változót. Például C nyelvben a következő módon deklarálhatjuk a változót:
Szintaxis: (Változó deklarációs szintaxisa C nyelvben)
datatype v1, v2, v3,....;
Példa:
#include void main(){ int a; int b; int sum; } A változó hatóköre
Minden változó definiált és használható a hatókörén belül, és meghatározza, hogy a programban ez a változó elérhető legyen. A hatókör az adott változó élettartamát jelenti. Ez azt jelenti, hogy a változó csak a hatókörén belül érhető el vagy látható.
A változók hatóköre deklarációjukkal definiálható, a változók deklarálása főként kétféleképpen történik:
Mi az a globális változó?
- A globális változók azok a változók, amelyek az összes függvényen vagy blokkon kívül vannak deklarálva, és globálisan elérhetők egy programban.
- A programban található bármely funkcióval elérhető.
- Miután deklaráltunk egy globális változót, az értéke változtatható a különböző függvényekkel.
- A globális változó élettartama a program végrehajtásáig létezik. Ezeket a változókat a fordító által megadott rögzített memóriahelyeken tárolják, és nem törlődnek automatikusan.
- A globális változókat leginkább a programozásban használják, és olyan esetekben hasznosak, amikor az összes funkciónak ugyanazokhoz az adatokhoz kell hozzáférnie.
Példa:
#include int a=50, b=40; void main() { printf('a = %d and b=%d',a,b); } A fenti példában a és b a globális változók.
A globális változó előnyei
- A globális változókat a programban lévő összes függvény elérheti.
- Csak egyetlen nyilatkozat szükséges.
- Nagyon hasznos, ha minden funkció ugyanahhoz az adathoz fér hozzá.
A globális változó hátrányai
- Egy globális változó értéke véletlenül megváltoztatható, mivel a program bármely függvénye használhatja.
- Ha nagyszámú globális változót használunk, akkor nagy az esélye a hibagenerálásnak a programban.
Mi az a lokális változó?
- Ezek a változók csak azon függvényen belül érhetők el, amelyben deklarálva vannak.
- A lokális változó élettartama csak a funkcióján belül van, ami azt jelenti, hogy a változó a függvény végrehajtásáig létezik. A funkció végrehajtása után a helyi változók megsemmisülnek, és a függvényen kívül már nem léteznek.
- A lokális változók korlátozott hatókörének oka, hogy a lokális változókat a veremben tárolják, ami dinamikus természetű, és automatikusan megtisztítja a benne tárolt adatokat.
- De ha a változót statikussá tesszük a 'static' kulcsszóval, megtarthatjuk a lokális változó értékét.
Példa:
#include void main() { int x=50, y=40; printf('x = %d and y=%d',x, y); } A fenti példában x és y két változót deklaráltunk a főfüggvényen belül. Ezért ezek helyi változók.
A helyi változó előnyei
- A helyi változó ugyanazon neve különböző függvényekben használható, mivel csak az a függvény ismeri fel, amelyben deklarálva van.
- A helyi változók csak korlátozott ideig használják a memóriát, amikor a függvény végrehajtódik; után ugyanaz a memóriahely újra felhasználható.
A lokális változók hátrányai
- A helyi változó hatóköre csak a funkciójára korlátozódik, és más függvények nem használhatják.
- A helyi változó általi adatmegosztás nem engedélyezett.
Összehasonlító táblázat a globális változó és a helyi változó között
| Globális változó | Helyi változó |
|---|---|
| A globális változókat az összes funkcióblokkon kívül deklarálják. | A helyi változókat egy funkcióblokkon belül deklarálják. |
| A hatókör az egész program alatt megmarad. | A hatókör korlátozott, és csak azon a funkción belül marad, amelyben deklarálva vannak. |
| A globális változó bármilyen változása az egész programot érinti, bárhol is használják. | A helyi változó bármilyen változása nem érinti a program egyéb funkcióit. |
| Egy globális változó létezik a programban a program végrehajtásának teljes ideje alatt. | A függvény végrehajtásakor helyi változó jön létre, és a végrehajtás befejezése után a változó megsemmisül. |
| A programban található összes funkcióval elérhető az egész programban. | Csak azokkal a függvényutasításokkal érhető el, amelyekben deklarálva van, a többi függvénytől nem. |
| Ha a globális változó nincs inicializálva, akkor alapértelmezés szerint nullát vesz fel. | Ha a helyi változó nincs inicializálva, akkor alapértelmezés szerint a szemét értéket veszi fel. |
| A globális változókat a memória adatszegmensében tárolják. | A helyi változók a memóriában egy veremben tárolódnak. |
| Nem deklarálhatunk sok változót azonos névvel. | Különféle változókat deklarálhatunk azonos néven, de más függvényekben. |
Példák a helyi és a globális változó közötti különbségek megértésére
Most nézzünk meg példákat különböző programozási nyelveken, hogy jobban megértsük a különbséget a helyi és a globális változók között.
Local vs Global in C
1. példa:
#include // Global variables int a; int b; int Add() { return a + b; } int Mul() { int c=10; //Local Variable int d=20; ////Local Variable return c*d; } void main() { int Ans1, Ans2, c=30;// Local variable a = 50; b = 70; Ans1 = Add(); Ans2= Mul(); printf('The addition result is: %d
',Ans1); printf('The Multiplication result is: %d
',Ans2); printf('%d
', c); } Kimenet:
The addition result is: 120 The Multiplication result is: 200 30
Ahogy a fenti programban is láthatjuk, megtettük a és b globális változók, amelyekhez különböző függvények, például Add() és main() érhetők el. Míg vannak olyan lokális változók is, mint a c, d, Ans1 és Ans2, amelyekhez csak azok a függvények férnek hozzá, amelyekben deklarálva vannak.
Ha a c és d változókat a Mul() függvényen kívül próbáljuk használni, akkor ezek új változóként kerülnek felhasználásra. Ahogy azt a main() függvénybe is bevéve c-t mutattuk, új változóként kezeljük.
udp protokoll
Helyi vs. Globális Pythonban
1. példa:
v1 = 'Hey, I am Global Variable!, I can be used everywhere in the program.' #globalvariable def func1(): v2='Hey, I am Local Variable!, I can be used within this block only in the program.' #localvariable print(v2) func1() #calling func1 def func2(): print(v1) func2() #callin func2
Kimenet:
Hey, I am a Local Variable!, I can be used within this block only in the program. Hey, I am Global Variable!, I can be used everywhere in the program.
A fenti programban egy v1 globális és egy v2 lokális változót vettünk fel. Mivel a v1 globális, könnyen elérhető bármely függvényben, a v2 pedig lokális; csak a deklarált funkcióján belül használható. De ha megpróbáljuk a v1-et használni a func1-ben, az hibát ad. Lássuk az alábbi példát:
Példa-2
v1 = 'Hey, I am Global Variable!, I can be used everywhere in the program.' #globalvariable def func1(): v2='Hey, I am Local Variable!, I can be used within this block only in the program.' #localvariable print(v2) print(v1) func1() #calling func1 def func2(): print(v1) print(v2) func2() #callin func2
Ha megpróbáljuk elérni a v1-et, könnyen elérhető fun1-ben és func2-ben. De ha a v2-t a funkcióján kívül próbáljuk elérni, ami azt jelenti, hogy func2-ben, az futásidejű hibát ad. A fenti kód végrehajtása után az alábbi kimenetet kapjuk:
Futtatási hiba:
NameError: global name 'v2' is not defined
Kimenet:
Hey, I am Local Variable!, I can be used within this block only in the program. Hey, I am Global Variable!, I can be used everywhere in the program. Hey, I am Global Variable!, I can be used everywhere in the program.
Helyi vs. Globális változó a Java nyelven
A Java-ban nincs fogalma a globális változóknak; mivel a Java egy objektum-orientált programozási nyelv, minden az osztály része. De ha egy változót globálisan elérhetővé akarunk tenni, akkor az a segítségével statikussá tehetjük statikus Kulcsszó.
class Demo { // static variable static int a = 10; // non-static or local variable int b = 20; } public class Main { public static void main(String[] args) { Demo obj = new Demo(); // accessing the non-static variable System.out.println('Value of non-static variable is: ' + (obj.b)); // accessing the static variable System.out.println('Value of static variable is:' + (Demo.a)); } } Kimenet:
Value of non-static variable is: 20 Value of static variable is:10
A fenti programban egy helyi változót vagy nem statikus változót és egy statikus változót használtunk. A helyi változó a Demo osztály objektumával, míg a statikus változó az osztály nevével érhető el.