Código Fonte... Parte II

Conforme prometido no post anterior, hoje vamos falar sobre os padrões do C.

Sou adepto da filosofia que diz que é fazendo que se aprende. Então vamos seguir essa filosofia! (Ao menos quando for possível ;)

Para isto inicie o Dev C++ e abra um novo Arquivo Fonte. Se não sabe como fazê-lo, veja aqui.

Para não causar desapontamentos futuros, vou logo avisando que não vamos criar um código fonte completo hoje! Veremos algumas particularidades sobre os padrões do C e como a IDE trata deles. Ok?

Identificando os dados
Lembra dos 'quadrinhos' que vimos aqui? Pois bem, dentro deste quadrinhos podem ficar armazenados informações ou instruções. O computador sabe encontrar cada um deles de acordo com o seu endereço. Mas este endereço não fica visível para nós programadores (existe uma forma de encontrar este endereço, assunto de um post mais adiante).
Se não podemos saber o endereço de um 'quadrinho', como vamos usá-lo? Como vamos 'escrever' ou 'ler' o que tem dentro de um deles?
Para resolver isto, o C nos dá a possibilidade de identificar cada um deles. Isto mesmo! Podemos dar um 'nome' a um 'quadrinho'. Seria como 'colar uma etiqueta' nele com o nome desejado.
Todas as vezes que nos referirmos a este nome estaremos falando daquele 'quadrinho' específico.
Este nome deve seguir algumas regras simples:
-COMEÇAR COM UMA LETRA OU _ (CARACTER DE SUBLINHADO (UNDERLINE)). Os caracteres seguintes podem ser letras, o próprio caracter de sublinhado ou números. Não use caracteres acentuados, espaços, símbolos de pontuação ou símbolos especiais (lembre-se que estes não são padronizados).
-LETRAS MAIÚSCULAS E MINÚSCULAS SÃO DIFERENTES PARA O C. Assim podemos ter no mesmo código fonte 4 'quadrinhos' identificados como valor, Valor, vAlOr e VaLoR. Cada um deles tem um endereço diferente e podem armazenar valores diferentes. USE ESTA REGRA COM CAUTELA! O computador não se confunde quanto a eles, mas nós podemos nos confundir. Não fica nem um pouco claro usar nomes como estes num mesmo programa.
-SÓ 32 CARACTERES SÃO SIGNIFICATIVOS.
-NÃO PODEM SER USADAS 'PALAVRAS RESERVADAS'. Vejamos o que e quais são elas.

Palavras reservadas
Existem algumas palavras que exercem um papel fundamental no C. Um exemplo são os identificadores e modificadores de tipo, que vimos aqui. No total elas são 32. (como diminuo este espaço entre o texto e a tabela?)

auto break case char const continue default do

double else enum extern float for goto if

int long register return short signed sizeof static

struct switch typedef union unsigned void volatile while

Vamos à pratica
Digite algumas dessas palavras naquele código fonte em branco que criamos no Dev C++.
Note que assim que você acaba de digitá-la, ela fica, automaticamente, em negrito. Esta é a forma que o Dev C++ trata as palavras reservadas do C.

Nomeando os 'quadrinhos'
Para nomear um 'quadrinho' devemos 1º dizer ao C qual será o tamanho dele, ou seja, o seu tipo.
Antes mesmo disto, se desejarmos que o seu conteúdo não se altere, devemos informar este desejo. Se não o fizermos, ele será, por padrão, variável.
Depois disto, informamos o nome desejado para ele.
Por exemplo, para dar o nome valor a um 'quadrinho' que armazenará um valor inteiro e terá seu conteúdo variável devemos digitar:

int valor

Experimente digitar isto no código fonte que está aberto no Dev C++.
Isto é uma instrução que demos ao C. Ela significa: pegue um 'quadrinho' de tamanho suficiente para armazenar um valor inteiro e cole uma etiqueta nele com o 'nome' valor.
Esta é uma instrução está quase completa. Falta uma coisa muito simples a ela: O ponto final.

