Priekšnosacījums: Norādes valodā C++
Rādītāji tiek izmantoti, lai piekļūtu resursiem, kas ir ārpus programmas, piemēram, kaudzes atmiņa. Tātad, lai piekļūtu kaudzes atmiņai (ja kaut kas ir izveidots kaudzes atmiņā), tiek izmantoti rādītāji. Piekļūstot jebkuram ārējam resursam, mēs izmantojam tikai resursa kopiju. Ja mēs tajā veicam kādas izmaiņas, mēs to mainām tikai kopētajā versijā. Bet, ja mēs izmantojam rādītāju uz resursu, mēs varēsim mainīt sākotnējo resursu.
Problēmas ar parastajiem rādītājiem
Dažas problēmas ar parastajiem rādītājiem programmā C++ ir šādas:
- Atmiņas noplūde: tas notiek, ja programma atkārtoti piešķir atmiņu, bet tā netiek atbrīvota. Tas izraisa pārmērīgu atmiņas patēriņu un galu galā izraisa sistēmas avāriju. Karājas norādes: Karājas rādītājs ir rādītājs, kas parādās brīdī, kad objekts tiek izņemts no atmiņas, nemainot rādītāja vērtību. Savvaļas norādes: Savvaļas norādes ir norādes, kuras tiek deklarētas un kurām tiek piešķirta atmiņa, taču rādītājs nekad netiek inicializēts, lai norādītu uz kādu derīgu objektu vai adresi. Datu nekonsekvence: datu nekonsekvence rodas, ja daži dati tiek saglabāti atmiņā, bet netiek konsekventi atjaunināti. Bufera pārpilde: kad rādītājs tiek izmantots, lai rakstītu datus uz atmiņas adresi, kas atrodas ārpus piešķirtā atmiņas bloka. Tas noved pie datu sabojāšanas, ko var izmantot ļaunprātīgi uzbrucēji.
Piemērs:
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();> >}> }> |
>
>
Izvade
Memory limit exceeded>
Paskaidrojums: Funkcijā jautri , tas izveido rādītāju, kas norāda uz Taisnstūris objektu. Objekts Taisnstūris satur divus veselus skaitļus, garums, un platums . Kad funkcija jautri beidzas, p tiks iznīcināts, jo tas ir lokāls mainīgais. Taču tā patērētā atmiņa netiks izdalīta, jo mēs aizmirsām to izmantot dzēst p; funkcijas beigās. Tas nozīmē, ka atmiņu nevarēs izmantot citi resursi. Bet mums vairs nav vajadzīgs mainīgais, mums ir vajadzīga atmiņa.
Funkcijā, galvenais , jautri tiek saukts bezgalīgā cilpā. Tas nozīmē, ka tas turpinās radīt lpp . Tas piešķirs arvien vairāk atmiņas, bet to neatbrīvos, jo mēs to nedabūjām. Iztērēto atmiņu nevar izmantot atkārtoti. Kas ir atmiņas noplūde. Visa kaudze šī iemesla dēļ atmiņa var kļūt bezjēdzīga.
Viedie rādītāji
Kā mēs zinām, neapzināti, ja rādītāja neatdalīšana izraisa atmiņas noplūdi, kas var izraisīt programmas avāriju. Valodas ir Java, C# Atkritumu savākšanas mehānismi lai gudri sadalītu neizmantoto atmiņu, lai to izmantotu vēlreiz. Programmētājam nav jāuztraucas par atmiņas noplūdēm. C++ nāk klajā ar savu mehānismu Viedais rādītājs . Kad objekts tiek iznīcināts, tas atbrīvo arī atmiņu. Tāpēc mums tas nav jādzēš, jo ar to tiks galā Smart Pointer.
A Viedais rādītājs ir iesaiņojuma klase virs rādītāja ar tādu operatoru kā * un -> pārslogots. Viedo rādītāju klases objekti izskatās kā parastie rādītāji. Bet, atšķirībā no Parastās norādes, tas var atdalīt un atbrīvot iznīcināto objektu atmiņu.
Ideja ir vadīt nodarbību ar rādītāju, iznīcinātājs, un pārslogoti operatori patīk * un -> . Tā kā iznīcinātājs tiek automātiski izsaukts, kad objekts ir ārpus darbības jomas, dinamiski piešķirtā atmiņa tiks automātiski dzēsta (vai atsauces skaitu var samazināt).
Piemērs:
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;> }> |
>
>Izvade
20>
Atšķirība starp rādītājiem un viedajiem rādītājiem
| Rādītājs | Viedais rādītājs |
|---|---|
| Rādītājs ir mainīgais, kas uztur atmiņas adresi, kā arī datu tipa informāciju par šo atmiņas vietu. Rādītājs ir mainīgais, kas norāda uz kaut ko atmiņā. | Tas ir rādītāja iesaiņošanas steka piešķirts objekts. Viedās norādes, vienkāršā izteiksmē, ir klases, kas iesaiņo rādītāju, vai tvēruma norādes. |
| Tas netiek iznīcināts nekādā veidā, kad tas iziet ārpus tā darbības jomas | Tas iznīcina sevi, kad tas iziet ārpus tā darbības jomas |
| Rādītāji nav tik efektīvi, jo neatbalsta nevienu citu funkciju. | Viedie rādītāji ir efektīvāki, jo tiem ir papildu atmiņas pārvaldības funkcija. |
| Tie ir ļoti orientēti uz darbu / manuāli. | Tie ir automātiski/iepriekš ieprogrammēti pēc būtības. |
Piezīme: Tas darbojas tikai starpt . Tātad, mums būs jāizveido viedais rādītājs katram objektam? Nē , ir risinājums, Veidne . Zemāk esošajā kodā, kā redzat T var būt jebkura veida.
nosacījuma operators java
Piemērs:
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>>> >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;> }> |
>
>Izvade
java saraksta mezgls
20>
Piezīme: Viedās norādes ir noderīgas arī resursu, piemēram, failu rokturu vai tīkla ligzdas, pārvaldībā.
Viedo rādītāju veidi
C++ bibliotēkas nodrošina viedo rādītāju ieviešanu šādos veidos:
- auto_ptr
- unikāls_ptr
- share_ptr
- vājš_ptr
auto_ptr
Izmantojot auto_ptr, varat pārvaldīt objektus, kas iegūti no jaunām izteiksmēm, un dzēst tos, kad tiek iznīcināts pats auto_ptr. Kad objekts tiek aprakstīts, izmantojot auto_ptr, tas saglabā rādītāju uz vienu piešķirto objektu.
Piezīme: Šī klases veidne ir novecojusi no C++11. unique_ptr ir jauna iekārta ar līdzīgu funkcionalitāti, bet ar uzlabotu drošību.
unikāls_ptr
unikāls_ptr saglabā tikai vienu rādītāju. Mēs varam piešķirt citu objektu, noņemot pašreizējo objektu no rādītāja.
Piemērs:
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; }> |
>
>Izvade
50 50>
share_ptr
Izmantojot share_ptr uz šo vienu objektu vienlaikus var norādīt vairāk nekā viens rādītājs, un tas saglabās a Atsauces skaitītājs izmantojot use_count() metodi.
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; }> |
>
>Izvade
50 50 50 2>
vājš_ptr
Weak_ptr ir viedais rādītājs, kas satur nepiederošu atsauci uz objektu. Tas ir daudz līdzīgāks share_ptr, izņemot to, ka tas neuztur a Atsauces skaitītājs . Šajā gadījumā rādītājam objektā nebūs atbalsta. Iemesls ir tāds, ka, pieņemot, ka norādes tur objektu un pieprasa citus objektus, tās var veidot a Strupceļš.
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; }> |
>
>Izvade
50 1>
C++ bibliotēkas nodrošina viedo rādītāju ieviešanu auto_ptr, unikālo_ptr, shared_ptr un vājo_ptr formā.