type conversions c
Verifique as várias conversões de tipo suportadas em C ++.
Esperamos que você esteja ciente de todos os tipos de dados disponíveis em C ++ em nossos tutoriais anteriores. Às vezes, pode surgir a necessidade de converter um tipo em outro. Isso é chamado de conversão de tipo ou conversão de tipo.
Neste tutorial, discutiremos as várias conversões de tipo suportadas em C ++.
perguntas para fazer a um analista de negócios
=> Clique aqui para obter o curso C ++ grátis.
O que você aprenderá:
- Conversões de tipo
- Conversão implícita
- Conversão Explícita
- Tipos de fundição
- Conclusão
- Leitura recomendada
Conversões de tipo
C ++ suporta dois tipos de conversões de tipo:
- Conversão de tipo implícita: A conversão implícita de tipo é automática. Não há interferência do usuário neste tipo de conversão e o compilador realiza a conversão diretamente. A conversão geralmente é feita quando na expressão há mais de um tipo de dados. Mas geralmente, neste tipo de conversão, existe a possibilidade de perda de dados, perda de sinais ou estouro de dados.
- Conversão de tipo explícito: A conversão explícita de tipo é definida pelo usuário e normalmente é chamada de “conversão de tipo”. Aqui, o usuário converte ou converte um valor de um tipo de dados em outro, dependendo dos requisitos. Esse tipo de conversão é mais seguro.
Agora veremos os dois tipos de conversão de tipo em detalhes.
Conversão implícita
Na conversão implícita, o compilador realiza as conversões de um tipo de dado para outro sempre que uma expressão possui mais de um tipo de dados. Para evitar a perda de dados, todas as variáveis dos outros tipos de dados são convertidas para o maior tipo de dados. Isso é chamado de promoção.
Vamos entender a conversão implícita usando um exemplo de código.
#include using namespace std; int main() { int num = 10; char ch = 'A'; cout<<'10 + 'A' = '< Resultado:
10 + 'A' = 75
float val (10 + ‘a’) = 107
var_int = 1000
O exemplo de código acima demonstra a conversão implícita. Declaramos um inteiro e uma variável de caractere com valores 10 e ‘A’ respectivamente. Quando somamos essas duas variáveis, ocorre uma conversão implícita.
Como o número inteiro é o tipo maior nesta expressão, o valor da variável de caractere ‘A’ é convertido em seu equivalente inteiro, ou seja, o valor 65 (valor ASCII). Portanto, o resultado da expressão é 75.
Na próxima expressão, adicionamos inteiro e caractere (‘a’ -> 97) e, em seguida, atribuímos o resultado a float. Portanto, o resultado da expressão é convertido implicitamente em float pelo compilador.
Na terceira expressão, uma variável int curta é convertida em inteiro implicitamente.
Observação : No caso de conversões implícitas, se o compilador detecta uma possível perda de dados, ele pode piscar um aviso para esse efeito.
Conversão Explícita
A conversão explícita também é conhecida como 'conversão de tipo', pois 'moldamos' um tipo de dados para outro tipo de dados. Aqui, os usuários definem explicitamente a conversão, ao contrário da conversão implícita, em que o compilador realiza a conversão internamente.
Podemos realizar a conversão explícita de duas maneiras:
# 1) Usando o Operador de Atribuição
A conversão explícita ou impressão de tipos usando o operador de atribuição de uma forma é executada de forma forçada. Aqui, lançamos ou convertemos um tipo de dados em outro tipo de dados usando o operador de atribuição.
A sintaxe geral é:
(data type) expression;
O exemplo a seguir explica isso:
#include #include using namespace std; int main() { int sum; double salary = 4563.75; sum = (int)salary + 1000; cout<<'Sum = '< Resultado:
Soma = 5563
Comp = 5563,2
Mostramos uma conversão explícita usando o operador de atribuição no exemplo acima. Primeiro, convertemos o salário variável do tipo double em um tipo inteiro. Em seguida, convertemos a soma da variável inteira em um tipo duplo.
Conforme mostrado na saída, o tipo para o qual convertemos indica o tipo final do resultado da expressão.
fone de ouvido vr para xbox one s
Isso é vantajoso porque o usuário pode alterar o tipo de expressão de acordo com os requisitos.
# 2) Usando o operador de elenco
Nesse tipo de conversão, usamos um “operador de conversão”, que é um operador unário para mudar de um tipo para outro.
Tipos de fundição
Temos os seguintes tipos de fundição, dependendo do operador de fundição que usamos:
# 1) Elenco estático
O elenco estático é o mais simples entre todos os tipos de fundição usando o operador de elenco . O cast estático é capaz de realizar todas as conversões que são realizadas implicitamente. Ele também executa conversões entre ponteiros de classes relacionadas entre si (upcast -> de derivado para base ou downcast -> de base para derivado).
Além das conversões listadas acima, o elenco estático também é capaz de converter qualquer ponteiro em void *.
O elenco estático é o elenco de tempo compilado. Isso significa que não há verificação feita em tempo de execução para ver se a conversão executada é válida ou não. Portanto, continua sendo responsabilidade do programador garantir que a conversão seja segura e válida.
Em outras palavras, o usuário deve garantir que o objeto convertido estava cheio em relação ao tipo de dados de destino.
Especificamos um elenco estático da seguinte maneira:
static_cast (expression)
Vamos entender o elenco estático usando um exemplo.
#include using namespace std; int main() { double df = 3.5 * 3.5 * 3.5; cout<<'Before casting: df = '<No exemplo acima, modificamos ligeiramente o código para incluir uma variável de caractere com o valor ‘A’. Em seguida, declaramos um ponteiro de inteiro e aplicamos uma conversão estática para converter um caractere em um ponteiro de inteiro.
Quando compilamos este programa, obtemos a seguinte saída.
Na função ‘int main ()’:
10:35: erro: static_cast inválido do tipo ‘char *’ para o tipo ‘int *’
O programa fornece um erro para o cast estático executado, pois é inválido. Assim, a conversão estática permite apenas conversão ou conversão de tipo válido e dá um erro quando tentamos realizar alguma conversão de tipo indesejável.
# 2) Elenco dinâmico
A conversão dinâmica é uma conversão em tempo de execução realizada para verificar a validade da conversão. A conversão dinâmica é executada apenas em referências e ponteiros de classe. A expressão retorna um valor NULL se a conversão falhar.
O elenco dinâmico usa um mecanismo conhecido como RTTI (Runtime Type Identification) . O RTTI disponibiliza todas as informações sobre o tipo de dados do objeto em tempo de execução e está disponível apenas para as classes que possuem pelo menos uma função virtual (tipo polimórfico). O RTTI permite determinar o tipo de objeto em tempo de execução ou durante a execução.
Vamos tentar um exemplo para entender o elenco dinâmico.
#include #include using namespace std; class base {public: virtual void print(){}}; class derived:public base{}; int main() { base* b = new derived; derived* d = dynamic_cast(b); if(d != NULL) cout<<'Dynamic_cast done successfully'; else cout<<'Dynamic_cast not successful'; }
Neste programa, definimos duas classes, base com uma função virtual e derivada tendo uma classe base, base.
Na função principal, criamos um objeto de classe derivada apontado pelo ponteiro da classe base. Em seguida, executamos dynamic_cast no ponteiro de base apontando para uma classe derivada para convertê-lo em um ponteiro de classe derivada.
Como na classe base, a base é polimórfica (contém a função virtual), o dynamic_cast foi bem-sucedido.
Nota: Se removermos a função virtual da classe acima, dynamic_cast falhará porque as informações RTTI para os objetos não estarão disponíveis.
O elenco dinâmico tem uma sobrecarga de segurança de tipo em tempo de execução.
# 3) Reinterpretar Elenco
Esse tipo de elenco é mais perigoso de usar, pois funciona em qualquer tipo de objeto sem que as classes estejam relacionadas entre si.
Reintepret_cast funciona em quaisquer ponteiros e converte um ponteiro de qualquer tipo em qualquer outro tipo, independentemente de os ponteiros estarem relacionados entre si ou não. Não verifica se o ponteiro ou os dados apontados pelo ponteiro são iguais ou não.
O operador de conversão usa apenas um parâmetro, o ponteiro de origem para o qual converter e não retorna nenhum valor. Ele simplesmente converte o tipo de ponteiro.
Não devemos usar a menos que seja necessário. Normalmente, fazemos o typecast do ponteiro de origem para seu tipo original.
Usamos principalmente para trabalhar com bits. Quando é usado em valores booleanos, os valores booleanos são convertidos em valores inteiros, ou seja, 1 para verdadeiro e 0 para falso.
Vejamos um exemplo de elenco de reinterpretação:
#include using namespace std; int main() { int* ptr = new int(97); char* ch = reinterpret_cast(ptr); cout << ptr << endl; cout << ch << endl; cout << *ptr << endl; cout << *ch << endl; return 0; }
Resultado:
0x3ef3090
para
97
para
No exemplo acima, declaramos um ponteiro de inteiro ptr apontando para o valor 97. Em seguida, declaramos um ponteiro de caractere ch e convertemos ptr nele usando.
A seguir, imprimimos vários valores. O primeiro que imprimimos é ptr que aponta para uma localização inteira. Portanto, ele imprime um endereço.
O próximo valor ch contém o valor 97 e, portanto, ele imprime 'a' que é ASCII equivalente a 97. O próximo valor “* ptr” mantém o valor 97 enquanto “* ch” mantém ASCII equivalente a 97, isto é, 'a' conforme é convertido usando o reinterpret_cast.
# 4) Elenco Const
O operador de conversão é usado para alterar ou manipular a constância do ponteiro de origem. Por manipulação, queremos dizer que pode ser tanto definir constância como um ponteiro não const ou remover constância de um ponteiro const.
A condição para o operador lançar com sucesso é que o ponteiro e a fonte que é convertido sejam do mesmo tipo.
Vamos dar um exemplo para entender isso.
#include using namespace std; int printVal(int* ptr) { return(*ptr*10); } int main(void) { const int value = 10; const int *ptr = &value; int *ptr_cast = const_cast (ptr); cout <<'printVal returned = '<< printVal(ptr_cast); return 0; }
Neste exemplo, vemos que a função ‘printVal’ aceita um ponteiro não const. Na função principal, temos uma variável const 'valor' atribuída ao ponteiro const ptr.
aplicativo de download de músicas mp3 grátis para android
Para passar esse ponteiro const para a função printVal, nós o lançamos aplicando para remover a constness. Em seguida, passamos o ponteiro ptr_cast para a função para obter os resultados desejados.
Conclusão
Com isso, encerraremos este tópico de conversão de tipo em C ++. Vimos tudo sobre conversões implícitas e explícitas que são usadas em C ++.
No entanto, deve-se estar ciente de que, para evitar a perda de dados e outras dificuldades semelhantes, as conversões ou modelagem de tipos devem ser aplicadas com sabedoria apenas se a situação exigir o uso.
=> Cuidado com o Guia de treinamento para iniciantes em C ++ aqui.
Leitura recomendada
- Best FREE C # Tutorial Series: The Ultimate C # Guide for Beginners
- Qualificadores de tipo e classes de armazenamento em C ++
- Tipos de teste de migração: com cenários de teste para cada tipo
- Como decidir qual tipo de teste é necessário para um projeto? - Manual ou Automação
- Tipos de dados C ++
- Teste de carga com tutoriais HP LoadRunner
- Variáveis em C ++
- Modelos em C ++ com exemplos