Wikilivros

Programar em C/Variáveis: diferenças entre revisões

Explorar interativamente o histórico
(Ver alterações pendentes à versão publicada)
[edição não verificada][edição verificada]
← Edição anteriorEdição posterior →
Conteúdo apagado Conteúdo adicionado
VisualTexto wiki
Etiqueta: esvaziamento
Desfeita a edição 260385 de 177.59.95.98 (Discussão): conteúdo inserido fora de contexto (a explicação é sobre o exemplo anterior); <tt> --> <code>; <source> -><syntaxhighlight>
Linha 1:
 
== Variáveis ==
Em um programa, existe a necessidade de se guardar valores na memória, e isso é feito através de '''variáveis''', que podem ser definidas simplificadamente como nomes que se referem a lugares na memória onde são guardados valores.
Linha 10 ⟶ 9:
tipo_da_variável nome_da_variável;
 
Por exemplo, para declarar uma variável do tipo <ttcode>int</ttcode> com o nome <var>a</var>, podemos escrever
<sourcesyntaxhighlight lang=c>
int a;
</syntaxhighlight>
</source>
 
É sempre necessário indicar o tipo da variável, pois cada tipo tem um tamanho diferente, ou seja, ocupa mais ou menos espaço na memória do computador. Mais adiante introduziremos os tipos de variável.
 
== Atribuindo valores ==
Se quisermos associar um valor a uma variável, usamos o operador <ttcode>=</ttcode> (igual):
 
<sourcesyntaxhighlight lang=c>
a = 5;
</syntaxhighlight>
</source>
 
Nesse caso, estamos pedindo que o computador guarde o valor 5 no espaço alocado à variável <var>a</var>.
 
É possível também atribuir um valor a uma variável ao mesmo tempo que ela é declarada, o que é chamado de ''inicializar'' a variável. Por exemplo:
<sourcesyntaxhighlight lang=c>
int a = 5;
</syntaxhighlight>
</source>
 
É possível também declarar mais de uma variável de um mesmo tipo em uma única instrução, separando os nomes por vírgulas. Também é possível inicializar as variáveis dessa maneira:
 
<sourcesyntaxhighlight lang=c>
int a, b, c, d;
int e = 5, f = 6;
int g, h = 2, i = 7, j;
</syntaxhighlight>
</source>
 
== Exemplo de erro ==
a = 25;
 
a:25;
int:a
Mesmo sabendo que é um exemplo de erro, escreva o código acima em um arquivo .c e tente compilar para se familiarizar com as mensagens de erro do compilador, assim você saberá o que fazer quando elas ocorrerem.
 
Linha 59 ⟶ 57:
 
== Tipos de variáveis ==
Até agora você só viu as variáveis do tipo <ttcode>int</ttcode>, que servem para guardar números inteiros. A linguagem C tem 4 tipos fundamentais. São eles:
* <ttcode>int</ttcode>, para números inteiros entre -2147483647 e 2147483647, utiliza 4 bytes;
* <ttcode>char</ttcode>, para caracteres individuais do padrão ASCII, utiliza 1 byte;
* <ttcode>float</ttcode>, para reais entre (aproximadamente) 10<sup>-38</sup> e 10<sup>38</sup>, utiliza 4 bytes, precisão de 7 dígitos;
* <ttcode>double</ttcode>, para reais entre (aproximadamente) 10<sup>-4932</sup> e 10<sup>4932</sup>, utiliza 8 bytes, precisão de 15 dígitos;
* <ttcode>bool</ttcode>, para indicar true (verdadeiro) ou false (falso), utiliza 1 byte; Presente apenas no padrão C99 em diante.
 
Os tipos <ttcode>float</ttcode> e <ttcode>double</ttcode> servem para guardar números de ponto flutuante, ou seja, números reais, como 3,1415 (pi), -2,3333, 0,00015, 6,02 &times; 10<sup>23</sup>. A diferença entre os dois é, além do intervalo de dados, a precisão. Geralmente, o tipo <ttcode>float</ttcode> guarda dados (com sinal positivo ou negativo) de 3,4E-38 a 3,4E+38 (além do zero). Já <ttcode>double</ttcode> suporta números tão pequenos quanto 1,7E-308 e no máximo 1,7E+308.
 
Também existem outros tipos, como short (ou short int), que serve para inteiros menores, long (ou long int) para inteiros maiores. Qualquer tipo inteiro pode ser precedido por unsigned (o signed para COM negativos), para cortar os números negativos, permitindo maior capacidade de armazenamento de números positivos. Alguns compiladores aceitam o long long, para aumentar ainda mais o tamanho da variável, alguns desses só aceitam para o tipo int, outros também para o tipo double.
Linha 93 ⟶ 91:
Podemos alterar a maneira como os dados são guardados com os '''modificadores de tipo'''. Você pode modificar os tipos de duas maneiras.
 
==== Tamanho: <ttcode>short</ttcode> e <ttcode>long</ttcode> ====
Você pode modificar o tamanho de uma variável usando os '''modificadores de tipo''', que são dois: <ttcode>short</ttcode> e <ttcode>long</ttcode>. Note que <ttcode>float</ttcode> e <ttcode>char</ttcode> não podem ser modificados em tamanho.
 
* '''<ttcode>short</ttcode>''' diminui o espaço necessário para guardar a variável (diminuindo também a gama de valores que esta pode assumir). Só pode ser usado com <ttcode>int</ttcode>.
* '''<ttcode>long</ttcode>''' aumenta o espaço tomado pela variável, e portanto aumenta seu valor máximo e/ou sua precisão. Pode ser usado com <ttcode>int</ttcode> e <ttcode>double</ttcode>.
* O padrão C de 1999 adicionou um terceiro modificador, suportado pelos compiladores mais recentes, inclusive o gcc: <ttcode>long long</ttcode>, que aumentaria ainda mais a capacidade da variável. Alguns deles suportam esse modificador apenas para o tipo <ttcode>int</ttcode>, e outros suportam também para <ttcode>double</ttcode>.
 
