Exemplul 1: Declarați indicatorul partajat în moduri diferite
Trei moduri diferite de a declara un indicator comun sunt prezentate în exemplul următor. O clasă cu un constructor și o metodă publică au fost declarate în cod. Constructorul va imprima un mesaj atunci când este creat un nou obiect partajat cu constructorul. The Afişa() metoda va imprima mesaje bazate pe obiectul pointer partajat apelant. Aici, primul obiect pointer partajat a fost creat fără a apela constructorul. Al doilea obiect pointer partajat a fost creat apelând constructorul. Al treilea indicator comun a fost creat prin atribuirea primului indicator comun. The Afişa() metoda a fost apelată de trei ori folosind trei obiecte de pointer partajate.
// Includeți bibliotecile necesare
#include
#include
usingnamespacestd;
// Definiți clasa
classMyClass{
public:
// Declarați constructorul
Clasa mea() {
cost<<'Constructorul este numit. n';
}
// Declarați o metodă de imprimare a textului
voidDisplay(str str)
{
cost<<„Metoda Display () este apelată din„<<str<<'indicator. n';
}
};
principal()
{
// Inițializați shared_ptr fără a apela constructorul
shared_ptr p1=make_shared();
p1->Afişa('primul');
// Inițializați shared_ptr apelând constructorul
shared_ptr p2=shared_ptr(newMyClass);
p2->Afişa('al doilea');
// Inițializați shared_ptr prin atribuire
shared_ptr p3=p1;
p3->Afişa('al treilea');
returnare0;
}
Ieșire:
Următoarea ieșire va apărea după executarea codului de mai sus. Constructorul a apelat numai în momentul creării celui de-al doilea obiect. Deci, mesajul constructorului a fost tipărit o singură dată:
Exemplul 2: Imprimați locația indicatorului partajat stocat
Pointerul partajat cu funcția get () este utilizat pentru a returna locația pointerului partajat stocat. Următorul exemplu va imprima locația indicatoarelor stocate, partajate, create de clasă și funcție. Aici, o clasă cu un constructor a fost definită pentru a fi utilizată pentru crearea unui pointer partajat. A fost declarată o funcție pentru a crea un pointer partajat și a imprima locația pointerului partajat folosind funcția get (). În acest cod, primul indicator comun a fost creat folosind clasa, al doilea indicator comun a fost creat folosind funcția, iar al treilea indicator comun a fost creat prin atribuirea primului indicator.
// Includeți bibliotecile necesare#include
#include
usingnamespacestd;
// Definiți clasa
classMyClass
{
public:
// Declarați constructorul
Clasa mea() {
cost<<'Constructorul este numit. n';
}
};
// Definiți funcția pentru a inițializa indicatorul
voidInit_shared_ptr()
{
shared_ptr p2(newMyClass);
cost<<p2.obține() <<' n';
}
principal()
{
// Inițializați shared_ptr apelând constructorul
shared_ptr p1=shared_ptr(newMyClass);
cost<<p1.obține() <<' n';
// Inițializați shared_ptr apelând funcția
Init_shared_ptr();
// Inițializați shared_ptr prin atribuire
shared_ptr p3=p1;
cost<<p3.obține() <<' n';
returnare0;
}
Ieșire:
Următoarea ieșire similară va apărea după executarea codului de mai sus. În ieșire, valoarea returnată a funcției get () pentru primul și al treilea indicator comun este aceeași. Cu toate acestea, al doilea indicator comun este diferit:
Exemplul 3: Numărați obiectele de indicator partajat
Următorul exemplu descrie o modalitate de a număra numărul de obiecte îndreptate de un pointer partajat după crearea și distrugerea pointerului. O clasă cu un constructor a fost declarată în cod. Primul indicator comun a fost creat folosind clasa, iar al doilea indicator comun a fost creat folosind primul indicator comun. Numărul de obiecte îndreptate de ambele indicatoare partajate înainte și după apelarea funcției reset () a fost tipărit ulterior.
// Includeți bibliotecile necesare#include
#include
usingnamespacestd;
// Definiți clasa
classMyClass{
public:
// Declarați constructorul
Clasa mea() {
cost<<'Constructorul este numit. n';
}
};
principal()
{
// Inițializați primul shared_ptr apelând constructorul
shared_ptr p1(newMyClass);
// Afișați numărul de obiecte shared_ptr de către primul indicator
cost<<„p1 arătând către”<<p1.use_count() <<' obiecte). n';
// Inițializați al doilea shared_ptr folosind primul shared_ptr
shared_ptr p2(p1);
// Afișați numărul de obiecte shared_ptr de către primul și al doilea pointer
cost<<„p2 care indică”<<p2.use_count() <<' obiecte). n';
cost<<„p1 arătând către”<<p1.use_count() <<' obiecte). n';
// Eliminați proprietatea primului indicator din obiectul shared_ptr
p1.resetați();
// Afișați numărul de obiecte shared_ptr de al doilea indicator
cost<<„p2 care indică”<<p2.use_count() <<' obiecte). n';
returnare0;
}
Ieșire:
Următoarea ieșire va apărea după executarea codului de mai sus. Primul indicator, p1 , indică un obiect după creație. După crearea celui de-al doilea indicator, p2 , folosind primul indicator, p1 , ambii indicatori indică două obiecte pentru partajarea indicatorului. După ce ați apelat funcția reset () pentru indicator, p1 , un obiect a fost distrus, iar indicatorul, p2 , indică acum un singur obiect.
Concluzie:
Scopurile utilizării unui pointer partajat în C ++ au fost explicate în acest tutorial folosind exemple simple. Crearea pointerelor partajate în moduri diferite, obținerea locației pointerului partajat stocat și numărarea numărului de obiecte îndreptate de pointerele partajate. Sper că programatorii C ++ vor putea folosi indicatorul partajat în codul lor după ce au citit acest tutorial.