C ++ explizite Schlüsselwort

In C ++ verwenden wir Klammern und lockige Zahnspangen, um die Elemente zu initialisieren und die Parameter zu übergeben, um verschiedene Konstrukteure aufzurufen. Diese Art der Initialisierung wird als explizite Initialisierung bezeichnet. Explizit wird vor dem Konstruktor verwendet, der so deklariert wird, dass der Konstruktor nicht das Schlüsselwort „Explizit“ benötigt, um eine implizite Konvertierung durchzuführen. Es ist definiert, um einigen impliziten Konvertierungen zu entkommen, wenn die Klasse ein Objekt besitzt, so dass es einen Argumentkonstruktor hat.

Compiler berücksichtigen im Allgemeinen implizite Conversions oder Conversion -Konstruktoren. Dies kann zu einem unerwünschten Ergebnis führen. Um solche Konsequenzen zu ignorieren, verwenden wir das Wort „explizit“ vor dem Konstruktor. Insgesamt werden explizite Konstruktoren deklariert, wenn implizite Konstruktoren nicht verfügbar sind, und die expliziten Konstruktoren enthalten einen oder mehrere Parameter. Wenn wir versuchen, den Code auszuführen, der den Spezifizierer „explizit“ im Konstruktor verwendet, finden wir einen Kompilierfehler.

Dieser Artikel beschreibt explizite Schlüsselwörter, die für Konstruktoren verwendet werden, die keinen impliziten Konstruktor verwenden können. Wir verwenden Software "Dev C ++", um die Codes auszuführen.

Explizite Konvertierungskonstruktor:

In C ++ werden die Konstruktoren hauptsächlich zum Initialisieren oder Erstellen von Objekten für Klassen verwendet, die standardmäßig vom Compiler geliefert werden. Wir können diese Art von Konstruktor für explizite Conversions verwenden. Dieses ausdrückliche Schlüsselwort ist optional, bei dem wir jeweils nur ein Argument verabschieden. Dieser Konstruktor kann bei der Stereotypisierung verwendet werden:

#enthalten
Verwenden von Namespace STD;
Klasse x
char variable_a;
öffentlich:
X()
X (char a): variable_a (a) ;
void print () std :: cout << "Value is "<< variable_a <;
Hohlraum disp (x i)

ich.drucken();

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);
Rückkehr 0;

In diesem Programm definieren wir zunächst die Klasse „x“, die die Variable als "variable_a" des Zeichentyps deklariert. Anschließend machen wir den Standardkonstruktor mit Nullparametern und dem einzelnen Argumentkonstruktor mit einer anderen Klasse mit dem Zeichen "variable_a" des Zeichentyps. Der Wert erstellt und dann als Argument an die Funktion übergeben wird gedruckt. Hier müssen wir nur einen beliebigen Charakter -Typ -Wert übergeben, aber in der Funktion main () verwenden wir das erste Objekt, das als „obj1“ der Klasse X bezeichnet wird. Danach geben wir das „M“ als Argument an eine Disp () -Funktion über. Somit wird der Wert gedruckt, wenn der Konstruktor normalerweise aufgerufen wird.

Nehmen wir an, wir erstellen ein zweites Objekt, „OBJ2“, von Klasse X, und der Funktionsdisp () wird übergeben. Dann werden wir ein Argument der Klasse "x" verabschieden. Wenn wir also den Funktionsdisp () aufrufen und das Alphabet „n“ des Typzeichens dem Objekt „OBJ2“ zuweisen, ändert der Compiler diese Variable des Typs „x“ indirekt in eine Variable des Typs des Typs. Es liefert Ausgabe in Charakterwert. Wir verwenden ein Argument und setzen das Schlüsselwort „explizit“ in den Konstruktor, um dies mit einem impliziten Aufruf zu vermeiden:

Vergleichen Sie zwei komplexe Zahlen:

