Mot-clé explicite C ++

En C ++, nous utilisons les parenthèses et les accolades bouclées pour initialiser les éléments et passer les paramètres pour invoquer différents constructeurs. Ce type d'initialisation est connu sous le nom d'initialisation explicite. Explicite est utilisé avant le constructeur, qui est déclaré afin que le constructeur ne nécessite pas le mot-clé «explicite» pour effectuer une conversion implicite. Il est défini pour échapper à certaines conversions implicites si la classe détient un objet, il a donc un constructeur d'argument.

Les compilateurs considèrent généralement des conversions implicites ou des constructeurs de conversion. Cela peut entraîner un résultat indésirable. Pour ignorer ces conséquences, nous utilisons le mot «explicite» devant le constructeur. Dans l'ensemble, les constructeurs explicites sont déclarés lorsque des constructeurs implicites ne sont pas disponibles, et les constructeurs explicites contiennent un ou plusieurs paramètres. Lorsque nous essayons d'exécuter le code qui utilise le spécificateur «explicite» dans le constructeur, nous trouvons une erreur de compilation.

Cet article décrit des mots clés explicites utilisés pour les constructeurs qui ne peuvent pas utiliser un constructeur implicite. Nous utilisons le logiciel «Dev C ++» pour exécuter les codes.

Constructeur de conversion explicite:

En C ++, les constructeurs sont principalement utilisés pour initialiser ou créer des objets pour les classes livrées par le compilateur par défaut. Nous pouvons utiliser ce type de constructeur pour des conversions explicites. Ce mot-clé explicite est facultatif dans lequel nous ne faisons qu'un seul argument à la fois. Ce constructeur peut être utilisé dans les stéréotypes:

#inclure
Utilisation de Namespace Std;
classe x
char variable_a;
public:
X()
X (char a): variable_a (a) ;
void print () std :: cout << "Value is "<< variable_a <;
void disp (x i)

je.imprimer();

int main()

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

Dans ce programme, nous définissons d'abord la classe «x» qui déclare la variable appelée «variable_a» de type de caractère. Ensuite, nous faisons le constructeur par défaut ayant zéro paramètres et le constructeur d'argument unique avec une autre classe qui a la «variable_a» du type de caractère. La valeur créée puis transmise comme argument à la fonction est imprimée. Ici, nous avons juste besoin de passer n'importe quelle valeur de type de caractère, mais dans la fonction principale (), nous utilisons le premier objet nommé «Obj1» de la classe X. Après cela, nous passons le «M» comme argument à une fonction DISP (). Ainsi, la valeur est imprimée lorsque le constructeur est généralement appelé.

Supposons que nous créons un deuxième objet, «Obj2», de la classe X, et la fonction disp () est passé. Ensuite, nous passerons un argument de la classe «x». Par conséquent, si nous appelons la fonction disp () et attribuons l'alphabet «n» du caractère de type pour objecter «obj2», le compilateur modifie indirectement cette variable de type «x» à une variable de caractère de type. Il fournit la sortie en valeur de caractère. Nous utilisons un argument et mettons le mot-clé «explicite» dans le constructeur pour éviter cela avec un appel implicite:

Comparez deux nombres complexes:

Nous utilisons le mot-clé «explicite» pour que le constructeur défini indique que le constructeur est explicitement appelé à l'aide de bretelles bouclées et de crochets. Le compilateur lance une erreur lorsque l'utilisateur tente d'appeler un constructeur explicite à l'aide d'un opérateur d'affectation «=».
Dans ce code, nous créons une classe "complex_number". Ensuite, nous fabriquons des variables de type de données doubles et mettons ces variables privées. Si la classe contient un constructeur dans lequel nous ne transmettons qu'un seul argument, ce constructeur sera un constructeur de conversion. Nous pouvons ignorer ces conversions implicites car elles peuvent nous donner des sorties inattendues. Par conséquent, nous créons explicitement le constructeur à l'aide du mot-clé «explicite»:

#inclure
Utilisation de Namespace Std;
classe XYZ

privé:
int b;
INT C;
public:
xyz (int u = 0, int v = 0): b (u), c (v)
Bool Operator == (xyz e)
retour (b == e.b && c == e.c)? faux vrai;

;
int main()

xyz obj (12, 23);
if (obj == 12)
couter << "matched";
autre
couter << "Not matched";
retour 0;

Dans le corps de la fonction principale, nous déclarons les valeurs à l'objet de la classe. Nous appliquons la condition IF-Else pour comparer deux nombres complexes. Ici, nous vérifions si la valeur donnée transmise comme argument est égale aux valeurs d'un objet. La sortie du code précédent est la suivante:

Utilisation de deux arguments:

Si nous ne pouvons pas contrôler la conversion implicite, nous devons avoir besoin d'un constructeur avec un mot-clé explicite pour le constructeur dans l'affirmation de la classe. Nous ne pouvons pas utiliser ce mot-clé dans le constructeur par défaut. Dans l'ensemble, indiquant le mot-clé «explicite» en tant qu'identifiant de fonction pour un constructeur ayant un ou plusieurs paramètres dans une déclaration de classe est utilisé pour protéger la classe des conversions de type inutile. Sinon, sans ce mot-clé, il pourrait s'agir d'un constructeur de conversion:

#inclure
Utilisation de Namespace Std;
classe complex_number

privé:
Double RNUM;
double inum;
public:
Explicit complex_number (double r = 0.0, double i = 0.0): rnum (r), inum (i)
Bool Operator == (complex_number ABC)
retour (rnum == ABC.rnum && inum == ABC.inum)? vrai faux;

;
int main()

Complex_number comp (9.0, 4.0);
if (comp == (complex_number) 7.0)
couter << "Same";
autre
couter << "Not Same";
retour 0;

Dans ce cas, nous créons une classe nommée «XYZ». Nous passons deux paramètres dans le constructeur. C'est généralement le meilleur moyen d'utiliser explicitement un constructeur d'argument. Car cela peut être déroutant si nous appelons deux ou plusieurs arguments pour les constructeurs de la fonction principale. Encore une fois, le constructeur est implicitement déclaré par le compilateur. Logiquement, pour éviter une implémentation de programme inutile qui pourrait conduire à la sortie, il n'est pas si facile de convertir le type, alors utilisez le mot-clé «explicite» en C ++ pour le constructeur:

Conclusion:

Dans cet article, nous déterminons que le mot-clé spécifique «explicite» est généralement utilisé pour les constructeurs utilisés pour fabriquer des objets de classe dans l'affirmation de la classe. Nous avons également remarqué que le mot-clé explicite est le plus efficace pour les constructeurs. Dans le même temps, nous devons nous éloigner des appels implicites à travers les compilateurs qui créent généralement les constructeurs en tant que constructeurs changeants. Il modifie les variables d'un type à un autre qui n'est pas exact. C'est un moyen exceptionnel d'utiliser constamment ce mot-clé dans de tels cas. Nous espérons que vous avez trouvé cet article utile. Consultez d'autres articles sur les conseils Linux pour plus de conseils et d'informations.