Objektets livslängd och lagringstid i C ++

När du skapar ett objekt måste dess plats i minnet fastställas innan det initialiseras. Initiering innebär att sätta värde på platsen. Ett objekts livslängd börjar precis efter initialiseringen. När ett objekt dör frigörs dess plats (lagring), som objektet upptas och sedan stängs datorn av eller lagringen tas upp (används) av ett annat objekt. Att frigöra ett lagringsmedel, vilket gör att identifieraren eller pekaren som ockuperade lagringen är ogiltig. Ett objekts livslängd slutar när lagringen släpps.

Det behövs lite tid för att skapa ett objekt. Det behövs lite tid för att döda ett föremål. När man talar om ett objekt är två saker inblandade: platsen som är lagringen och värdet. Betydelsen av livstid och lagringstid är lika; men varaktigheten ses mer från platsens synvinkel än från värdets synvinkel. Lagringstiden är tiden från när en plats associeras till ett objekt till den tid då platsen dissocieras från objektet.

Resten av den här artikeln illustrerar objektets livslängd och förklarar kort de olika lagringstiderna. Du bör ha grundläggande kunskaper i C ++ för att förstå den här artikeln. Du bör också ha kunskap inom C ++ - omfattning.

Artikelinnehåll

Illustration av objektets livstid
Lagringstid
Automatisk lagringstid
Dynamisk lagringstid
Statisk lagringstid
Trådlagringstid
Slutsats

Illustration av objektets livstid

Tänk på följande program:

#omfatta
använder namnrymd std;
int main ()

om (1 == 1)

int x;
x = 1;
char y;
y = 'A';
cout << x << y << '\n';

returnera 0;

Utgången är 1A .

Ett objekts liv upphör när det går utanför räckvidden. Objektets livstid börjar med “x = 1;” och slutar i slutet av if-local-scope. Objektets livslängd börjar med “y = 'A';” och slutar i slutet av if-local-scope. Innan båda föremål dör används de i cout-uttalandet .

Lagringstid

Lagringstid bestäms av något av följande scheman: automatisk lagringstid; dynamisk lagringstid; statisk lagringstid; trådlagringstid. Lagringstidskategorier, gäller även för referenser.

Automatisk lagringstid

Om en variabel inte deklareras uttryckligen som statisk, trådlokal eller extern, har variabeln automatisk lagringstid. Exempel är x och y ovan. Varaktigheten för sådana variabler slutar när de går utanför räckvidden. Följande program illustrerar automatisk lagringstid för en referens och en pekare i det globala omfånget.

#omfatta
använder namnrymd std;
int x = 1;
int & m = x;
char y = 'A';
char * n = & y;
int main ()

cout << m << *n << '\n';
returnera 0;

Utgången är 1A .

Längden på m börjar från “int & m = x;” och slutar i slutet av programmet. Varaktigheten för n börjar från “char * n = & y;” och slutar i slutet av programmet.

Dynamisk lagringstid

Gratis butik

I en modern dator kan mer än ett program köras samtidigt. Varje program har sin egen del av minnet. Resten av minnet som inte används av något program kallas gratis butik. Följande uttryck används för att returnera en plats för ett heltal från gratis butik

ny int

Denna plats (lagring) för heltalet som returneras måste fortfarande identifieras genom tilldelning till en pekare. Följande kod illustrerar hur man använder pekaren med gratis butik:

int * ptrInt = ny int;
* ptrInt = 12;
cout<< *ptrInt <<'\n';

Utgången är 12 .

För att få ett slut på objektets livslängd, använd raderingsuttrycket enligt följande:

ta bort ptrInt;

Argumentet för borttagningsuttrycket är en pekare. Följande kod illustrerar dess användning:

int * ptrInt = ny int;
* ptrInt = 12;
ta bort ptrInt;

En pekare som skapats med det nya uttrycket och raderats med borttagningsuttrycket är av dynamisk lagringstid. Den här pekaren dör när den går utanför räckvidden eller raderas. Varaktigheten för objektet i den föregående koden, börjar med “* ptrInt = 12;” och slutar i slutet av den deklarativa regionen (omfattning). Det finns mer i det nya och ta bort uttryck än vad som har diskuterats här - se senare.

Statisk lagringstid

Statiskt objekt

Ett objekt som förklarats statiskt, beter sig som det vanliga objektet, förutom att dess lagringstid börjar från det att det initialiseras till slutet av programmet. Det kan inte ses utanför dess räckvidd, men det kan indirekt användas utanför dess räckvidd.

Tänk på följande program, som ska räknas från 1 till 5 (testa inte programmet):

#omfatta
använder namnrymd std;
int fn ()

int stc = 1;
cout << " << stc;
stc = stc + 1;
om (stc> 5)
returnera 0;
fn ();

int main ()

fn ();
returnera 0;

Utgången är 1 1 1 1 1 1 1 1 ... och slutar aldrig riktigt. Funktionsdefinitionen är en återkommande funktion; vilket betyder att det fortsätter att ringa sig själv tills ett villkor är uppfyllt.