Wir verwenden das Schlüsselwort „explizit“, damit der definierte Konstruktor angibt. Der Compiler macht einen Fehler, wenn der Benutzer versucht, einen expliziten Konstruktor mit Hilfe eines Zuweisungsoperators "=" aufzurufen.
In diesem Code erstellen wir eine Klasse "Complex_Number". Dann machen wir Variablen des Doppel -Datentyps und setzen diese Variablen privat ein. Wenn die Klasse einen Konstruktor enthält, an dem wir nur ein Argument bestehen, ist dieser Konstruktor ein Konvertierungskonstruktor. Wir können diese impliziten Conversions ignorieren, da sie uns unerwartete Ausgänge geben können. Daher erstellen wir den Konstruktor explizit mit dem Schlüsselwort „explizit“:

#enthalten
Verwenden von Namespace STD;
Klasse XYZ

Privatgelände:
int b;
int c;
öffentlich:
xyz (int u = 0, int v = 0): b (u), c (v)
Bool Operator == (xyz e)
return (b == e.B && c == e.C)? Falsch Richtig;

;
int main ()

XYZ OBJ (12, 23);
if (obj == 12)
Cout << "matched";
anders
Cout << "Not matched";
Rückkehr 0;

Im Körper der Hauptfunktion deklarieren wir dem Objekt der Klasse Werte für Werte. Wir wenden die IF-ELSE-Bedingung an, um zwei komplexe Zahlen zu vergleichen. Hier prüfen wir, ob der als Argument übergebene angegebene Wert den Werten eines Objekts entspricht. Die Ausgabe des vorherigen Codes lautet wie folgt:

Verwenden Sie zwei Argumente:

Wenn wir die implizite Konvertierung nicht kontrollieren können, müssen wir einen Konstruktor mit einem expliziten Schlüsselwort für den Konstruktor in der Klassenbehauptung benötigen. Wir können dieses Schlüsselwort im Standardkonstruktor nicht verwenden. Insgesamt wird das Schlüsselwort „explizit“ als Funktionskennung für einen Konstruktor mit einem oder mehreren Parametern in einer Klassenerklärung verwendet, um die Klasse vor unnötigen Konvertierungen zu schützen. Andernfalls könnte es ohne dieses Schlüsselwort ein Konvertierungskonstruktor sein:

#enthalten
Verwenden von Namespace STD;
Klasse Complex_Number

Privatgelände:
doppeltes RNUM;
doppeltes Inum;
öffentlich:
explizite komplex_number (double r = 0.0, doppelte i = 0.0): rnum (r), Inum (i)
bool operator == (complex_number abc)
return (rnum == ABC.rnum && inum == ABC.Inum)? wahr falsch;

;
int main ()

Complex_number comp (9.0, 4.0);
if (comp == (complex_number) 7.0)
Cout << "Same";
anders
Cout << "Not Same";
Rückkehr 0;

In diesem Fall erstellen wir eine Klasse namens "XYZ". Wir übergeben zwei Parameter im Konstruktor. Dies ist im Allgemeinen der beste Weg, um einen Argumentkonstruktor explizit zu verwenden. Da es verwirrend sein kann, wenn wir zwei oder mehr Argumente für die Konstrukteure in der Hauptfunktion anrufen. Auch hier wird der Konstruktor implizit vom Compiler deklariert. Um eine unnötige Programmimplementierung zu vermeiden, die zu Ausgabe führen kann, ist es nicht so einfach, den Typ zu konvertieren. Verwenden Sie daher das Schlüsselwort „explizit“ in C ++ für den Konstruktor:

Abschluss:

In diesem Artikel stellen wir fest, dass das spezifische Schlüsselwort „explizit“ normalerweise für die Konstrukteure verwendet wird, die zur Erstellung von Klassenobjekten in der Klassenbehauptung verwendet werden. Wir haben auch festgestellt, dass das ausdrückliche Schlüsselwort für Konstrukteure am effektivsten ist. Gleichzeitig müssen wir uns von den impliziten Aufrufen durch die Compiler fernhalten, die die Konstrukteure normalerweise als sich ändernde Konstruktoren erstellen. Es ändert Variablen von einer Art zu einer anderen Art, was nicht genau ist. Dies ist eine außergewöhnliche Möglichkeit, dieses Schlüsselwort in solchen Fällen ständig zu verwenden. Wir hoffen, Sie haben diesen Artikel hilfreich gefunden. Weitere Tipps und Informationen finden Sie in anderen Linux -Hinweisartikeln.