Standard konstruktør i C ++

“Når et objekt opprettes i C ++, kalles en spesiell teknikk som heter funksjonskonstruktøren umiddelbart. Generelt brukes den til å konfigurere medlemsfunksjoner for nye klasser. I C ++ fungerer klassenavnet som tittelen på konstruktøren. Hver gang vi lager et objekt, må vi påkalle konstruktøren. Det skaper verdiene, jeg.e., leverer elementet med data; Dette er grunnen til at det blir referert til som konstruktør.

Standardkonstruktøren brukes til å generere objektene uten en forhåndsdefinert initialverdi. En konstruktør kan ha standardparametere så vel som standardverdier. Hvis brukeren ikke spesifiserer en standardkonstruktør, kan kompilatoren automatisk konstruere en og definere den etter behov. Noen konfigurasjoner av klasseintervallene må utføres av standardkonstruktøren som er spesifisert av kompilatoren. Men avhengig av situasjonen oppretter kompilatoren instruksjoner for standardkonstruktøren.

Vi vil gå over standardkonstruktørens funksjonalitet i denne artikkelen.”

Eksempel nr. 1

La oss definere en klasse som arves av en annen klasse som har en standardkonstruktør eller opprette en klasse som inneholder et element i en annen klasse som har en standardkonstruktør. Det integrerte objektet for klassen og det integrerte objektet til standardkonstruktørene må påberopes av kompilatoren ved å inkorporere programmet.

#inkludere
ved hjelp av navneområdet STD;
Klassebase
offentlig:
;
Klasse X
offentlig:
X () cout << "X Constructor" << endl;
int -størrelse;
;
Klasse L: public x
;
Klasse M: public x
offentlig:
M ()

cout << "M Constructor" << endl;

;
klasse n
offentlig:
N ()

cout << "N Constructor" << endl;

privat:
X x;
;
int main ()

Base base;
L l;
M m;
N n;
retur 0;

Først av alt vil vi integrere biblioteket . Denne overskriftsfilen vil inneholde forskjellige inngangs- og utgangsfunksjoner. Så bruker vi standard navneområdet. I neste trinn lager vi en baseklasse. Her vil kompilatoren erklære konstruktøren. Og vi setter den til offentlig. Nå lager vi en klasse som heter x. Den brukerdefinerte konstruktøren vil bli kalt offentlig. Vi initialiserer en variabel "størrelse".

Videre vil vi lage et objekt av klasse “L”. Formålet med denne klassen vil bli satt som offentlig. Her definerer kompilatoren standardkonstruktøren for "L" -klassen, og vi setter klassen for å ringe objektkonstruktøren. Kompilatoren ville ikke initialisere noen verdi av klasse X. Nå igjen lager vi en ny klasse som heter M. Vi konstruerer objektet til klasse M, og deretter spesifiserer vi det som offentlig.

Innenfor denne klassen lager vi en brukerdefinert konstruktør av klasse M. Kompilatoren vil integrere klassen for å påkalle X -konstruktøren. "Cout" -uttalelsen vil bli brukt til å vise utfallet. La oss lage en annen klasse, n. Vi lager offentlig en konstruktør av denne klassen. Dette vil være den brukerdefinerte konstruktøren. Da settes "cout" -kommandoen inn for å vise resultatet.

Her initialiserte ikke kompilatoren igjen noe innhold relatert til klasse N. Videre ville vi konstruere objektet "x" til klassen "x". Og dette elementet i klassen kan holdes privat. Nå kaller vi hovedfunksjonen (). Vi påkaller gjenstandene i forskjellige klasser.

Eksempel nr. 2

Kompilatoren må kanskje sette inn kode i en rekke situasjoner for å bekrefte at det kreves en viss konfigurasjon av språket. Standardkonstruktøren i dette tilfellet har to argumenter: et enkelt argument og et standardargument. Det er for øyeblikket to metoder for å påkalle standardkonstruktøren:

For det første kan vi gi begge verdiene for parametrene som vil bli gitt til standardkonstruktøren, og erstatte standardparameteren med verdien som ble gitt når vi utførte standardkonstruktøren.

Den andre tilnærmingen brukes til å indikere at standardargumentet er tomt. Når du gjør dette, vil "J" beregne en summering på 5 og bruke standardverdien på 0 som ønsket verdi.

#inkludere
ved hjelp av navneområdet STD;
Klasse F
offentlig:
int s = 0;
F ();
F (int i, int j = 0)

s = i + j;

void print () cout << "Sum of two numbers =" << s << endl;
;
int main ()

F o_1 (23, 50);
F o_2 (5);
O_1.skrive ut();
O_2.skrive ut();
retur 0;

Her skal vi inkludere biblioteket . Så bruker vi standard navneområde som STD. Nå lager vi klassen som heter “F”. Innenfor denne klassen vil vi initialisere variabelen som kalles "S". Her har standard konstruktør ingen argumenter. Navnet på konstruktøren og klassen vil være det samme. Vi oppretter en annen standardkonstruktør i klassen “F”. Men her passerer vi to variabler (i og j) som parameteren til konstruktøren.

Dessuten vil vi bruke formlene for summen. Her tilfører vi verdien av en variabel til en annen. Deretter kaller vi Void Print () -metoden, og sammen med dette bruker vi "Cout" -uttalelsen for å skrive ut uttalelsen "Summen av to verdier". La oss nå starte kodingen inne i kroppen til hovedfunksjonen () etter å ha ringt denne funksjonen. Vi lager to forskjellige objekter i klasse F. Det første objektet, "O_1," har to heltallverdier som argumenter. Den andre variabelen, “O_2,” inneholder bare 1 verdi som parameter.

Vi vil påkalle konstruktøren i disse to mulige tilnærmingene. Vi bruker metoden Print () for begge disse objektene for å vise utgangen. Til slutt ville vi ha brukt uttalelsen om "retur 0".

Konklusjon

I dette innlegget snakket vi om driften av standardkonstruktøren. Konstruktøren beholder en lignende tittel som klassen, er åpen for publikum, og inneholder derfor ingen returtype. I en standardkonstruktør vil vi gi ingen parametere. Vi har kjørt en rekke programmer, hvorav den ene viser hvordan du bruker standardkonstruktøren. Vi illustrerer at konstruktører vil ha standardparametere i det andre eksemplet. Vi lager to standardkonstruktører, den ene uten argumenter og den andre med to argumenter, og deretter evaluerer vi funksjonaliteten deres.