smart pointerek
Munka mutatók néha hibákhoz vezethet, ha nem használják őket nagyon óvatosan. Így például, nehéz lehet, ha elfelejti inicializálni őket, felejtsd el, hogy távolítsa el őket használat után, és távolítsa el kétszer ugyanazt az indexet.
A fő probléma a mutatókat, hogy ha dolgozik, dinamikus memória szükséges kialakítani egy olyan rendszert, amely kezeli saját memóriájába. Ő tudni fogja, hol a memóriát, és ahol a kibocsátás, ami nem mindig egyszerű feladat. Néha alkalmazásokat fejleszt olyan bonyolult, hogy nem lehet felszabadítja a memóriát foglal el, pontosan ugyanazon a helyen és azonosították. És ez gyakran nehéz meghatározni az élettartama a forrás.
Osztályba a C ++ - «smart». Ellentétben a C nyelv mellett a módszerek vannak konstruktorok és a destruktor. Így van a „élettartama” - a hívás idejére a kivitelező, hogy hívja a destruktor. Bár a valóságban a tárgy tekinthető életben után a teljes körű végrehajtása a tervező előtt a destruktor hívják. Azt nem mondhatjuk, hogy az objektum életben idején a végrehajtás, mivel nem biztos, hogy minden mező megtörtént és nem triviális, hogy velük együtt dolgozni lehet tele van problémákkal.
void ize () a a;
// hasznos munkát
// hívja a destruktor
>
void ize () a a;
// hasznos munkát
// hívja a destruktor
>
// hasznos munkát
>
bar (a ());
// destruktor lesz
// nevezték el
// befejeződött
// végrehajtása bar ()
A dinamikus elosztás a tárgy fog létezni, amíg nem mi távolítottuk. Amikor a program befejeződik a végrehajtás, senki sem fogja hívni a dekonstruktorának tárgyak, amelyek nem egy programozó nem távolítja el magát, így ha van olyan fontos kód (például a kapcsolat bezárása), akkor nem kerül végrehajtásra. Ebben az esetben, az élettartam egy tárgy korlátozódik az eltávolítása a mutatót törölni. Ha az objektum nem kerül eltávolításra, mielőtt a megjelenése a látómezejében, akkor lesz egy „zombi” - ez létezik, de az ahhoz való hozzáférés nem szerezhető.
void ize () a a = új A ();
// objektum nem kell semmisíteni, amíg a hívás törlése
>
„Smart Index” összeköti az élettartama a tárgyat a kupac a tárgy élettartama kiosztott a verem.
Tekintsük az összehasonlítás kód, amely együttműködik a hagyományos és az új smart pointer. Mi fog alapulni már kidolgozott előzetes bigint osztályban.
Bigint * p = új bigint ();
(* P) = n;
//.
karakterlánc str = p-> toString ();
//.
törölni p;
A probléma a szokásos mutató az, hogy bárhol a szövegben okozhatja vissza. és ebben az esetben a program nem fogja elérni azt a pontot a rendelkezésére. Azonban a törlés kell hivatkozni, amikor volt egy memóriafoglalás új. Akkor nincs szükség nevezni manuálisan a smart pointer kommunikálni a szintaxis, ami hasonló a szintaxis kommunikáció közönséges mutató. Ebben az esetben a memória át lehet tisztítani destructor smart pointer.
Bemutatjuk az osztály kifejlesztett egy okos mutató.
private:
Bigint * ptr_;
nyilvános:
BigIntPtr (bigint * p = 0);
BigIntPtr ();
bigint üzemeltető * () const;
Bigint * operátor -> () const;
private:
BigIntPtr (BigIntPtr const );
BigIntPtr operátor = (BigIntPtr const );
>;
BigIntPtr :: BigIntPtr (bigint * p): ptr_ (p)>
BigIntPtr () törölni ptr_;
>
bigint BigIntPtr :: operator * () const visszatérés * ptr_;
>
Bigint * BigIntPtr :: operator -> () const visszatérő ptr_;
>
Azt is meg kell jegyezni, hogy megfelelően a mnemonikot szabály meghatározásánál a destruktor is meg kell határozni a másolatot a kivitelező, valamint az értékadó operátor. Ez annak a ténynek köszönhető, hogy ha azt akarjuk, hogy elpusztítsa a tárgy nem triviális (például, hogy engedje el a korábban elkülönített memória), akkor is, amikor a másolás egy kivitelező vagy megbízás problémákat okozhat.
Egyoperandusú „csillag” - állandó, de vissza nem const referencia. Által kifejlesztett intelligens mutató kell viselkednie, mint egy normális mutatót, akkor lehetővé kell tennie, hogy módosítsa a tárgy, amelyre hivatkozott. Ugyanakkor tisztában vagyunk azzal, hogy a nagyon okos mutató ebben az esetben nem változik.
Nincs szükség, hogy kezelni egy kivétel, ha egy okos mutató semmit nem hivatkozható (azaz ptr_ nulla). Az a tény, hogy a rendes mutató és nem reagál az ilyen viselkedést, és nem világos, hogy mit kell visszaküldeni ebben az esetben okos.
„Arrow” operátor vissza kell térnie a mutatót. Bár a valóságban, akkor vissza semmit, hogy van egy nyilatkozatot, „nyíl”, de akkor még ez a szolgáltató fogja ismételni, amíg, amíg végül, nem lehet vissza a mutatót.
Intelligens egérmutató destructor megszabadít minket a szükségességét, hogy megtisztítsa a memóriát, mert ezzel magam. Így a tárgy, amely az intelligens mutató, akkor azonnal meg kell semmisíteni, amikor kilép a blokk smart pointer láthatóságát.
Ez a koncepció az úgynevezett RAII - Erőforrás akvizíció inicializálása (forráselosztás inicializálás). Ez azt jelenti, hogy az inicializálás, nézzük a tárgyat a kiosztási memória, és teszi felelős a visszatérés memóriában a pusztulástól. Példaként adatbázis kapcsolatok lekérdezett port mutexes konkurens alkalmazásokat. Ha az objektum nem tér vissza a kért erőforrás inicializálás, senki sem utána nem lesz képes használni.
Kód kifejlesztett fenti sok hátránya. Először is egy ilyen mutató nem lehet változtatni. Ezt lehet korrigálni meghatározó értékadó operátor jobb oldalán, amely egy mutató a kívánt objektumot.
Így nem létezhet két pointert ugyanarra az objektumra. A destruktor az első smart pointer megsemmisíti az objektumot, és a második mutató destructor megpróbálja ugyanezt tegye. Ebben az esetben lesz egy kettős hiba eltávolítását.
Ezen túlmenően, ez lehetetlen ellenőrizni, nem utal, hogy egy ilyen okos mutató nullára.
Továbbá, ezek a mutatók nem lehet összehasonlítani a hagyományos mutatók. Ha át őket az összehasonlító függvényt, ha a kivitelező, hogy vesz egy normális egér nincs bejelentve explicit. ez létre fog hozni egy okos mutató, és miután azt egy ideiglenes objektum destruktor eltávolítja az objektumot.
A koncepció egy ilyen mutató az úgynevezett gyári irányzékkal ellátott Pointer - pointer körét. Ez az intelligens mutató csak akkor lehet alkalmazni, a blokk, amelyben megállapították.
Tovább végrehajtása - Közös Pointer, közös mutatót. A különbség abban rejlik, hogy ez a mutató lehet másolni. Ebben az esetben maga a tárgy hagyni csak az utolsó mutató megsemmisül, utalva rá. Ez tette lehetővé, segítségével a referencia száma.
Az ötlet a következő: ha egy okos mutató jön létre, akkor viszont létrehoz egy referencia számot, egy szám, amely tárolja a kupac, számának megadásával okos mutatók, amelyek utalnak egy tárgyat. Másolásakor mutató nem csak egy mutató a másolási tárgy, hanem egy mutatót a mai és a számláló értéke növekszik. A megsemmisítés a smart pointer számláló értéke csökken. Ha a mutató már elpusztult az utolsó tulajdonosa a tárgy és a tárgy eltávolítása is.
A másik variáció az, hogy létrehozzanak egy közös mutató további célja a kupac, amely mind a számláló, és hivatkoznak a tartós objektumot. Így, ha a másolás másolni, csak egy index, minden okos mutató csak utal egy tárgyat számláló és hivatkozás az eredeti forrást.
Ezeket a jelzéseket a már most is egymáshoz rendelve, annak másolatát megküldi a funkció összehasonlítására és így tovább.