C ++ Palavra -chave explícita

Em C ++, utilizamos parênteses e aparelhos encaracolados para inicializar os itens e passar os parâmetros para invocar diferentes construtores. Este tipo de inicialização é conhecido como inicialização explícita. Explictic é utilizado antes do construtor, que é declarado para que o construtor não requer a palavra -chave "explícita" para realizar uma conversão implícita. É definido para escapar de algumas conversões implícitas se a classe possuir algum objeto, por isso possui um construtor de argumentos.

Os compiladores geralmente consideram conversões implícitas ou construtores de conversão. Isso pode resultar em um resultado indesejável. Para ignorar essas consequências, usamos a palavra "explícita" antes do construtor. No geral, os construtores explícitos são declarados quando os construtores implícitos não estão disponíveis, e os construtores explícitos contêm um ou mais parâmetros. Quando tentamos executar o código que usa o especificador "explícito" no construtor, encontramos um erro de compilação.

Este artigo descreve palavras -chave explícitas utilizadas para construtores que não podem utilizar um construtor implícito. Utilizamos o software "dev c ++" para executar os códigos.

Construtor de conversão explícito:

Em C ++, os construtores são utilizados principalmente para inicializar ou criar objetos para classes entregues pelo compilador por padrão. Podemos usar esse tipo de construtor para conversões explícitas. Esta palavra -chave explícita é opcional na qual passamos apenas um argumento de cada vez. Este construtor pode ser utilizado em estereotipagem:

#incluir
usando namespace std;
classe X
char variable_a;
público:
X ()
X (char a): variable_a (a) ;
void print () std :: cout << "Value is "<< variable_a <;
Void Disp (X i)

eu.imprimir();

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

Neste programa, primeiro definimos a classe "X" que declara a variável denominada "variável_a" do tipo de caractere. Em seguida, fazemos o construtor padrão com zero parâmetros e o construtor de argumentos únicos com outra classe que possui a “variável_a” do tipo de caractere. O valor criado e depois passou como um argumento para a função é impresso. Aqui, só precisamos passar qualquer valor do tipo de caractere, mas na função Main (), usamos o primeiro objeto chamado "Obj1" da classe X da Classe X. Depois disso, passamos o "M" como um argumento para uma função disp (). Assim, o valor é impresso quando o construtor é geralmente chamado.

Suponha que criemos um segundo objeto, "obj2", da classe X, e a função disp () é passada. Então, vamos passar um argumento de classe "x". Portanto, se chamarmos a função disp () e atribuirmos o alfabeto "n" do caractere do tipo para objeto "obj2", o compilador altera indiretamente essa variável do tipo "x" para uma variável de tipo de caractere de tipo. Ele fornece saída no valor do caractere. Usamos um argumento e colocamos a palavra -chave "explícita" no construtor para evitar isso com uma chamada implícita:

Compare dois números complexos:

Utilizamos a palavra -chave "explícita" para o construtor definido para indicar que o construtor é explicitamente chamado com a ajuda de aparelhos encaracolados e colchetes quadrados. O compilador lança um erro quando o usuário tenta chamar um construtor explícito com a ajuda de um operador de atribuição "=".
Neste código, criamos uma classe "Complex_Number". Em seguida, fabricamos variáveis ​​de tipo de dados duplo e colocamos essas variáveis ​​privadas. Se a classe contiver um construtor no qual passamos apenas um argumento, esse construtor será um construtor de conversão. Podemos ignorar essas conversões implícitas, pois elas podem nos dar saídas inesperadas. Portanto, criamos explicitamente o construtor usando a palavra -chave "explícita":

#incluir
usando namespace std;
Classe XYZ

privado:
int b;
int c;
público:
xyz (int u = 0, int v = 0): b (u), c (v)
operador bool == (xyz e)
retornar (b == e.b && c == e.c)? falso verdadeiro;

;
int main ()

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

No corpo da função principal, declaramos valores para o objeto da classe. Aplicamos a condição if-else para comparar dois números complexos. Aqui, verificamos se o valor fornecido passado como um argumento é igual aos valores de um objeto. A saída do código anterior é a seguinte:

Usando dois argumentos:

Se não podemos controlar a conversão implícita, devemos exigir um construtor com uma palavra -chave explícita para o construtor na afirmação da classe. Não podemos utilizar essa palavra -chave no construtor padrão. No geral, afirmando a palavra -chave "explícita" como um identificador de função para um construtor com um ou mais parâmetros em uma declaração de classe é utilizado para proteger a classe de conversões de tipo desnecessário. Caso contrário, sem essa palavra -chave, poderia ser um construtor de conversão:

#incluir
usando namespace std;
Classe complex_number

privado:
duplo rnum;
duplo inum;
público:
complexo explícito_number (duplo r = 0.0, duplo i = 0.0): rnum (r), inum (i)
operador bool == (complex_number ABC)
retornar (rnum == ABC.rnum && inum == ABC.inum)? verdadeiro falso;

;
int main ()

Complex_Number Comp (9.0, 4.0);
if (comp == (complex_number) 7.0)
cout << "Same";
outro
cout << "Not Same";
retornar 0;

Nesse caso, criamos uma classe chamada "xyz". Passamos dois parâmetros no construtor. Geralmente é a melhor maneira de usar explicitamente um construtor de argumentos. Já que pode ser confuso se ligarmos para dois ou mais argumentos para os construtores na função principal. Novamente, aqui o construtor é implicitamente declarado pelo compilador. Logicamente, para evitar a implementação desnecessária do programa que possa levar à produção, não é tão fácil converter o tipo, portanto, utilize a palavra -chave "explícita" em C ++ para o construtor:

Conclusão:

Neste artigo, determinamos que a palavra -chave específica “explícita” é normalmente utilizada para os construtores usados ​​para fazer objetos de classe na afirmação da classe. Também notamos que a palavra -chave explícita é a mais eficaz para os construtores. Ao mesmo tempo, precisamos nos afastar das chamadas implícitas através dos compiladores que normalmente criam os construtores como mudança de construtores. Muda de variáveis ​​de um tipo para outro que não é preciso. É uma maneira excepcional de usar constantemente essa palavra -chave em tais casos. Esperamos que você tenha achado este artigo útil. Confira outros artigos de dica do Linux para obter mais dicas e informações.