O ponto final do C (;)
No post anterior, vimos alguns padrões da língua portuguesa. Um exemplo que usei foi o parágrafo e os sinais de pontuação. O C também tem parágrafos e sinais de pontuação.
Vejamos os sinais de pontuação; mais precisamente, o ponto final.
O ponto final define o final da frase (será que é por isso que ele tem este nome?). Sem ponto final não dá pra saber onde termina uma frase e começa a outra.
O ponto final do C é o ponto e vírgula (;). Se você tentar compilar um código fonte que não tenha o ; no final de cada instrução, isto criará um erro de compilação.
Parabéns! Você acabou de descobrir o erro de compilação que usei para mostrar como o Dev C++ encontra este tipo de erro.

Sendo assim a nossa instrução só ficará completa com o seu (;) final.

int valor;

E se o nosso 'quadrinho' fosse constante? Como seria declarado? (Vá se acostumando com esta nomenclatura. Daqui pra frente, procurarei usar a linguagem técnica, o famoso jargão.)
Para declarar uma constante a forma correta é:

const int valor;

Esta instrução declara uma constante do tipo inteira com o nome valor. Só que cria um problema! Será que você sabe que problema é este?

Qual o valor do 'quadrinho'?
Para responder a esta pergunta, precisamos ter em mente que a MEMÓRIA RAM é um área onde o PROCESSADOR guarda dados rápidos e realiza operações. Lembre do conceito do quadro na sala de aula.
Só que tem um detalhe! O PROCESSADOR é um professor descansado, que não se preocupa em apagar o quadro depois de usar.
Portanto, nunca se sabe o que estava escrito no quadro antes. (Algumas vezes, em situações específicas, quando uma variável é declarada, o 'quadrinho' correspondente a ela é automaticamente apagado.)

Olha o problema aí: Declaramos uma constante inteira chamada valor, mas não sabemos qual o valor que está armazenado nela. E, ainda pior, por ser uma constante não pode ser alterada.
Como resolver isto?

Colocando um valor no 'quadrinho'
Mais uma vez, o C vem nos socorrer rsrs.
Nos podemos 'colocar' um valor no nosso 'quadrinho'. Quando este 'quadrinho' é variável, esta atribuição pode ser feita a qualquer momento, inclusive, na declaração desta variável. No caso de ser constante, SÓ pode ser feito na declaração desta constante. O símbolo que indica esta atribuição é o = (não confundir com o = de matemática, que significa é igual a).
Vamos ver alguns exemplos:
int valor;
valor = 10;

Traduzindo: Declaramos uma variável do tipo inteiro com o nome valor e, no comando seguinte, atribuimos o valor inteiro 10 a esta variável. Este valor pode mudar durante a execução do problema.
Usamos 2 comandos para fazer isto. Poderíamos fazer a mesma coisa com um único comando.

int valor = 10;

Esta é uma atribuição na declaração, que é chamada de inicialização. Que é a única forma de criar constantes.
Agora que sabemos disto, vamos corrigir o nosso problema anterior.

const int valor = 10;

Agora sim! Criamos uma constante inteira chamada valor que contém o valor 10.
Eu, particularmente, goste de nomear constante com letras maiúsculas, pois acho que fica mais fácil de identificá-las no código fonte. Faça como achar melhor.

Um pouco mais sobre atribuições
Como você viu até agora, podemos atribuir um valor a uma variável, tanto na sua declaração, como no decorrer do código fonte.
Existem outras coisas que podemos fazer com as atribuições. Vejamos duas delas.

Podemos atribuir o valor de uma variável a outra variável.
Quer um exemplo?

int valor01 = 10;
int valor02 = 5;
valor02 = valor01;

Os comandos acima declaram e inicializam duas variáveis (valor01 com o valor 10 e valor02 com o valor 5) e, depois, o valor da variável valor01 é atribuido a variável valor02; ou seja, o valor de valor02 agora é 10 (valor armazenado). Não quer dizer que as variáveis são iguais, e sim que o valor armazenado nas duas é o mesmo, no caso, 10. (Procure entender bem este conceito, pois ele causa um tipo de erro muito comum, o famoso erro de lógica.)

Podemos atribuir o resultado de uma operação a uma variável.
Exemplo:

int total;
total = 10 + 5;

Olhando os comandos acima, você pode dizer qual é o valor de total após o 2º comando?
Parabéns se você disse 15.

Pode fazer os seus testes no Dev C++. Lembrando que ainda não dá pra ver o resultado disto, ou seja, o programa em execução.

Essa hora está chegando. Aguarde e confie.