C-ben a változók hatóköre alatt azt a kódrészletet értjük, amelyben az adott változó elérhető, használható. Ez a hatókör attól függ, hol definiáljuk az adott változót. Ennek függvényében 3 változótípust különböztethetünk meg:

• helyi változók: egy adott függvényen vagy kódblokkon belül definiált változók
• paraméterek: egy függvény paraméterlistájában meghatározott változók
• globális változók: minden függvényen kívül megadott változó

Helyi változók

Más néven lokális változók. Egy függvényen vagy kódblokkon belül definiáljuk, elérhetősége is ezen kódrészletre korlátozódik. Amint a program futása túlhalad ezen a kódrészleten, a változó többé már nem elérhető, az általa felhasznált memóriaterület felszabadul. Az így deklarált változók prioritása a legmagasabb. Ha létezik már azonos nevű változó, amit „kijjebb”, magasabb szinten hoztunk létre, az az új létezése alatt a kódból elérhetetlen lesz, az új képletesen fogalmazva kitakarja azt. Fontos, hogy ettől a korábbi változó nem szűnik meg és értéke sem változik! Az adott függvényt / kódrészletet elhagyva a magasabb szinten deklarált változó újra elérhető lesz.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#include <stdio.h>
 
// Itt még nem létezik a változó
 
int main() {
	// Változó deklarálása
	int szam;
 
	// Változó inicializálása (kezdőérték adás)
	szam = 10;
 
	// A függvényen belül vagyunk, használhatjuk
	szam = szam + 3;
	printf ("%d\n", szam);
 
	return 0;
}
 
// Itt már nem létezik a változó

Paraméterek

A függvényen belül mindenhol elérhető, hacsak a fentebb említett módon egy azonos nevű helyi változó el nem fedi. A függvényen kívül nem létezik, nem elérhető. A paraméter számára memóriaterület a függvény meghívásakor foglalódik és a függvény befejeződésekor felszabadul, tartalma elveszik.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#include <stdio.h>
 
// Paraméter deklarálása
void minta (int param) {
	printf ("Parameter: %d\n", param);
}
 
int main() {
	// Itt még nem létezik a paraméter
 
	// Paraméter inicializálása (kezdőérték adás)
	minta (10);
 
	// Itt már nem létezik a paraméter
 
	return 0;
}

Globális változók

Minden függvényen és kódblokkon kívül kerülnek definiálásra és a program futása alatt végig, mindenhol elérhetőek. Természetesen a korábbiakban említetteknek megfelelően időnként más, helyi változók vagy paraméterek kitakarhatják, maszkolhatják őket. Jellemzően a program elején szokták definiálni a globális változókat. Ma már erősen ellenjavallt használatuk, tulajdonképpen programozástechnikai hibaként kezelendő és megfelelő tervezéssel használatuk elkerülhető.1-200 sornál hosszabb kód esetén már nehezen kezelhetővé válik és nagyon időigényesen tárhatók csak fel a globális változók használatából eredő hibák.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#include <stdio.h>
 
// Változó deklarálása
int globalis;
 
void minta() {
	// Függvényen belül is elérhető
	printf ("%d\n", globalis);
 
	// És módosítható is
	globalis += 4;
}
 
int main() {
	// Már itt is létezik a globális változó
 
	// Változó inicializálása (kezdőérték adás)
	globalis = 10;
	minta();
	printf ("%d\n", globalis);
 
	return 0;
}