Phenquestions
Egy objektum létrehozásához időre van szükség. Némi időre van szükség egy tárgy megöléséhez. Amikor egy objektumról beszélünk, két dolog vesz részt: a hely, amely a tároló, és az érték. Az élettartam és a tárolási idő jelentése hasonló; de az időtartam inkább a helyszín, mint az érték szempontjából látható. A tárolási időtartam az az idő, amely a hely társításától egy objektumig terjed, és az az idő, amikor a hely elszakad az objektumtól.
A cikk további része bemutatja az objektum élettartamát, és röviden ismerteti a különböző tárolási időtartamokat. A cikk megértéséhez rendelkeznie kell alapvető ismeretekkel C ++ nyelven. A C ++ hatókörében is rendelkeznie kell ismeretekkel.
A cikk tartalma
- Az objektum élettartamának illusztrációja
- Tárolási időtartam
- Automatikus tárolási időtartam
- Dinamikus tárolási idő
- Statikus tárolási idő
- Menet tárolási időtartama
- Következtetés
Az objektum élettartamának illusztrációja
Fontolja meg a következő programot:
#includenévtér használata std;
int main ()
ha (1 == 1)
int x;
x = 1;
char y;
y = 'A';
cout << x << y << '\n';
visszatér 0;
A kimenet 1A .
Egy tárgy élete akkor ér véget, amikor kilép a hatóköréből. Az x objektum élettartama „x = 1;” -nél kezdődik. és az if-local-hatókör végén ér véget. Az y objektum élettartama „y =„ A ”;” -nél kezdődik. és az if-local-hatókör végén ér véget. Mielőtt mindkét objektum meghal, alkalmazzák őket a cout utasításban .
Tárolási időtartam
A tárolási időtartamot a következő sémák valamelyike határozza meg: automatikus tárolási időtartam; dinamikus tárolási időtartam; statikus tárolási időtartam; szál tárolási időtartama. A tárolási időtartam kategóriái vonatkoznak a hivatkozásokra is.
Automatikus tárolási időtartam
Ha egy változó nincs kifejezetten statikus, thread_local vagy extern néven deklarálva, akkor ennek a változónak automatikus tárolási időtartama van. Ilyen például a fenti x és y. Az ilyen változók időtartama akkor ér véget, amikor kilépnek a hatókörből. A következő program szemlélteti a referencia és egy mutató automatikus tárolási időtartamát globális terjedelemben.
#includenévtér használata std;
int x = 1;
int & m = x;
char y = 'A';
char * n = & y;
int main ()
cout << m << *n << '\n';
visszatér 0;
A kimenet 1A .
M időtartama „int & m = x;” -től kezdődik és a program végén ér véget. N időtartama a „char * n = & y;” értéktől kezdődik és a program végén ér véget.
Dinamikus tárolási idő
Ingyenes áruház
Egy modern számítógépben több program is futhat egyszerre. Minden programnak megvan a maga memóriarésze. A memória többi részét, amelyet egyetlen program sem használ, szabad tárolónak nevezzük. A következő kifejezés egy egész szám helyének visszaadására szolgál a szabad tárolóból
új intAz egész számnak ezt a helyét (tárhelyét) vissza kell adni, még mindig egy mutatóhoz való hozzárendeléssel kell meghatározni. Az alábbi kód bemutatja, hogyan kell használni a mutatót az ingyenes tárolással:
int * ptrInt = új int;* ptrInt = 12;
cout<< *ptrInt <<'\n';
A kimenet 12 .
Az objektum életének befejezéséhez használja a törlés kifejezést az alábbiak szerint:
ptrInt törlése;Az argumentum a kifejezés törlésére mutató. A következő kód szemlélteti használatát:
int * ptrInt = új int;* ptrInt = 12;
ptrInt törlése;
Az új kifejezéssel létrehozott és a törlés kifejezéssel törölt mutató dinamikus tárolási időtartamú. Ez a mutató elhal, amikor kilép a hatókörből, vagy törlődik. Az objektum időtartama az előző kódban „* ptrInt = 12;” -nél kezdődik. és a deklaratív régió végén ér véget (hatókör). Az új és a törlendő kifejezéseknél többről van szó, mint amit itt tárgyaltunk - lásd később.
Statikus tárolási idő
Statikus objektum
A statikusnak nyilvánított objektum a szokásos objektumhoz hasonlóan viselkedik, azzal a különbséggel, hogy a tárolási időtartama az inicializálástól a program végéig kezdődik. Nem tekinthető a hatályán kívül, de közvetve alkalmazási körén kívül is alkalmazható.
Vegye figyelembe a következő programot, amelynek állítólag 1-től 5-ig kell számolnia (ne tesztelje a programot):
#includenévtér használata std;
int fn ()
int stc = 1;
cout << " << stc;
stc = stc + 1;
ha (stc> 5)
visszatér 0;
fn ();
int main ()
fn ();
visszatér 0;
A kimenet 1 1 1 1 1 1 1 1 1 ... és soha nem ér véget. A függvénydefiníció visszatérő függvény; vagyis folyamatosan hívja magát, amíg egy feltétel nem teljesül.
A megoldás az, hogy az stc objektum statikussá válik. Ha egy statikus objektum inicializálva van, akkor annak értéke nem változtatható meg, amíg a program nem fejeződik be. A következő program (amelyet tesztelhet), amely megegyezik a fentiekkel, de most statikus stc-vel készült, 1-től 5-ig számít:
#includenévtér használata std;
int fn ()
statikus int stc = 1;
cout << " << stc;
stc = stc + 1;
ha (stc> 5)
visszatér 0;
fn ();
int main ()
fn ();
visszatér 0;
A kimenet: 1 2 3 4 5 .
Megjegyzés: A statikus objektum időtartama az objektum inicializálásakor kezdődik, és a program végén ér véget. Időközben az objektum közvetetten, más hatókörből használható. A statikus objektum inicializálása után kezdeti értéke nem változtatható meg, még akkor sem, ha a definícióját újraértékelik. A fenti kódban az stc nem áll vissza, a következő híváskor. A következő híváskor növeli az „stc = stc + 1;”.
Statikus adat tag
A kapcsolódó változók és függvények halmaza elhelyezhető egy osztálynak nevezett általánosított egységben. Ha a változók meghatározott értékeket kapnak, az osztály objektummá válik. Az objektum azonban nem úgy jön létre, hogy csak értékeket rendel hozzá a változóhoz. Az osztály példányos egy objektum megszerzéséhez; és minden létrehozott objektumnak megvan a saját neve, amely eltér az azonos osztály többi objektumától. A következő program egy TheCla nevű osztályt és egy obj nevű objektumot mutat be; azt is megmutatja, hogy az objektum hogyan példányosodik és hogyan használható a main () függvényben:
#includenévtér használata std;
osztály TheCla
nyilvános:
int szám;
void func (char cha, const char * str)
cout << "There are " << num << " books worth " << cha << str << " in the store." << '\n';
;
int main ()
TheCla obj;
obj.szám = 12;
obj.func ('$', "500");
visszatér 0;
A kimenet:
12 üzlet van 500 dollár értékben a boltban.
Figyelje meg, hogy a 12 változó hozzárendeléséhez a num változóhoz az objektumot példányosítani kell, mielőtt a hozzárendelés megtörténhetne. A programozónak lehetősége van az érték hozzárendelésére egy objektum példányosítása (létrehozása) nélkül. Ennek elérése érdekében a num változót statikusnak kell deklarálni. Ezután „TheCla :: num” néven lesz elérhető az objektum neve nélkül, de az osztály nevével. A következő program ezt szemlélteti:
#includenévtér használata std;
osztály TheCla
nyilvános:
statikus const int szám = 12;
void func (char cha, const char * str)
cout << "There are " << num << " books worth " << cha << str << " in the store." << '\n';
;
int main ()
cout << TheCla::num << '\n';
TheCla obj;
obj.func ('$', "500");
visszatér 0;
A kimenet:
12
A boltban 12 könyv áll 500 dollár értékben.
Ne feledje, hogy az adattaghoz való hozzáféréshez a num in main (), a hatókör-felbontás operátort, :: kellett használni. Az sem, hogy a num változót állandóvá kellett tenni és inicializálni kellett az osztályleírásban (definíció).
Statikus tag funkció
Figyelje meg, hogy az előző programlistában a func függvény használatához a main () -ban egy objektumot kellett példányosítani. Lehetséges, hogy a programozó objektum példányosítása (létrehozása) nélkül hívja meg a függvényt. Ennek elérése érdekében a függvénydefiníciót a „statikus” szó elé kell állítani. Ezután az „TheCla :: func ()” néven lesz elérhető az objektum neve nélkül, de az osztály nevével. A következő program ezt szemlélteti a statikus adat tag és a statikus tag függvény esetében:
#includenévtér használata std;
osztály TheCla
nyilvános:
statikus const int szám = 12;
static void func (char cha, const char * str)
cout << "There are " << num << " books worth " << cha << str << " in the store." << '\n';
;
int main ()
TheCla :: func ('$', "500");
visszatér 0;
A kimenet:
12 üzlet van 500 dollár értékben a boltban.
Menet tárolási időtartama
A szálat a C ++ szolgáltatásban még nem valósította meg a g ++ fordító. Tehát ennek magyarázata helyett a C ++ specifikációból származó idézetet adjuk meg a következőképpen:
- A thread_local kulcsszóval deklarált összes változónak tárolási időtartama van. Ezeknek az entitásoknak a tárolás addig tart, amíg a szál létre nem jön. Különálló objektum vagy hivatkozás van szálanként, és a deklarált név használata az aktuális szálhoz társított entitásra utal.
- A szál tárolási időtartamú változót inicializálni kell az első szagtalan használat előtt, és ha felépítették, akkor a szál kilépésekor meg kell semmisíteni.”
Következtetés
Az objektum élettartama az inicializálás befejeztével kezdődik, és a tárolás felszabadulásakor ér véget. A dinamikus tárolási időtartam akkor kezdődik, amikor az (új típus) által létrehozott tároló inicializálódik, és akkor ér véget, amikor az objektum kimarad a hatókörből, vagy a „törlés mutató” törli. A statikus objektum időtartama az objektum inicializálásakor kezdődik, és a program végén ér véget. A statikus objektum inicializálása után kezdeti értéke nem változtatható meg, még akkor sem, ha a definícióját újraértékelik. A statikus adatok tagjai és a statikus függvények tagjai az osztályleíráson kívül érhetők el a „ClassName :: name” névvel.
Chrys
