C ++ Parola chiave esplicita

In C ++, utilizziamo parentesi e pareti ricci per inizializzare gli elementi e passare i parametri per invocare diversi costruttori. Questo tipo di inizializzazione è noto come inizializzazione esplicita. Esplicito viene utilizzato prima del costruttore, che viene dichiarato in modo che il costruttore non richieda la parola chiave "esplicita" per eseguire una conversione implicita. È definito per sfuggire ad alcune conversioni implicite se la classe detiene qualsiasi oggetto, quindi ha un costruttore di argomenti.

I compilatori generalmente considerano conversioni implicite o costruttori di conversione. Ciò può comportare un risultato indesiderabile. Per ignorare tali conseguenze, usiamo la parola "esplicito" davanti al costruttore. Complessivamente, i costruttori espliciti sono dichiarati quando i costruttori impliciti non sono disponibili e i costruttori espliciti contengono uno o più parametri. Quando tentiamo di eseguire il codice che utilizza lo specificatore "esplicito" nel costruttore, troviamo un errore di compilazione.

Questo articolo descrive parole chiave esplicite utilizzate per i costruttori che non possono utilizzare un costruttore implicito. Utilizziamo il software "Dev C ++" per eseguire i codici.

Costruttore di conversione esplicito:

In C ++, i costruttori vengono utilizzati principalmente per inizializzare o creare oggetti per le classi consegnate dal compilatore per impostazione predefinita. Potremmo usare questo tipo di costruttore per conversioni esplicite. Questa parola chiave esplicita è facoltativa in cui passiamo solo un argomento alla volta. Questo costruttore può essere utilizzato negli stereotipi:

#includere
Utilizzo dello spazio dei nomi std;
Classe X
char variabile_a;
pubblico:
X()
X (char a): variabile_a (a) ;
void print () std :: cout << "Value is "<< variable_a <;
void disp (x i)

io.stampa();

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);
restituzione 0;

In questo programma, definiamo innanzitutto la classe "x" che dichiara la variabile definita "variabile_a" del tipo di carattere. Quindi, creiamo il costruttore predefinito con parametri zero e il costruttore di argomenti singolo con un'altra classe che ha la "variabile_a" del tipo di carattere. Viene stampato il valore creato e quindi passato come argomento alla funzione. Qui, dobbiamo solo passare qualsiasi valore del tipo di carattere, ma nella funzione principale (), utilizziamo il primo oggetto chiamato "OBJ1" della Classe X. Dopo questo, passiamo la "M" come argomento a una funzione dis (). Pertanto, il valore viene stampato quando il costruttore viene generalmente chiamato.

Supponiamo di creare un secondo oggetto, "obj2", della classe X, e la funzione disp () viene passata. Quindi, passeremo una discussione sulla classe "X". Quindi, se chiamiamo la funzione disp () e assegniamo l'alfabeto "n" del carattere di tipo all'oggetto "obj2", il compilatore cambia indirettamente questa variabile di tipo "x" in una variabile di tipo carattere. Fornisce output nel valore dei caratteri. Usiamo un argomento e mettiamo la parola chiave "esplicita" nel costruttore per evitarlo con una chiamata implicita:

Confronta due numeri complessi:

Utilizziamo la parola chiave "esplicita" per il costruttore definito per indicare che il costruttore viene esplicitamente chiamato con l'aiuto di parentesi curnee e parentesi quadrate. Il compilatore lancia un errore quando l'utente tenta di chiamare un costruttore esplicito con l'aiuto di un operatore di assegnazione "=".
In questo codice, creiamo una classe "complesso_number". Quindi, facciamo variabili del doppio tipo di dati e inseriamo queste variabili private. Se la classe contiene un costruttore in cui passiamo un solo argomento, quel costruttore sarà un costruttore di conversione. Possiamo ignorare queste conversioni implicite in quanto possono darci output inaspettati. Quindi, creiamo esplicitamente il costruttore usando la parola chiave "esplicita":

#includere
Utilizzo dello spazio dei nomi std;
Classe XYZ

privato:
int b;
int c;
pubblico:
xyz (int u = 0, int v = 0): b (u), c (v)
Bool Operator == (xyz e)
restituzione (b == e.b && c == e.C)? falsa verità;

;
int main ()

XYZ OBJ (12, 23);
if (obj == 12)
cout << "matched";
altro
cout << "Not matched";
restituzione 0;

Nel corpo della funzione principale, dichiariamo valori all'oggetto della classe. Applichiamo la condizione if-else per confrontare due numeri complessi. Qui, controlliamo se il valore dato passato come argomento è uguale ai valori di un oggetto. L'output del codice precedente è il seguente:

Usando due argomenti:

Se non possiamo controllare la conversione implicita, dobbiamo richiedere un costruttore con una parola chiave esplicita per il costruttore nella classe. Non possiamo utilizzare questa parola chiave nel costruttore predefinito. Nel complesso, affermare che la parola chiave "esplicita" come identificatore di funzione per un costruttore ha uno o più parametri in una dichiarazione di classe viene utilizzato per proteggere la classe da conversioni di tipo non necessarie. Altrimenti, senza questa parola chiave, potrebbe essere un costruttore di conversione:

#includere
Utilizzo dello spazio dei nomi std;
Class Complex_number

privato:
doppio rnum;
doppio inum;
pubblico:
esplicito complesso_number (doppio r = 0.0, doppio i = 0.0): rnum (r), inum (i)
bool operator == (complesso_number ABC)
return (rnum == ABC.rnum && inum == ABC.inum)? vero falso;

;
int main ()

Complesso_number comp (9.0, 4.0);
if (comp == (complex_number) 7.0)
cout << "Same";
altro
cout << "Not Same";
restituzione 0;

In questo caso, creiamo una classe chiamata "XYZ". Passiamo due parametri nel costruttore. È generalmente il modo migliore per utilizzare esplicitamente un costruttore di argomenti. Dal momento che può essere confuso se chiamiamo due o più argomenti per i costruttori nella funzione principale. Ancora una volta, qui il costruttore è implicitamente dichiarato dal compilatore. Logicamente, per evitare l'implementazione del programma inutile che potrebbe portare all'output, non è così facile convertire il tipo, quindi utilizzare la parola chiave "esplicita" in C ++ per il costruttore:

Conclusione:

In questo articolo, determiniamo che la parola chiave specifica "esplicita" viene generalmente utilizzata per i costruttori utilizzati per creare oggetti di classe nell'asserzione di classe. Abbiamo anche notato che la parola chiave esplicita è la più efficace per i costruttori. Allo stesso tempo, dobbiamo tenere lontano dalle chiamate implicite attraverso i compilatori che in genere creano i costruttori come costruttori mutevoli. Cambia le variabili da un tipo a un altro tipo che non è accurato. È un modo eccezionale di utilizzare costantemente questa parola chiave in tali istanze. Speriamo che tu abbia trovato questo articolo utile. Dai un'occhiata ad altri articoli di suggerimento Linux per ulteriori suggerimenti e informazioni.