C ++ eksplisitt nøkkelord

I C ++ bruker vi parentes og krøllete seler for å initialisere elementene og passere parametrene for å påkalle forskjellige konstruktører. Denne typen initialisering er kjent som eksplisitt initialisering. Eksplisitt brukes før konstruktøren, som er erklært slik at konstruktøren ikke krever det "eksplisitte" nøkkelordet for å utføre en implisitt konvertering. Det er definert å unnslippe noen implisitte konverteringer hvis klassen har noe objekt, så den har ett argumentkonstruktør.

Kompilatorer vurderer generelt implisitte konverteringer eller konverteringskonstruktører. Dette kan resultere i et uønsket resultat. For å ignorere slike konsekvenser, bruker vi ordet “eksplisitt” før konstruktøren. Totalt sett er eksplisitte konstruktører erklært når implisitte konstruktører ikke er tilgjengelige, og de eksplisitte konstruktørene inneholder en eller flere parametere. Når vi prøver å kjøre koden som bruker spesifikasjonen "eksplisitt" i konstruktøren, finner vi en kompileringsfeil.

Denne artikkelen beskriver eksplisitte nøkkelord som brukes til konstruktører som ikke kan bruke en implisitt konstruktør. Vi bruker programvare “Dev C ++” for å utføre kodene.

Eksplisitt konverteringskonstruktør:

I C ++ blir konstruktørene først og fremst brukt til å initialisere eller lage objekter for klasser levert av kompilatoren som standard. Vi kan bruke denne typen konstruktør for eksplisitte konverteringer. Dette nøkkelordet eksplisitt er valgfritt der vi bare passerer ett argument om gangen. Denne konstruktøren kan brukes i stereotyping:

#inkludere
ved hjelp av navneområdet STD;
Klasse X
char variabel_a;
offentlig:
X ()
X (char a): variabel_a (a) ;
void print () std :: cout << "Value is "<< variable_a <;
void disp (x i)

Jeg.skrive ut();

int main ()

X obj1 ('m');
X obj2 = 'n';
cout<<"When we call constructor normally, this is the value :" << endl;
disp (obj1);
cout<<"\n" <cout<<"We get this value after the compiler implicitly changes it to character type from X type is : " << endl;
disp (obj2);
retur 0;

I dette programmet definerer vi først klassen "X" som erklærer variabelen som kalles "variabel_a" av karaktertype. Deretter lager vi standardkonstruktøren som har null parametere og den enkelt argumentkonstruktøren med en annen klasse som har "variable_a" av karaktertype. Verdien som er opprettet og deretter ført som et argument til funksjonen, skrives ut. Her trenger vi bare å passere en hvilken. Etter dette passerer vi “M” som et argument til en disp () -funksjon. Dermed skrives verdien ut når konstruktøren vanligvis kalles.

Anta at vi oppretter et annet objekt, “OBJ2”, av klasse X, og funksjonen Disp () er bestått. Deretter vil vi gi et argument fra klasse “x”. Derfor, hvis vi kaller funksjonsdisp () og tilordner alfabetet "n" av typekarakteren til objektet "obj2", endrer kompilatoren indirekte denne variabelen av typen "x" til en variabel av typen tegn. Det gir utgang i karakterverdi. Vi bruker ett argument og setter søkeordet "eksplisitt" i konstruktøren for å unngå dette med en implisitt samtale:

Sammenlign to komplekse tall:

Vi bruker nøkkelordet "eksplisitt" for den definerte konstruktøren for å indikere at konstruktøren eksplisitt blir kalt ved hjelp av krøllete seler og firkantede parenteser. Kompilatoren kaster en feil når brukeren prøver å ringe en eksplisitt konstruktør ved hjelp av en oppdragsoperatør “=”.
I denne koden lager vi en klasse “Complex_number”. Deretter lager vi variabler av dobbel datatype og legger disse variablene private. Hvis klassen inneholder en konstruktør der vi bare passerer ett argument, vil konstruktøren være en konverteringskonstruktør. Vi kan ignorere disse implisitte konverteringene, da de kan gi oss uventede utganger. Derfor oppretter vi eksplisitt konstruktøren ved å bruke nøkkelordet “eksplisitt”:

#inkludere
ved hjelp av navneområdet STD;
Klasse XYZ

privat:
int b;
int c;
offentlig:
xyz (int u = 0, int v = 0): b (u), c (v)
bool operatør == (xyz e)
retur (b == e.b && c == e.c)? usann sannhet;

;
int main ()

xyz obj (12, 23);
if (obj == 12)
cout << "matched";
ellers
cout << "Not matched";
retur 0;

I kroppen av hovedfunksjonen erklærer vi verdier for objektet for klassen. Vi bruker IF-ests-tilstanden for å sammenligne to komplekse tall. Her sjekker vi om den gitte verdien som er gitt som et argument er lik verdiene til et objekt. Utgangen fra den forrige koden er som følger:

Bruke to argumenter:

Hvis vi ikke kan kontrollere den implisitte konverteringen, må vi kreve en konstruktør med et eksplisitt nøkkelord for konstruktøren i klassens påstand. Vi kan ikke bruke dette nøkkelordet i standardkonstruktøren. Totalt sett brukes nøkkelordet "eksplisitt" som en funksjonsidentifikator for en konstruktør som har en eller flere parametere i en klasse erklæring for å beskytte klassen mot unødvendige type konverteringer. Ellers, uten dette nøkkelordet, kan det være en konverteringskonstruktør:

#inkludere
ved hjelp av navneområdet STD;
Klassekompleks_nummer

privat:
dobbel rnum;
dobbel inum;
offentlig:
eksplisitt kompleks_nummer (dobbelt r = 0.0, dobbelt i = 0.0): rnum (r), inum (i)
bool operatør == (complex_number abc)
Retur (rnum == ABC.rnum && inum == ABC.inum)? sant: falsk;

;
int main ()

Complex_number comp (9.0, 4.0);
if (comp == (complex_number) 7.0)
cout << "Same";
ellers
cout << "Not Same";
retur 0;

I dette tilfellet lager vi en klasse som heter “XYZ”. Vi passerer to parametere i konstruktøren. Det er generelt den beste måten å eksplisitt bruke en argumentkonstruktør. Siden det kan være forvirrende hvis vi kaller to eller flere argumenter for konstruktørene i hovedfunksjonen. Igjen, her er konstruktøren implisitt erklært av kompilatoren. Logisk sett, for å unngå unødvendig programimplementering som kan føre til output, er det ikke så lett å konvertere typen, så bruk nøkkelordet "eksplisitt" i C ++ for konstruktøren:

Konklusjon:

I denne artikkelen bestemmer vi at det spesifikke nøkkelordet "eksplisitt" vanligvis brukes til konstruktørene som brukes til å lage klasseobjekter i klassens påstand. Vi la også merke til at nøkkelordet eksplisitt er det mest effektive for konstruktører. Samtidig må vi holde oss unna implisitte samtaler gjennom kompilatorene som vanligvis skaper konstruktørene som skiftende konstruktører. Det endrer variabler fra en art til en annen art som ikke er nøyaktig. Det er en eksepsjonell måte å hele tiden bruke dette nøkkelordet i slike tilfeller. Vi håper du fant denne artikkelen nyttig. Sjekk ut andre Linux -hint -artikler for flere tips og informasjon.