Linguagem C: comentários e identação

Um tópico muito importante em C (e em qualquer linguagem de programação) são os comentários. Quando os programas começam a ficar muito grandes, torna-se difícil seguir o raciocínio que o programador utilizou (mesmo que esse programador tenhas sido tu!). Os comentários são blocos de texto normal que inserimos entre as instruções do nosso programa para nos ajudar a seguir a lógica do mesmo. Substitui o código do nosso programa pelo seguinte:

 
/* Em baixo temos uma diretiva de pré-processador */
#include <stdio.h>

/* Vamos começar o nosso programa. */
int main() {
    /* Escrever no ecrã uma frase */
    printf("O meu primeiro programa em C!\n"); /* O \n indica uma nova linha*/
    /* Vamos retornar zero, indicando que correu tudo bem. */
    return 0;
}

Como podes constatar, os comentários em C são colocados dentro de blocos que começam com /* e terminam com */, como por exemplo /* isto é um comentário */. Se compilares e executares o programa vais verificar que os comentários são totalmente ignorados. É uma excelente prática comentar os nossos programas, e algo que aconselho fazerem sempre, seja em projetos para a universidade ou a nível profissional.

Outra boa prática é a chamada identation (não existe uma palavra exata em Português, mas para facilitar vamos chamar-lhe identação). A identação não é mais do que chegar à frente os conteúdos de um bloco. Por exemplo, tudo o que está dentro do bloco da função main está identado com quatro espaços. Desta forma o programa torna-se mais claro e mais fácil de entender. A identação é essencial para que um programa seja minimamente legível. Aqui vamos usar identação de 4 espaços (o chamado estilo Kernighan & Ritchie), no entanto cada pessoa tem a sua preferência, alguns usam 2 espaços, outros usam um tab, e por ai fora. O que interessa é que o nosso programa seja consistente e mantenha a mesma identação do princípio ao fim. Se por acaso tiverem longas partes do vosso código que não estejam identadas, estejam mal identadas ou estejam identadas de forma inconsistente, existem várias formas automáticas de resolver o problema. Deixo duas soluções, uma usando a interface gráfica, outra usando a linha de comandos:

1. A maioria dos IDEs (ver aqui o que é um IDE) suporta esta operação. Por exemplo, no Code::Blocks, basta ires ao menu "Plugins => Source Code Formatter (AStyle)", e o teu código fica automaticamente identado. Para alterares o estilo de identação efetuada através deste processo, edita as preferências do plugin em "Setting => Editor", e selecionares em baixo "Source Formatter". Como podes verificar, existem vários estilos de identação, e podes inclusive criar um personalizado.
2. Usando o comando indent. Este comando também suporta uma série de estilos diferentes, bem como personalizações específicas de cada estilo. Após instalares o indent (ver parágrafo seguinte), podes fazer identação automática do nosso primeiro programa usando o seguinte comando:
   
   $ indent -kr -nut primeiroprog.c
   
   As opções -kr e -nut indicam que queres usar o estilo Kernighan & Ritchie e que não queres usar tabs, respetivamente. Para veres todas as opções deste comando basta fazeres:
   
   $ man indent

Nem o Code::Blocks nem o comando indent estão instalados por defeito na maioria das distribuições Linux. Em distribuições baseadas em Debian (Ubuntu, Mint, WattOS, Bodhi, etc.), um simples comando serve para instalar os dois programas de uma só vez:

$ sudo apt-get install codeblocks indent

Seja qual for o estilo que usares, convém seres consistente e usares esse estilo em todo o teu programa. Em situações em que várias pessoas estão a trabalhar no mesmo código, convém definir à partida o estilo usado, de forma a que o resultado final tenha um aspeto coerente.

Linguagem C: o nosso primeiro programa

Neste post vamos voltar a falar do nosso primeiro programa em C, e vamos assumir que o leitor já tem um sistema preparado para compilar e executar programas em C (ver posts anteriores).

Vamos criar uma pasta para colocarmos o nosso código, e vamos abrir o gedit para editar o nosso programa. Para isso abre um terminal, e insere os seguintes comandos (explicações detalhadas de todos estes comandos estão disponíveis nos posts anteriores):

$ mkdir aprender_c
$ cd aprender_c
$ gedit primeiroprog.c &

Agora, faz copy-paste do código em baixo para dentro do gedit, e guarda o ficheiro.

 
#include <stdio.h>

int main() {
    printf("O meu primeiro programa em C!\n");
    return 0;
}

Vamos então por partes. A linha 1 do código contém o seguinte texto:

 
#include <stdio.h>