Uma observação é necessária: segundo o padrão, não existe nenhuma garantia de que uma variável <ttcode>short int</ttcode> é menor que uma variável <ttcode>int</ttcode>, nem que <ttcode>long int</ttcode> é maior que <ttcode>int</ttcode>. Apenas é garantido que <ttcode>int</ttcode> não é maior que <ttcode>long</ttcode> nem menor que <ttcode>short</ttcode>. De fato, nos sistemas x86 de 32 bits (ou seja, a maioria dos computadores pessoais atualmente), o tamanho de <ttcode>int</ttcode> é igual ao de <ttcode>long</ttcode>. Geralmente, <ttcode>int</ttcode> será o tamanho nativo do processador &mdash; ou seja, 32 bits num processador de 32 bits, 16 bits num processador de 16 bits etc.
 
=== Converter um tipo de variável ===
Linha 106 ⟶ 104:
 
Esta operação pode ser realizada de duas maneiras.<br>
'''Conversões do tipo implícita:''' Consiste em uma modificação do tipo de variável que é feita automaticamente ▼
'''
▲Conversões do tipo implícita:''' Consiste em uma modificação do tipo de variável que é feita automaticamente
pelo compilador.
:Ex:
Linha 120 ⟶ 117:
 
Veja um exemplo da conversão de tipo inteiro em caracteres. Aqui convertemos um numero decimal em um caracte ASCII.
<sourcesyntaxhighlight lang="C">
#include <stdio.h>
 
Linha 130 ⟶ 127:
x = (char) y;
printf("O numero inteiro: %d \n O caracter: %c \n\n", y, x);
}</sourcesyntaxhighlight>
 
==== Sinal: <ttcode>signed</ttcode> e <ttcode>unsigned</ttcode> ====▼
Existe outro tipo de modificador, que define se o número vai ser guardado com '''sinal''' ou não. São os modificadores <ttcode>signed</ttcode> e <ttcode>unsigned</ttcode>, suportados pelos tipos inteiros apenas.▼
 
* '''<ttcode>signed</ttcode>''' diz que o número deve ser guardado com sinal, ou seja, serão permitidos valores positivos e negativos. Esse é o padrão, portanto esse modificador não é muito usado.▼
▲==== Sinal: <tt>signed</tt> e <tt>unsigned</tt> ====
* '''<ttcode>unsigned</ttcode>''' diz que o número deve ser guardado '''sem sinal'''. Com isso, o valor máximo da variável aumenta, já que não teremos mais valores negativos. Por exemplo, com uma variável <ttcode>char</ttcode> podemos guardar valores de -128 a 127, mas com uma variável <ttcode>unsigned char</ttcode> pode guardar valores de 0 a 255.▼
▲Existe outro tipo de modificador, que define se o número vai ser guardado com '''sinal''' ou não. São os modificadores <tt>signed</tt> e <tt>unsigned</tt>, suportados pelos tipos inteiros apenas.
 
▲* '''<tt>signed</tt>''' diz que o número deve ser guardado com sinal, ou seja, serão permitidos valores positivos e negativos. Esse é o padrão, portanto esse modificador não é muito usado.
▲* '''<tt>unsigned</tt>''' diz que o número deve ser guardado '''sem sinal'''. Com isso, o valor máximo da variável aumenta, já que não teremos mais valores negativos. Por exemplo, com uma variável <tt>char</tt> podemos guardar valores de -128 a 127, mas com uma variável <tt>unsigned char</tt> pode guardar valores de 0 a 255.
 
Para usar esses modificadores, devemos colocá-los '''antes''' do nome do tipo da variável, sendo que o modificador de sinal deve vir antes do modificador de tamanho caso ambos sejam usados. Por exemplo:
Linha 146 ⟶ 142:
'''long double''' preco;
 
<div style="background-color: #ddffdd; padding: 10px; margin: 20px;">'''Nota:''' Você pode abreviar <ttcode>short int</ttcode> e <ttcode>long int</ttcode> para simplesmente <ttcode>short</ttcode> e <ttcode>long</ttcode>, respectivamente.</div>
 
 
== Literais ==
Linha 154 ⟶ 149:
* Literais de inteiros podem ser especificados nas bases decimal, octal ou hexadecimal. Se o literal for prefixado com "0x" ou "0X", ele será interpretado como hexadecimal; se o prefixo for apenas "0", será interpretado como octal; ou se não houver prefixo, será interpretado como decimal.
* Literais de reais podem ser especificados na forma decimal (144.57) ou em notação científica (1.4457e+2). Lembre-se que o separador decimal é o ponto e não a vírgula, como seria usual.
* Literais de caracteres devem vir entre aspas simples (') e conter a representação de apenas um caractere<sup>1</sup>. Usos válidos seriam: 'c', '\n', '\x1b', '\033'. Se você quiser usar a aspa simples como caractere, preceda-a com uma barra invertida: <ttcode>'<nowiki>\'</nowiki>'</ttcode>.
* Literais de strings devem vir entre aspas duplas ("). Para usar aspas duplas dentro de strings, preceda-as com barra invertida: <ttcode>"Ele disse \"Olá\"."</ttcode>. Note que um literal de string adiciona o caractere nulo (<ttcode>\0</ttcode>) ao final da string, pois ele é, em C, a maneira de delimitar o final de uma string.
 
== Notas de rodapé ==
Obtido em "https://pt.wikibooks.org/wiki/Programar_em_C/Variáveis"