Programar em C/Mais sobre variáveis: diferenças entre revisões
| [edição verificada] | [edição verificada] |
Conteúdo apagado Conteúdo adicionado
Sem resumo de edição |
|||
Linha 102:
== Conversão de tipos ==
As atribuições no C tem o seguinte formato:
destino=origem;
Se o destino e a origem são de tipos diferentes o compilador faz uma conversão entre os tipos. Mas nem todas as conversões são possíveis. O primeiro ponto a ser ressaltado é que o valor de origem é convertido para o valor de destino antes de ser atribuído e não o contrário.
=== Casting: conversão manual ===▼
Em C, cada tipo básico ocupa uma determinada porção de bits na memória, logo, a conversão entre tipos nem sempre é algo nativo da linguagem, por
É importante lembrar que quando convertemos um tipo numérico para outro, nós nunca ganhamos precisão. Nós podemos perder precisão ou no máximo manter a precisão anterior. Isto pode ser entendido de uma outra forma. Quando convertemos um número não estamos introduzindo no sistema nenhuma informação adicional. Isto implica que nunca vamos ganhar precisão.
Abaixo vemos uma tabela de conversões numéricas com perda de precisão, para um compilador com palavra de 16 bits:
De Para Informação Perdida
unsigned char char Valores maiores que 127 são alterados
short int char Os 8 bits de mais alta ordem
int char Os 8 bits de mais alta ordem
long int char Os 24 bits de mais alta ordem
long int short int Os 16 bits de mais alta ordem
long int int Os 16 bits de mais alta ordem
float int Precisão - resultado arredondado
double float Precisão - resultado arredondado
long double double Precisão - resultado arredondado
▲=== Casting: conversão manual ===
Se declararmos '''a = 10/3''', sabemos que o resultado é '''3,333''', ou seja a divisão de dois números inteiros dá um número real. Porém o resultado em C será o inteiro 3. Isso acontece, porque as constantes são do tipo inteiro e operações com inteiros tem resultado inteiro. O mesmo ocorreria em '''a = b/c''' se b e c forem inteiros.
Se declararmos:
O resultado será '''3'''.
Mesmo que declarássemos:
o resultado continua a ser 3 mas desta vez, '''3,0000'''.
Para fazer divisão que resulte número real, é necessário fazer cast para um tipo de ponto flutuante:
a = (float)10/3
a = 10/(float)3
Nesse caso, o 10 ou o 3 é convertido para float. O outro número continua como inteiro, mas ao entrar na divisão com um float, ele é convertido automaticamente para float. A divisão é feita e depois atribuída à variável a.
(tipo)variável
(tipo)(expressão)
Mas existem umas conversões automáticas:
<source lang="C">
int
{
▲float f;
float f_var;
double d_var;
long double l_d_var;
▲i = (int) f;
f_var = 1; d_var = 1; l_d_var = 1;
d_var = d_var + f_var; /*o float é convertido em double*/
l_d_var = d_var + f_var; /*o float e o double convertidos em long double*/
return l_d_var;
}
</source>
Repare que a conversão é feita de menor para o maior.
▲Casting é colocar um tipo entre parênteses antes da atribuição de uma variável.
É possível fazer a conversão ao contrário de um tipo com mais bits para um com menos bits e isso é truncar. Nesse caso, o cast explícito é necessário. Assim, um número '''float''': 43.023 ao ser convertido para '''int''' deverá ser "cortado", ficando inteiro: '''43'''. Se converter long para short, os bits mais significativos são perdidos na conversão.
▲variavel_destino = (tipo) variavel_origem;
A seguir um pequeno exemplo:
<source lang="C">
#include <stdio.h>
typedef struct estruturar{
char a ;
char b ;
};
int main()
{
char buffer[2] = {17, 4};
estruturar *p;
p = (struct estruturar*) &buffer;
char* x = (char*)malloc(10);
printf("a: %i b: %i", p->a,p->b);
getchar();
return 0;
}
</source>
== Atributos das variáveis ==
| |||