Forutsetning: Pekere i C++
Pekere brukes for å få tilgang til ressursene som er eksterne for programmet - som haugminne. Så for å få tilgang til heap-minnet (hvis noe er opprettet i heap-minnet), brukes pekere. Når vi får tilgang til en ekstern ressurs, bruker vi bare en kopi av ressursen. Hvis vi gjør noen endringer i den, endrer vi den bare i den kopierte versjonen. Men hvis vi bruker en peker til ressursen, kan vi endre den opprinnelige ressursen.
Problemer med normale pekere
Noen problemer med normale pekere i C++ er som følger:
- Minnelekkasjer: Dette skjer når minne gjentatte ganger tildeles av et program, men aldri frigjøres. Dette fører til overdreven minneforbruk og fører til slutt til systemkrasj. Dinglepekere: En dinglende peker er en peker som oppstår på det tidspunktet objektet blir fjernet fra minnet uten å endre verdien til pekeren. Wild-pekere: Wild-pekere er pekere som er deklarert og tildelt minne, men pekeren initialiseres aldri til å peke til noe gyldig objekt eller adresse. Datainkonsistens: Datainkonsistens oppstår når noen data er lagret i minnet, men ikke oppdateres på en konsistent måte. Bufferoverflyt: Når en peker brukes til å skrive data til en minneadresse som er utenfor den tildelte minneblokken. Dette fører til korrupsjon av data som kan utnyttes av ondsinnede angripere.
Eksempel:
C++
// C++ program to demonstrate working of a Pointers> #include> using> namespace> std;> class> Rectangle {> private>:> >int> length;> >int> breadth;> };> void> fun()> {> >// By taking a pointer p and> >// dynamically creating object> >// of class rectangle> >Rectangle* p =>new> Rectangle();> }> int> main()> {> >// Infinite Loop> >while> (1) {> >fun();> >}> }> |
>
>
Produksjon
Memory limit exceeded>
Forklaring: I funksjon moro , skaper det en peker som peker til Rektangel gjenstand. Objektet Rektangel inneholder to heltall, lengde, og bredde . Når funksjonen moro slutter, vil p bli ødelagt da det er en lokal variabel. Men minnet det forbrukte vil ikke bli tildelt fordi vi har glemt å bruke slette p; på slutten av funksjonen. Det betyr at minnet ikke vil være gratis å brukes av andre ressurser. Men vi trenger ikke variabelen lenger, vi trenger minnet.
I funksjon, hoved- , moro kalles i en uendelig løkke. Det betyr at det vil fortsette å skape s . Det vil tildele mer og mer minne, men vil ikke frigjøre dem siden vi ikke tildelte det. Minnet som er bortkastet kan ikke brukes igjen. Som er en minnelekkasje. Hele haug minne kan bli ubrukelig av denne grunn.
Smarte pekere
Som vi har kjent ubevisst, forårsaker ikke deallokering av en peker en minnelekkasje som kan føre til en krasj av programmet. Språk Java, C# har Søppeloppsamlingsmekanismer for å smart deallokere ubrukt minne som skal brukes igjen. Programmereren trenger ikke å bekymre seg for minnelekkasjer. C++ kommer opp med sin egen mekanisme Smart peker . Når objektet blir ødelagt, frigjør det også minnet. Så vi trenger ikke å slette det, da Smart Pointer vil håndtere det.
EN Smart peker er en wrapper-klasse over en peker med en operatør som * og -> overbelastet. Objektene til smartpekerklassen ser ut som vanlige pekere. Men i motsetning til Normale pekere, den kan deallokere og frigjøre ødelagt objektminne.
Tanken er å ta en klasse med en peker, ødelegger, og overbelastede operatører som * og -> . Siden destruktoren kalles automatisk når et objekt går utenfor scope, vil det dynamisk tildelte minnet automatisk bli slettet (eller referanseantallet kan reduseres).
Eksempel:
C++
// C++ program to demonstrate the working of Smart Pointer> #include> using> namespace> std;> class> SmartPtr {> >int>* ptr;>// Actual pointer> public>:> >// Constructor: Refer> >// techcodeview.com for use of> >// explicit keyword> >explicit> SmartPtr(>int>* p = NULL) { ptr = p; }> >// Destructor> >~SmartPtr() {>delete> (ptr); }> >// Overloading dereferencing operator> >int>& operator*() {>return> *ptr; }> };> int> main()> {> >SmartPtr ptr(>new> int>());> >*ptr = 20;> >cout << *ptr;> >// We don't need to call delete ptr: when the object> >// ptr goes out of scope, the destructor for it is> >// automatically called and destructor does delete ptr.> >return> 0;> }> |
>
>Produksjon
20>
Forskjellen mellom pekere og smarte pekere
| Peker | Smart peker |
|---|---|
| En peker er en variabel som opprettholder en minneadresse samt datatypeinformasjon om den minneplasseringen. En peker er en variabel som peker på noe i minnet. | Det er et pekepinnende stabeltildelt objekt. Smarte pekere er i enkle ord klasser som omslutter en peker, eller pekere med omfang. |
| Den blir ikke ødelagt i noen form når den går utenfor sitt virkeområde | Den ødelegger seg selv når den går utenfor sitt virkeområde |
| Pekere er ikke så effektive siden de ikke støtter noen annen funksjon. | Smarte pekere er mer effektive siden de har en tilleggsfunksjon for minneadministrasjon. |
| De er veldig arbeidssentrerte/manuelle. | De er automatiske/forhåndsprogrammerte. |
Merk: Dette fungerer kun for int . Så vi må lage Smart Pointer for hvert objekt? Nei , det er en løsning, Mal . I koden nedenfor som du kan se T kan være av hvilken som helst type.
nfa eksempler
Eksempel:
C++
// C++ program to demonstrate the working of Template and> // overcome the issues which we are having with pointers> #include> using> namespace> std;> // A generic smart pointer class> template> <>class> T>>class> SmartPtr {> >T* ptr;>// Actual pointer> public>:> >// Constructor> >explicit> SmartPtr(T* p = NULL) { ptr = p; }> >// Destructor> >~SmartPtr() {>delete> (ptr); }> >// Overloading dereferencing operator> >T& operator*() {>return> *ptr; }> >// Overloading arrow operator so that> >// members of T can be accessed> >// like a pointer (useful if T represents> >// a class or struct or union type)> >T* operator->() {>return> ptr; }> };> int> main()> {> >SmartPtr<>int>>ptr(>new> int>());> >*ptr = 20;> >cout << *ptr;> >return> 0;> }> |
>
>Produksjon
20>
Merk: Smarte pekere er også nyttige i administrasjonen av ressurser, for eksempel filhåndtak eller nettverkskontakter.
Typer smarte pekere
C++-biblioteker tilbyr implementeringer av smarte pekere i følgende typer:
- auto_ptr
- unik_ptr
- delt_ptr
- svak_ptr
auto_ptr
Ved å bruke auto_ptr kan du administrere objekter hentet fra nye uttrykk og slette dem når selve auto_ptr blir ødelagt. Når et objekt beskrives gjennom auto_ptr, lagrer det en peker til et enkelt allokert objekt.
Merk: Denne klassemalen er avviklet fra og med C++11. unique_ptr er et nytt anlegg med lignende funksjonalitet, men med forbedret sikkerhet.
unik_ptr
unik_ptr lagrer kun én peker. Vi kan tilordne et annet objekt ved å fjerne det gjeldende objektet fra pekeren.
Eksempel:
C++
// C++ program to demonstrate the working of unique_ptr> // Here we are showing the unique_pointer is pointing to P1.> // But, then we remove P1 and assign P2 so the pointer now> // points to P2.> #include> using> namespace> std;> // Dynamic Memory management library> #include> class> Rectangle {> >int> length;> >int> breadth;> public>:> >Rectangle(>int> l,>int> b)> >{> >length = l;> >breadth = b;> >}> >int> area() {>return> length * breadth; }> };> int> main()> {> // --/ Smart Pointer> >unique_ptr P1(>new> Rectangle(10, 5));> >cout // This'll print 50 // unique_ptr P2(P1); unique_ptr P2; P2 = move(P1); // This'll print 50 cout // cout return 0; }> |
>
>Produksjon
50 50>
delt_ptr
Ved bruk av delt_ptr mer enn én peker kan peke til dette ene objektet om gangen, og det vil opprettholde en Referanseteller bruker bruk_antall() metode.
C++
// C++ program to demonstrate the working of shared_ptr> // Here both smart pointer P1 and P2 are pointing to the> // object Addition to which they both maintain a reference> // of the object> #include> using> namespace> std;> // Dynamic Memory management library> #include> class> Rectangle {> >int> length;> >int> breadth;> public>:> >Rectangle(>int> l,>int> b)> >{> >length = l;> >breadth = b;> >}> >int> area() {>return> length * breadth; }> };> int> main()> {> >//---/ Smart Pointer> >shared_ptr P1(>new> Rectangle(10, 5));> >// This'll print 50> >cout shared_ptr P2; P2 = P1; // This'll print 50 cout // This'll now not give an error, cout // This'll also print 50 now // This'll print 2 as Reference Counter is 2 cout << P1.use_count() << endl; return 0; }> |
>
>Produksjon
50 50 50 2>
svak_ptr
Weak_ptr er en smart peker som inneholder en ikke-eiende referanse til et objekt. Det ligner mye mer på shared_ptr bortsett fra at det ikke opprettholder en Referanseteller . I dette tilfellet vil ikke en peker ha en festning på objektet. Årsaken er at hvis anta at pekere holder objektet og ber om andre objekter, kan de danne en Dødlås.
C++
// C++ program to demonstrate the working of weak_ptr> // Here both smart pointer P1 and P2 are pointing to the> // object Addition to which they both does not maintain> // a reference of the object> #include> using> namespace> std;> // Dynamic Memory management library> #include> class> Rectangle {> >int> length;> >int> breadth;> public>:> >Rectangle(>int> l,>int> b)> >{> >length = l;> >breadth = b;> >}> >int> area() {>return> length * breadth; }> };> int> main()> {> >//---/ Smart Pointer> >shared_ptr P1(>new> Rectangle(10, 5));> > >// create weak ptr> >weak_ptr P2 (P1);> > >// This'll print 50> >cout // This'll print 1 as Reference Counter is 1 cout << P1.use_count() << endl; return 0; }> |
kartlegging i maskinskrift
>
>Produksjon
50 1>
C++-biblioteker gir implementeringer av smarte pekere i form av auto_ptr, unique_ptr, shared_ptr og weak_ptr