Este texto não corresponde a código C, mas sim a uma directiva de pré-processador. Não te assustes com o nome. Esta directiva de pré-processador serve apenas para indicar ao compilador que pretendemos usar funções (ou comandos) que estão na biblioteca de funções stdio.h (Standard Input/Output). Esta biblioteca contém funções de entrada/saída de dados, tais como o printf (usado na linha 4, do qual falaremos adiante). Se quisermos usar outros tipos de funções, tais como funções matemáticas ou funções para tratamentos de sequências de caracteres (strings), vamos ter de incluir (#include) mais bibliotecas (math.h no caso das funções matemáticas, e string.h no caso das funções para tratamento de sequências de caracteres). As directivas de pré-processador começam sempre com um cardinal (#), e, ao contrário de todas as expressões e chamadas de função em C, não devem terminar com um ponto e vírgula (;), como acontece nas linhas 4 e 5.

Nas linhas 3 e 6 temos o início e o fim da função principal, main, que é chamada em primeiro lugar assim que o nosso programa é executado.

 
int main() {
}

A palavra-chave int antes do nome da função (neste caso main), indica o tipo de dados que a função vai devolver a quem a chamou. Por definição, a função main devolve sempre um número inteiro. Adiante falaremos melhor sobre os diferentes tipos de dados existentes em C. Tudo o que está entre as chavetas {...} é o nosso programa propriamente dito, que é composto por instruções. As instruções em C devem ser sempre terminadas por ponto e vírgula.

Na linha 4 temos a função printf.

 
printf("O meu primeiro programa em C!\n");

Esta função, na sua forma mais simples, aceita uma sequência de caracteres, e escreve/imprime essa sequência no ecrã. Em C, as sequências de caracteres são definidas entre aspas (ex. "sou uma sequencia de carateres"). Repara nos dois últimos caracteres da sequência que estão dentro do printf. Temos uma barra "\" seguida de um "n". Esta sequência, "\n", indica uma nova linha (new line), e serve para indicar o fim da linha atual e o início de uma nova linha. Vamos ver um exemplo do seu efeito mais à frente. Por último, na linha 5 temos a seguinte instrução:

 
return 0;

Esta instrução indica o fim da função main, e por consequência o fim do nosso programa, devolvendo o valor zero (que é um número inteiro). Neste caso o valor é devolvido ao sistema operativo, e é comum este valor indicar que o programa terminou sem erros.

Agora que temos um entendimento mais completo sobre o nosso programa, vamos compila-lo e executa-lo. Salva o documento no gedit, e na linha de comandos escreve o seguinte:

$ gcc primeiroprog.c -ansi -pedantic -Wall -g -o primeiroprog

Se tudo correr bem, o programa vai compilar sem erros. Antes de executarmos o nosso programa, uma pequena explicação sobre as opções que usámos para o compilador gcc:

• gcc : Nome do comando de compilação
• primeiroprog.c : Nome do ficheiro a compilar
• -ansi e -pedantic : Indicam que o  nosso ficheiro contém código C o mais standard possível, sem extensões mais recentes.
• -Wall : Pede ao compilador para nos avisar (Warning) de todos (all) os pequenos problemas que possam existir no programa, mesmo que esses problemas não impeçam a compilação.
• -g : Pede ao compilador para incluir informação de depuração (debug), que nos pode ajudar a resolver problemas usando um depurador (debugger) tal como o gdb, o qual vamos usar mais à frente.
• -o primeiroprog : Indica ao compilador que o ficheiro executável resultante (output) da compilação deve-se chamar primeiroprog.

Vamos executar o programa da seguinte forma:

$ ./primeiroprog

O resultado será:

O meu primeiro programa em C!

Se removermos o "\n" da cadeia de caracteres dentro do printf e voltarmos a compilar, vamos verificar que no fim da execução do programa o cursor fica situado logo à frente da frase e não por baixo da mesma. Existem outros caracteres especiais em C, como podes ver aqui. Experimenta inserir alguns destes caracteres especiais na cadeira de caracteres, volta a compilar e executar o programa e observa o resultado!

No final do nosso programa retornamos o valor zero, que indica que o programa terminou sem problemas. Após a execução de qualquer comando em Linux podes verificar o resultado retornado usando outro comando:

$ echo $?

Ao executares este comando após teres executado o nosso primeiro programa, vais ver o resultado retornado: zero. Na linha 5 do nosso programa, substitui o 0 por outro valor inteiro, volta a compilar e executar, e logo de seguida corre o comando anterior e verifica o resultado obtido.

Por último o programador deve ter em atenção que o C é case-sensitive, ou por outras palavras, é sensível às maiúsculas e minúsculas. Se por exemplo em vez de escrevermos main, printf ou return, escrevermos Main, PRINTF ou ReTuRn, o programa não vai sequer compilar.