C ++ STD -eier mindre

I denne artikkelen vil vi diskutere et funksjonsobjekt på C ++ språk, STD :: Eier_less. Full form er eierbasert mindre enn drift. For å forklare dette i detalj, må du forstå først hvilke funksjonsobjekter som er. Funksjonsobjekter er også kjent som funktorer i C++. Funktorer er som byggesteiner for å komponere større programmer. Det viktigste vi gjør i funktorer er at vi konstruerer objekter ut av funksjoner. Så det vi gjør i dette tilfellet er å bruke et objekt som en funksjon.

En funktor er en funksjon med en tilstand, og nøkkelen for å holde denne tilstanden er operatøren (). En funktor er en funksjon som oppnås ved å overbelaste søkeordoperatøren () i noen klasser. Så funktorer er objekter som fungerer som funksjoner. Den samme gamle syntaksfunksjonen brukes til å påkalle funktorer. En funktor er konstruert ved å lage et objekt som overbelaster operatøren. La oss nå diskutere eier_løs functor. Dette funktor- eller funksjonsobjektet, i stedet for verdibasert type bestilling, gir oss eierbasert bestilling av blandet type av både std :: svake_ptr og std :: shared_ptr.

Det har blitt bestilt på en slik måte at disse to smarte pekerne samsvarer like bare når begge deler deler eierskapet. Eller hvis begge er tomme selv når verdiene hentet fra getter -metoder for råpekere ikke er de samme. Disse utfører eierbaserte sammenligninger mellom svake pekere og delte pekere. “Eier_løs” brukes til å bestille adressen til kontrollblokken. Så den vurderer to svake pekere eller delte pekere som tilsvarer hvis de deler det samme eierskapet.

Syntaks:

Syntaks for eier mindre operatør er:

mal struct eier_løs;
eier_løs>

Standardbiblioteket til C ++ gir oss en spesialisering av STD :: Eier_løs når “T” ikke initialiseres. I tilfelle av det trekkes parametrene fra parameterlisten.

Merk at dette er en mal for eier_løs. Det har ikke en spesifikk syntaks, da det er en tilnærming for å løse et problem ved å bruke smarte pekere og funktorer.

Medlemmene av eier_less

bool operatør () (const std :: shared_ptr& LHS,
const std :: shared_ptr& rhs) const noescept

Eksempel # 01:

For å gjøre det har vi ikke skrevet noen kompleks kode som bruker noen struktur, klasse, funksjon eller noe programmeringsobjekt som disse. I stedet prøvde vi å skrive en kode som kan være så enkel som mulig direkte i hovedmetoden vår. Vi initialiserte en peker av et datatype heltall med en lengde på 10.

Etter det erklærte vi en delt peker “X” med en lengde på 20. Vi har erklært en annen delt peker y med lengden som den delte pekeren “x”. I neste linje har vi satt pekeren til verdibasert. I linje nummer 12 har vi satt pekerne våre til eierløse pekere. Nå vil vi utføre verdibaserte innsettinger for våre pekere x og y.

Etter det vil vi gjøre det samme, men eier basert på pekerne våre X og Y ved å bruke vår functor std :: eier_less. Vær oppmerksom på at vi har skrevet den samme koden for både verdibaserte og eierbaserte pekere. Den eneste forskjellen er at vi bruker STD :: Eier_less nøkkelord for eierbaserte pekere.

Nå, for å vise deg verdiforskjellen og størrelsesforskjellen mellom de to tilnærmingene, har vi skrevet ut størrelsen på både verdibaserte og eierbaserte pekere. Etter det, på linje nummer 20, slettet vi pekeren vi opprettet opprinnelig i begynnelsen av vår viktigste funksjon. I den siste linjen har vi returnert 0 fordi returtypen til hovedmetoden vår er et heltall. Så vi har returnert 0. Nå vil vi utføre koden vår og sjekke resultatet vårt.

#inkludere
#inkludere
#inkludere
int main ()

int * peker = ny int (10);
std :: shared_ptr x (ny int (20));
std :: shared_ptr y (x, peker);
std :: sett < std::shared_ptr > verdi_basert;
std :: sett < std::shared_ptr, std :: eier_løs>> eier_basert;
verdi_basert.sett inn (x);
verdi_basert.sett inn (y);
eier_basert.sett inn (x);
eier_basert.sett inn (y);
std :: cout << "value_based.size() is " << value_based.size() << '\n';
std :: cout << "owner_based.size() is " << owner_based.size() << '\n';
slett pekeren;
retur 0;

Utgangen vi får fra ovennevnte kode er som følger. Hvis vi tar en titt på utgangen, kan vi se at størrelsen på den verdibaserte pekeren er 2 og størrelsen på eierbasert peker er 1. Spørsmålet oppstår her er at hvis vi utførte de samme trinnene for dem begge? Svaret er at som vi diskuterte tidligere i introduksjonen, gir denne funktoren eierbasert type bestilling og de to pekerne sammenligner tilsvarende hvis de deler samme eierskap. Men hvis verdiene er forskjellige for begge pekere, hvorfor deler de det samme eierskapet?

Så dette er den viktigste fordelen med det eierløse funksjonsobjektet selv om verdiene er forskjellige og ikke like, de deler det samme eierskapet. Det er grunnen til at størrelsen på verdibasert er to fordi den har to tips og begge har forskjellige eierskap. Men hos eierbasert bruker vi eierløse funktorer som skyldes deling av samme eierskap, størrelsen er en. I vårt tilfelle, siden de to delte pekerne har samme eierskap, er det grunnen til at de anses som likeverdige og størrelsen på eierbasen blir 1.

Konklusjon

I denne guiden diskuterte vi et type funksjonsobjekt i C ++ som er std :: eier_løs. Vi forklarte om funksjonsobjekter, hvordan disse objektene brukes og hvordan disse blir erklært og kalt. Etter det diskuterte vi std :: eier_løse funksjonsobjekter og forklarte applikasjonene og definisjonen når det gjelder programmering. Senere forklarte vi syntaks og tok en titt på medlemmene deres. Vi utførte også et praktisk eksempel angående emnet for å få deg til å forstå konseptet mer detaljert. For å avslutte dette emnet, kan vi si at std :: eier_less definerer funktorer eller funksjonsobjekter som utfører eierbaserte sammenligninger mellom svake pekere og delte pekere.