Capítulo 3 - Variáveis, Tipos e Operadores

Tipos de variáveis:

1. int: armazena números inteiros.
2. float: armazena ponto flutuante com 6 ou 7 dígitos de precisão.
3. char: caracteres ASCII (padrão do teclado).
4. double: ponto flutuante com 13 ou 14 dígitos de precisão.

Analisando: O valor limite de int varia de compilador para compilador. No Dev-C++ esse limite é muito maior do que o exposto.
O tipo float será mais do que suficiente para aplicações tradicionais, em oposição ao double.
Usaremos char para criar e manipular strings, além de receber valores unitários (ex. masculino = m e feminino = f).

main()
{
     int sum;
     sum = 3 + 5;
     printf("Sum = %d", sum);
}

Executa: 7
A variável é definida como do tipo inteiro com o nome "sum".

main()
{
     unsigned int num;
     num = 60000;
     printf("Sum = %u", num);
}

Executa: 60000
Qualificar int como unsigned aumenta o tamaho do limite dos números inteiros positivos em int. Perceba que utilizei o especificador de formato %u.

main()
{
     long int distancia = 93000000;
     printf("A distancia e de: %ld", distancia);
}

Executa: 93000000.
Qualificar int como long aumenta o tamanho do limite dos inteiros tanto com sinal positivo quanto negativo, ainda maior que unsigned. Usamos o especificador de formato %ld.
Podemos usar unsigned long int, que aumenta ainda mais o tamanho dos inteiros positivos de long.

main()
{
     short int val = 32767 + 1;
     printf("O valor e: %d", val);
}

Executa: -32768.
O que aconteceu aqui? O qualificador short impoe ao int valores entre -32768 a 32767. Quando ultrapassamos o limite positivo, ele mostra como valor padrão o limite negativo. Se ultrapassamos o limite negativo, ele mostra o limite positivo.

Existe também o qualificador register, que diz ao compilador para armazenar a variável em um registrador (memória do processador), aumentando a performance. No entanto, não sei se esse qualificador realmente funciona. Geralmente usado para variáveis em loopings (for, while, etc.).

Incremento e Decremento:

main()
{
     int val = 0;
     printf("Valor de pos-incremento: %d\n", val++);
     val = 0;
     printf("Valor de pre-incremento: %d",++val);
     getchar();
}

Fazer val++ ou ++val é o mesmo que val = val + 1. Acontece que no pos-incremento de val (val++), primeiro é executada a linha de comando (função printf()) com o valor padrão de val (val = 0). Somente "depois" acrescenta-se 1. Na linha de comando abaixo defino val como sendo zero de novo. Na segunda chamada a printf(), é feito o pré incremento, ou seja, na "mesma" linha de comando, alteramos o valor de val para 1.

Obs: getchar() Recebe um caractere. Apertando ENTER ele recebe o caractere e a tela fecha.
Obs: comentários no código:

// comentário

/*comentário*/

/*
*
* comentário
*
*/

Operadores BIT a BIT:

main()
{
     int num = 255;  /* É igual a 0000 0000 1111 1111 
                        em decimal */
     num = num >> 3; /* Desloca 3 bits para a direita, 
                      * ou seja, 0000 0000 0001 1111 em                                        
                      * binário, o que equivale a 31 
                      * em decimal 
                      */

     printf("%d", num);
     getchar();
}

Executa: 31
O número 255 em decimal é 1111 1111. O operador de deslocamento para a direita >> desloca 3 bits à direita, o que equivale a 31 em decimal.

main()
{
     int num = 255;  /* É igual a 0000 0000 1111 1111 
                     em decimal*/
                      
     num = num << 1; /* Desloca 1 bit para a esquerda, 
                      * ou seja, 0000 0001 1111 1110 em 
                      * binário, o que equivale a 510 
                      * em decimal 
                      */
     printf("%d", num);
     getchar();
}

Executa: 510

main()
{
int num1 = 5; // 0101 em binário
int num2 = 10; // 1010 em binário
int total = num1^num2;

/* O operador ^ é chamado OR exclusivo, vale 1
* para cada dígito binário diferente, e zero
* para dígitos binário iguais
* 5 = 0101
* 10 = 1010
* -----------
* 15 = 1111
*/

printf("%d", total);
getchar();
}

Executa: 15

main()
{
     int num1 = 5; // 0101 em binário
     int num2 = 10; // 1010 em binário
     int total = num1num2;

     /* O operador é chamado OR, vale 0 quando os 
      * dois digitos binários em comparação forem zero.
      * 4 = 0100
      * 10 = 1010
      * -----------
      * 14 = 1110
      */

     printf("%d", total);
     getchar();
}

Executa: 14

main()
{
     int num1 = 5; // 0101 em binário
     int num2 = 10; // 1010 em binário
     int total = num1&num2;
     /* O operador & é chamado AND, vale 1 quando os 
      * dois digitos binários em comparação forem 1.
      * 5 = 0101
      * 10 = 1010
      * -----------
      * 0 = 0000
      */
      printf("%d", total);
      getchar();
}

Executa: 0

Função sizeof():

main()
{
     int tamanho;
     tamanho = sizeof(int);
     printf("O compilador usa %d bytes para armazenar um int na memória.", tamanho);
     getchar();
}

Executa: O compilador usa 4 bytes para armazenar um int na memória. (Lembre-se, o tamanho depende do compilador).
1 byte representa 8 bits, então são 8x4 bits = 32 bits. Ou seja, são 31 bits(espaços) para armazenar dígitos e 1 bit para armazenar o sinal.
Da mesma forma, onde você digitou int (entre os parênteses da função sizeof() - depois explicarei como isso funciona), pode digitar outros tipos de dados, como:

- char, long int, unsigned char, unsigned int, unsigned long int, float e double.
Obs: nos especificadores unsigned só são armazenados dígitos, o sinal é sempre positivo.