Voorbeeld 1: Gedeelde aanwijzer op verschillende manieren declareren
In het volgende voorbeeld worden drie verschillende manieren getoond om een gedeelde aanwijzer te declareren. Een klasse met een constructor en een openbare methode zijn gedeclareerd in de code. De constructor zal een bericht afdrukken wanneer een nieuw gedeeld object wordt gemaakt met de constructor. De Weergave() methode zal berichten afdrukken op basis van het aanroepende gedeelde pointer-object. Hier is het eerste gedeelde pointer-object gemaakt zonder de constructor aan te roepen. Het tweede gedeelde pointer-object is gemaakt door de constructor aan te roepen. De derde gedeelde aanwijzer is gemaakt door de eerste gedeelde aanwijzer toe te wijzen. De Weergave() methode is drie keer aangeroepen met behulp van drie gedeelde pointer-objecten.
//Benodigde bibliotheken opnemen
#erbij betrekken
#erbij betrekken
namespace std; gebruiken;
//Definieer de klasse
classMyClass{
openbaar:
//Declareer de constructor
Mijn klas() {
kosten<<'De constructeur wordt gebeld.N';
}
//Declareer een methode om tekst af te drukken
voidDisplay(tekenreeks)
{
kosten<<'De methode Display() wordt aangeroepen vanuit de '<<P<<' wijzer.N';
}
};
intmain()
{
// Initialiseer shared_ptr zonder de constructor aan te roepen
shared_ptr p1=make_shared();
p1->Weergave('eerst');
// Initialiseer shared_ptr door constructor aan te roepen
shared_ptr p2=shared_ptr(nieuweMyClass);
p2->Weergave('tweede');
// Initialiseer shared_ptr per opdracht
shared_ptr p3=p1;
p3->Weergave('derde');
return0;
}
Uitgang:
De volgende uitvoer verschijnt na het uitvoeren van de bovenstaande code. De constructor heeft alleen aangeroepen op het moment van het maken van het tweede object. Het bericht van de constructor is dus maar één keer afgedrukt:
Voorbeeld 2: Druk de opgeslagen gedeelde aanwijzerlocatie af
De get() functie gedeelde aanwijzer wordt gebruikt om de opgeslagen, gedeelde aanwijzerlocatie te retourneren. In het volgende voorbeeld wordt de locatie afgedrukt van de opgeslagen, gedeelde pointers die zijn gemaakt door de klasse en de functie. Hier is een klasse met een constructor gedefinieerd om te worden gebruikt voor het maken van een gedeelde aanwijzer. Er is een functie gedeclareerd om een gedeelde aanwijzer te maken en de locatie van de gedeelde aanwijzer af te drukken met behulp van de functie get(). In deze code is de eerste gedeelde aanwijzer gemaakt met behulp van de klasse, de tweede gedeelde aanwijzer is gemaakt met behulp van de functie en de derde gedeelde aanwijzer is gemaakt door de eerste aanwijzer toe te wijzen.
//Benodigde bibliotheken opnemen#erbij betrekken
#erbij betrekken
namespace std; gebruiken;
//Definieer de klasse
classMyClass
{
openbaar:
//Declareer de constructor
Mijn klas() {
kosten<<'De constructeur wordt gebeld.N';
}
};
// Definieer functie om de aanwijzer te initialiseren
voidInit_shared_ptr()
{
shared_ptr p2(nieuweMyClass);
kosten<<p2.krijgen() <<'N';
}
intmain()
{
// Initialiseer shared_ptr door constructor aan te roepen
shared_ptr p1=shared_ptr(nieuweMyClass);
kosten<<p1.krijgen() <<'N';
// Initialiseer shared_ptr door functie aan te roepen
Init_shared_ptr();
// Initialiseer shared_ptr per opdracht
shared_ptr p3=p1;
kosten<<p3.krijgen() <<'N';
return0;
}
Uitgang:
De volgende vergelijkbare uitvoer verschijnt na het uitvoeren van de bovenstaande code. In de uitvoer is de geretourneerde waarde van de functie get() voor de eerste en derde gedeelde pointers hetzelfde. De tweede gedeelde aanwijzer is echter anders:
Voorbeeld 3: Tel de gedeelde aanwijzerobjecten
In het volgende voorbeeld wordt een manier weergegeven om het aantal objecten te tellen waarnaar een gedeelde aanwijzer verwijst nadat de aanwijzer is gemaakt en vernietigd. Een klasse met een constructor is gedeclareerd in de code. De eerste gedeelde aanwijzer is gemaakt met behulp van de klasse en de tweede gedeelde aanwijzer is gemaakt met behulp van de eerste gedeelde aanwijzer. Het aantal objecten waarnaar wordt verwezen door beide gedeelde aanwijzers voor en na het aanroepen van de reset()-functie is later afgedrukt.
//Benodigde bibliotheken opnemen#erbij betrekken
#erbij betrekken
namespace std; gebruiken;
//Definieer de klasse
classMyClass{
openbaar:
//Declareer de constructor
Mijn klas() {
kosten<<'De constructeur wordt gebeld.N';
}
};
intmain()
{
// Initialiseer de eerste shared_ptr door constructor . aan te roepen
shared_ptr p1(nieuweMyClass);
// Geef het aantal shared_ptr-objecten weer met de eerste aanwijzer
kosten<<'p1 wijzend naar '<<p1.use_count() <<' voorwerpen).N';
// Initialiseer de tweede shared_ptr met de eerste shared_ptr
shared_ptr p2(p1);
// Geef het aantal shared_ptr-objecten weer met de eerste en tweede wijzers
kosten<<'p2 wijzend naar '<<p2.use_count() <<' voorwerpen).N';
kosten<<'p1 wijzend naar '<<p1.use_count() <<' voorwerpen).N';
//Verwijder het eigendom van de eerste aanwijzer van het shared_ptr-object
p1.resetten();
// Geef het aantal shared_ptr-objecten weer met de tweede aanwijzer
kosten<<'p2 wijzend naar '<<p2.use_count() <<' voorwerpen).N';
return0;
}
Uitgang:
De volgende uitvoer verschijnt na het uitvoeren van de bovenstaande code. De eerste wijzer, p1 , verwijst naar één object na creatie. Nadat u de tweede aanwijzer hebt gemaakt, p2 , met behulp van de eerste aanwijzer, p1 , wijzen beide aanwijzers naar twee objecten om de aanwijzer te delen. Na het aanroepen van de reset() functie voor de aanwijzer, p1 , één object is vernietigd en de aanwijzer, p2 , wijst nu naar slechts één object.
Conclusie:
De doeleinden van het gebruik van een gedeelde aanwijzer in C++ zijn in deze zelfstudie uitgelegd aan de hand van eenvoudige voorbeelden. Gedeelde aanwijzers op verschillende manieren maken, opgeslagen gedeelde aanwijzerlocatie verkrijgen en het aantal objecten tellen dat door de gedeelde aanwijzers wordt verwezen. Ik hoop dat de C++-programmeurs de gedeelde aanwijzer in hun code kunnen gebruiken na het lezen van deze tutorial.