Lösningen är att göra stc-objektet statiskt. När ett statiskt objekt har initierats kan dess värde inte ändras förrän programmet avslutas. Följande program (som du kan testa), som är detsamma som ovan, men nu med stc gjort statisk, räknas från 1 till 5:

#omfatta
använder namnrymd std;
int fn ()

statisk int stc = 1;
cout << " << stc;
stc = stc + 1;
om (stc> 5)
returnera 0;
fn ();

int main ()

fn ();
returnera 0;

Utgången är: 1 2 3 4 5 .

Obs: Varaktigheten för ett statiskt objekt börjar när objektet har initierats och slutar i slutet av programmet. Under tiden kan objektet användas indirekt, från ett annat omfång. När ett statiskt objekt har initialiserats kan dess initialvärde inte ändras, även om dess definition utvärderas. I koden ovan återställs inte stc, nästa gång den anropas. Nästa gång det kallas ökas det med “stc = stc + 1;”.

Statisk datamedlem

En uppsättning relaterade variabler och funktion kan placeras i en generaliserad enhet som kallas en klass. Om variablerna ges särskilda värden blir klassen ett objekt. Ett objekt skapas dock inte genom att bara tilldela värden till variabeln. Klassen instanseras för att få ett objekt; och varje skapat objekt har sitt eget namn som skiljer sig från andra objekt i samma klass. Följande program visar en klass, kallad TheCla och ett objekt, kallad obj; det visar också hur objektet instantieras och används i huvudfunktionen ():

#omfatta
använder namnrymd std;
klass TheCla

offentlig:
int num;
void func (char cha, const char * str)

cout << "There are " << num << " books worth " << cha << str << " in the store." << '\n';

;
int main ()

TheCla invände;
obj.num = 12;
obj.funk ('$', "500");
returnera 0;

Utgången är:

Det finns 12 böcker värda $ 500 i butiken.

Observera att för att tilldela värdet 12 till variabeln num måste objektet instansieras innan tilldelningen kan ske. Det är möjligt för programmeraren att tilldela värdet utan att omedelbart (skapa) ett objekt. För att uppnå detta måste variabeln num deklareras som statisk. Sedan kommer den att nås som “TheCla :: num” utan objektnamnet, men med klassnamnet. Följande program illustrerar detta:

#omfatta
använder namnrymd std;
klass TheCla

offentlig:
statisk konst int int = 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 invände;
obj.funk ('$', "500");
returnera 0;

Utgången är:

12
Det finns 12 böcker värda $ 500 i butiken.

Observera att för att komma åt datamedlemmen, num in main (), måste operatören för omfångsupplösning :: användas. Inte heller att variabeln, num måste göras konstant och initialiseras i klassbeskrivningen (definition).

Statisk medlemsfunktion

Lägg märke till att för att använda funkfunktionen i main () i föregående programlista ovan, måste ett objekt instantieras. Det är möjligt för programmeraren att ringa till funktionen utan att omedelbart (skapa) ett objekt. För att uppnå detta måste funktionsdefinitionen föregås av ordet "statisk". Sedan kommer den att nås som “TheCla :: func ()” utan objektnamnet, men med klassnamnet. Följande program illustrerar detta för statisk datamedlem och statisk medlemsfunktion:

#omfatta
använder namnrymd std;
klass TheCla

offentlig:
statisk konst int int = 12;
statisk tomrumsfunktion (char cha, const char * str)

cout << "There are " << num << " books worth " << cha << str << " in the store." << '\n';

;
int main ()

TheCla :: func ('$', "500");
returnera 0;

Utgången är:

Det finns 12 böcker värda $ 500 i butiken.

Trådlagringstid

Tråd som en funktion i C ++ har ännu inte implementerats av g ++ - kompilatorn. Så istället för att förklara detta ges citatet från C ++ specifikationen enligt följande:

Alla variabler som deklarerats med sökordet thread_local har varaktighet för trådlagring. Lagringen för dessa enheter ska pågå under hela den tråd där de skapas. Det finns ett distinkt objekt eller referens per tråd, och användning av det deklarerade namnet avser den enhet som är associerad med den aktuella tråden.
En variabel med varaktighet för trådlagring ska initieras före dess första användning och, om den är konstruerad, ska den förstöras vid trådutgången.”

Slutsats

Ett objekts livslängd börjar när initialiseringen är klar och slutar när lagringen släpps. Dynamisk lagringstid startar när lagringen som skapats av (ny typ) initieras och slutar när objektet går utanför räckvidden eller raderas av "delete pointer". Varaktigheten för ett statiskt objekt börjar när objektet har initierats och slutar i slutet av programmet. När ett statiskt objekt har initialiserats kan dess ursprungliga värde inte ändras, även om dess definition utvärderas på nytt. Statiska datamedlemmar och statiska funktionsmedlemmar nås utanför klassbeskrivningen med "ClassName :: name".

Chrys