Como converter tipos de dados em C++
Em C++, existem duas maneiras de alterar os tipos de dados:
Conversão de tipo implícita
De acordo com as regras predefinidas pelo compilador de código C++, a conversão implícita de tipo é a conversão de tipo realizada pelo compilador automaticamente, sem a necessidade de qualquer gatilho externo do usuário. Este tipo de conversão geralmente ocorre em um programa quando há mais de um tipo de dados e o tipo de dados da expressão não corresponde ao tipo de dados da variável envolvida nesta expressão.
Para evitar a perda de dados durante a conversão, o compilador, por padrão, altera o tipo de dados de baixa precisão pelo tipo de dados de maior precisão. Por exemplo, ele converterá um número inteiro em um número flutuante em vez de alterar o número flutuante em um número inteiro para evitar perda de dados. Isso é chamado de promoção. A seguir está o diagrama de precedência para os diferentes tipos de dados.
Pedido para conversão de tipo
A ordem correta para conversão de tipo é fornecida como:
bool - > Caracteres -- > int curto - > interno-- > int não assinado - > longo -- > sem assinatura longa - > longo longo -- > flutuar - > dobro -- > longo duplo
A variável do tipo de baixa precisão é convertida no tipo de dados de alta precisão para evitar perda de dados.
Exemplo 1
Neste exemplo, a adição é realizada na variável de diferentes tipos de dados usando a conversão implícita de tipo.
#include
usando espaço para nome padrão ;
interno principal ( ) {
interno número = 100 ;
Caracteres personagem = 'C' ;
corte << '100 + 'C' =' << número + personagem << fim ;
flutuador valor = número + 'c' ;
corte << 'float val(100 + 'c') =' << valor << fim ;
interno era = 7890 ;
longo não foi = era ;
corte << 'var_int =' << não foi ;
retornar 0 ;
}
Aqui, um número inteiro e um caractere da tabela ASCII, e um número flutuante e o caractere ‘c’ são adicionados. O inteiro é mantido no terceiro segmento como um tipo de dados longo e os tipos de dados são alterados pelo próprio compilador com base em suas regras predefinidas.
A soma de 100 e 'C' retorna 167, pois 'C' equivale a 67 em números e 100 + 'c' retorna 199, pois 'c' minúsculo equivale a 99. A variável int é armazenada em um tipo de dados longo.
Exemplo 2
Neste exemplo, o caractere D é convertido em float para realizar a operação de divisão.
#includeusando espaço para nome padrão ;
interno principal ( ) {
Caracteres x = 'D' ;
flutuador float_var ;
float_var = flutuador ( x ) / 'c' ;
// Convertendo explicitamente um int em float.
corte << 'O valor de float_var é:' << float_var << fim ;
retornar 0 ;
}
O valor de entrada está na forma do caractere D que é armazenado no tipo de dados float e posteriormente dividido pelo caractere C. Esses caracteres são transformados em valores numéricos e uma operação de divisão é realizada sobre eles, retornando o valor em float.
Conversão de tipo explícita
O usuário deve alterar manualmente o tipo de dados com a conversão de tipo explícita do C++, geralmente conhecida como conversão de tipo. Este tipo de conversão é feito para evitar a conversão implícita de tipo. Existem dois métodos para realizar conversão de tipo explícito em C++:
- Conversão usando o Operador de Atribuição
- Conversão usando o operador Cast
Conversão de tipo usando o operador de atribuição em C++
A conversão de tipo utilizando o Operador de Atribuição é feita de forma forçada, ou seja, um tipo de dado é convertido para outro manualmente. Isso é feito usando o operador de atribuição “=”, que atribui o valor do operando à direita à variável do seu lado esquerdo.
Exemplo
Este programa calcula a área do círculo usando conversão de tipo.
#incluir
usando espaço para nome padrão ;
interno principal ( )
{
interno raio ;
corte <> raio ;
flutuador área = M_PI * raio * raio ;
corte << 'Área do círculo com raio' << raio << '=' << área ;
}
O operador de atribuição é usado para atribuir o valor flutuante à área, que consiste no valor do raio no tipo de dados inteiro.
A área do círculo é retornada no tipo de dados float, enquanto o raio é inserido no tipo de dados inteiro. Assim, o tipo de dados da variável é alterado por meio de conversão de tipo usando o operador de atribuição.
Conversão de tipo usando o operador Cast em C++
A conversão de tipo é feita usando um operador de conversão, que força um tipo de dados a mudar para outro tipo de acordo com as necessidades do programa.
Existem quatro operadores de elenco diferentes:
- static_cast
- const_cast
- elenco_dinâmico
- reinterpretar_cast
1: static_cast
O static_cast é o operador de conversão usado para converter explicitamente números flutuantes e caracteres em inteiros e assim por diante. Este é o operador de conversão mais básico. Ele pode lançar tipos de dados de natureza semelhante. Ele pode converter ponteiros de um formato para outro, portanto também pode ser usado para gerenciamento de memória.
Sintaxe
static_cast ( expressão ) Exemplo
Este programa foi criado para converter uma variável dupla em um tipo de dados int usando static_cast. Isso cortará qualquer parte decimal na saída.
usando espaço para nome padrão ;
interno principal ( )
{
//declara uma variável
dobro p ;
p = 2.905 * 1.235 * 24.675 ;
flutuador resultado ;
corte << 'Antes de usar a conversão estática:' << fim ;
corte << 'O valor de p =' << p << fim ;
// use o static_cast para converter o tipo de dados
resultado = static_cast ( p ) ;
corte << ' Depois de usar a conversão estática: ' << fim ;
corte << 'O valor do resultado =' << resultado << fim ;
retornar 0 ;
}
Inicialmente, uma variável dupla p é carregada com valores que são multiplicados entre si e armazenados no resultado. O resultado contém o resultado antes e depois do operador static_cast:
Antes de usar o operador static_cast, o resultado é exibido em casas decimais, enquanto depois de usar este operador ele é exibido em tipo de dados inteiro.
2: const_cast
O operador const_cast é usado para converter um valor constante de um objeto para o tipo não constante. É usado onde um objeto constante é declarado e precisamos alterar seu valor ocasionalmente.
Sintaxe
const_cast ( expressão ) Exemplo
Neste exemplo, o operador const_cast é utilizado para remover temporariamente o qualificador de constante e permite fazer alterações na variável de acordo com a necessidade:
usando espaço para nome padrão ;
interno principal ( ) {
const interno x = 70 ;
const interno * e = & x ;
corte << 'O valor antigo é' << * e << ' \n ' ;
interno * Com = const_cast ( e ) ;
* Com = 90 ;
corte << 'Novo valor é' << * e ;
retornar 0 ;
}
O qualificador constante é atribuído a uma variável int x, o que significa que esta variável não pode ser modificada diretamente. Depois disso, int *y que é um ponteiro é usado para acessar x, mas ainda não pode ser alterado, e seu valor original é exibido usando cout. Usando o operador const_cast, é criado um ponteiro z que não é constante, é usado para acessar o valor de x tornando-o editável. Ele altera o valor atribuído a z por 90, o que altera indiretamente o valor em x.
Inicialmente, o valor da variável constante x é 70 que é modificado usando o operador const_cast, tornando-o 90.
3: elenco_dinâmico
com a hierarquia de herança, que também é conhecida como downcast com segurança de tipo. Downcast é o processo de conversão de uma referência ou ponteiro em uma classe derivada de uma referência ou ponteiro de classe base.
Sintaxe
elenco_dinâmico ( expressão ) Exemplo
Neste exemplo, o operador dynamic_cast é usado para verificar o tipo de classe polimórfica e permite acesso aos membros da classe base e derivada.
#include
usando espaço para nome padrão ;
aula TBase
{
público :
flutuador base_g = 9,81 ;
virtual vazio fictício ( )
{
} ;
} ;
aula TDerivado : público TBase
{
público :
interno local_g = 9,78 ;
} ;
interno principal ( )
{
TBase * base = novo TDerivado ;
TDerivado * derivado ;
derivado = elenco_dinâmico ( base ) ;
corte < base_g << fim ;
corte < local_g << fim ;
pegarchar ( ) ;
retornar 0 ;
}
Duas classes são definidas como classes base e derivadas. Um ponteiro base do tipo TBase* é criado e atribuído a um objeto alocado dinamicamente do tipo TDerived. Um objeto de classe derivada pode ser atribuído a um ponteiro de classe base nesta instância de polimorfismo. O dynamic_cast verifica se o ponteiro acessa o objeto válido de TDerived, se a conversão obtiver um resultado bem-sucedido, a classe derivada obterá um resultado válido, caso contrário, retornará um valor nulo.
4: reinterpretar_cast
O reinterpret_cast transforma um ponteiro de um tipo de dados em um ponteiro de um tipo de dados diferente. Ele não verifica se os tipos de dados dos ponteiros são iguais ou não. Este operador de fundição precisa ser usado e manuseado com cuidado.
Exemplo
Nesta ilustração, o ponteiro de um tipo de dados é reinterpretado em um ponteiro de outro tipo de dados usando reinterpret_cast:
usando espaço para nome padrão ;
interno principal ( )
{
interno * q = novo interno ( 70 ) ;
Caracteres * CH = reinterpretar_cast ( q ) ;
corte << * q << fim ;
corte << * CH << fim ;
corte << q << fim ;
corte << CH << fim ;
retornar 0 ;
}
Inicialmente, um inteiro é atribuído com o valor 70. O ponteiro q aponta para esse inteiro alocado dinamicamente. O reinterpret_cast é usado para reinterpretar o ponteiro q como um ponteiro de caractere ch, o que significa que a memória originalmente atribuída a q agora é tratada como se fosse um caractere. Usando o comando cout, ele imprime o valor atribuído a q e ch. Como ch é tratado como um ponteiro de caractere, ele retornará um valor de caractere.
Imprime o valor apontado para ch usando *ch. Entretanto, como ch é tratado como um ponteiro de caractere, esta linha interpretará a memória como um caractere. Ele imprime o endereço de memória armazenado no ponteiro ch usando ch. Este é o mesmo endereço de memória que q porque é apenas uma reinterpretação da mesma memória.
Inicialmente, o inteiro armazena 70. Posteriormente, isso é manipulado entre o ponteiro q e o ponteiro ch. As saídas 2 e 4 são iguais porque o segundo valor é reinterpretado usando reinterpret_cast.
Observação : Sugere-se não usar este operador de conversão até e a menos que seja muito necessário, pois torna o objeto um produto não portátil
Conclusão
O processo de alteração do tipo de dados de uma variável para outra é conhecido como conversão de tipo ou conversão de tipo em C++. Isso é feito para realizar operações matemáticas nas variáveis de diferentes tipos de dados, tornando seus tipos de dados compatíveis entre si. A conversão de tipo otimiza o código. Existem conversões de tipo implícitas e explícitas em C++. A conversão implícita de tipo é realizada pelo próprio compilador usando um conjunto predefinido de regras, enquanto a conversão explícita de tipo é realizada pelo programador usando operadores de atribuição e operadores de conversão.