C Comentários

Um comentário é um texto que você escreve dentro do código e que o compilador ignora por completo. Ele não vira parte do programa, não aparece na tela e não deixa nada mais lento: serve só para as pessoas que vão ler o código, inclusive você daqui a um mês. O C tem dois tipos de comentário, e esta aula mostra os dois, os cuidados com cada um e um uso que você vai fazer o tempo todo: "desligar" uma linha para testar.

Os exemplos foram compilados na máquina fictícia da Ana com o comando padrão do guia, gcc -std=c23 -Wall -Wextra, na pasta ~/c.

A ideia: anotações a lápis na receita

Pense numa receita de família, cheia de anotações a lápis na margem: "a vó usava menos açúcar", "não deixar mais de 40 minutos", "esta parte é opcional". A cozinheira lê as anotações, mas não as "cozinha": elas não vão para dentro do bolo. Às vezes a anotação até risca um passo inteiro: "~~acrescentar nozes~~ (o Pedro é alérgico)".

Os comentários são essas anotações. O compilador pula tudo o que está marcado como comentário, como se não estivesse lá.

1. Comentário de linha: //

Duas barras, //, começam um comentário que vai até o fim da linha. Ele pode ocupar a linha inteira ou ficar depois de uma instrução:

// compras.c: mostra a lista de compras da Ana
#include <stdio.h>

int main(void) {
    printf("Lista de compras:\n");  // título
    printf("- arroz\n");
    printf("- feijão\n");
    return 0;
}

$ gcc -std=c23 -Wall -Wextra compras.c -o compras
$ ./compras
Lista de compras:
- arroz
- feijão

// compras.c: …

Linha 1: um comentário que ocupa a linha toda. É comum começar o arquivo dizendo o que ele faz.

// título

Linha 5: um comentário no fim de uma linha de código. O printf antes dele roda normalmente; só o que vem depois das // é ignorado.

Nada dos comentários apareceu na saída, e o programa é exatamente o mesmo que seria sem eles.

$ gcc -std=c89 antigo.c -o antigo
antigo.c: In function ‘main’:
antigo.c:4:5: error: C++ style comments are not allowed in ISO C90
    4 |     // comentário de linha
      |     ^
antigo.c:4:5: note: (this will be reported only once per input file)

2. Comentário de bloco: /* … */

O outro tipo começa com /* e termina com */. Tudo o que fica entre os dois é ignorado, mesmo que ocupe várias linhas:

#include <stdio.h>

/*
 * Programa da lista de compras.
 * Autora: Ana
 */
int main(void) {
    printf("Lista de compras:\n");
    printf("- arroz\n");
    printf("- feijão\n");
    return 0;  /* tudo certo */
}

/*

Linha 3: abre o comentário.

* Programa da… / * Autora: Ana

Linhas 4 e 5: o texto. Os * no começo de cada linha não são obrigatórios: são só um costume, para deixar claro que aquilo ainda é comentário.

*/

Linha 6: fecha o comentário. A partir daqui, é código de novo.

/* tudo certo */

Linha 11: um comentário de bloco curto, no fim de uma linha.

Diferente do //, o /* */ termina onde você mandar, e por isso pode ficar até no meio de uma linha, com código antes e depois:

#include <stdio.h>

int main(void) {
    printf("Total: " /* sem centavos */ "R$ 30\n");
    return 0;
}

$ gcc -std=c23 -Wall -Wextra meio.c -o meio
$ ./meio
Total: R$ 30

O comentário sumiu, e os dois textos entre aspas, agora vizinhos, foram juntados (você viu isso em Sintaxe). Funciona, mas comentário no meio da linha atrapalha a leitura; use com moderação.

3. Comentar código para testar

Este é o uso mais prático dos comentários no dia a dia. Quer ver como o programa se comporta sem uma linha, mas não quer apagá-la? Transforme a linha em comentário. Os programadores chamam isso de comentar a linha (e, para voltar, descomentar):

#include <stdio.h>

int main(void) {
    printf("Lista de compras:\n");
    printf("- arroz\n");
    printf("- feijão\n");
    /* printf("- chocolate\n"); */
    // printf("- sorvete\n");
    return 0;
}

$ gcc -std=c23 -Wall -Wextra compras3.c -o compras3
$ ./compras3
Lista de compras:
- arroz
- feijão                 « nada de chocolate nem de sorvete

As duas linhas continuam no arquivo, prontas para voltar: basta apagar o // (ou o /* e o */) e compilar de novo. Quase todo editor de código tem um atalho para isso; no VS Code e em muitos outros, é Ctrl + /, que coloca ou tira // nas linhas selecionadas.

#include <stdio.h>

int main(void) {
    printf("Lista de compras:\n");
    printf("- arroz\n");
    printf("- chocolate\n");
    printf("- feijão\n");
    return 0;
}

#include <stdio.h>

int main(void) {
    printf("Lista de compras:\n");
    printf("- arroz\n");
    // printf("- chocolate\n");
    printf("- feijão\n");
    return 0;
}

4. Um /* */ não pode ficar dentro de outro

Esta é a pegadinha dos comentários de bloco. O */ fecha o comentário na primeira vez que aparece, não importa quantos /* vieram antes. Veja o que acontece quando a Ana tenta comentar duas linhas, e uma delas já tinha um comentário:

#include <stdio.h>

int main(void) {
    printf("Lista de compras:\n");
    /*
    printf("- arroz\n");   /* o arroz acabou? */
    printf("- feijão\n");
    */
    return 0;
}

$ gcc -std=c23 -Wall -Wextra aninhado.c -o aninhado
aninhado.c: In function ‘main’:
aninhado.c:6:28: warning: ‘/*’ within comment [-Wcomment]
    6 |     printf("- arroz\n");   /* o arroz acabou? */
aninhado.c:8:6: error: expected expression before ‘/’ token
    8 |     */
      |      ^

Siga o compilador, da esquerda para a direita:

1. Linha 5: /* abre o comentário.
2. Linha 6: o segundo /* é só texto dentro do comentário (o -Wall avisa: ‘/*’ within comment, "/* dentro de comentário"). Logo depois, o primeiro */ fecha o comentário.
3. Linha 7: o printf("- feijão\n"); voltou a ser código.
4. Linha 8: sobrou um */ solto, que não significa nada para o compilador: erro.

Dizemos que os comentários de bloco não se aninham (não ficam um dentro do outro). O // não tem esse problema: um /* ou um */ dentro de um comentário // é só texto, e um // dentro de /* */ também.

O truque do #if 0

Para desligar um trecho grande que já tem comentários de bloco dentro, há um truque do pré-processador: #if 0 ("se falso") no começo e #endif no fim. Tudo entre os dois some antes da compilação, com comentários e tudo:

#include <stdio.h>

int main(void) {
    printf("Lista de compras:\n");
#if 0
    printf("- arroz\n");   /* o arroz acabou? */
    printf("- feijão\n");
#endif
    printf("- café\n");
    return 0;
}

$ gcc -std=c23 -Wall -Wextra ifzero.c -o ifzero
$ ./ifzero
Lista de compras:
- café

O #if é explicado na aula Compilação Condicional. Por enquanto, basta saber que #if 0 … #endif funciona como um "comentário que aninha".

5. Dentro das aspas não é comentário

Um // ou um /* dentro de um texto entre aspas é só texto, e aparece na tela normalmente:

#include <stdio.h>

int main(void) {
    printf("Site: http://exemplo.com\n");
    printf("Isto /* não é */ comentário\n");
    return 0;
}

$ gcc -std=c23 -Wall -Wextra string.c -o string
$ ./string
Site: http://exemplo.com
Isto /* não é */ comentário

Ainda bem: senão, nenhum programa conseguiria mostrar um endereço da internet.

6. O que escrever num comentário

Comentar bem é uma arte. A regra principal: o código diz o que está sendo feito; o comentário diz por quê.

Bons lugares para um comentário:

• No topo do arquivo: o que o programa faz, quem escreveu, como compilar.
• Antes de um trecho complicado: a ideia geral, em uma ou duas frases.
• Avisos para o futuro: "cuidado: esta conta não funciona com números negativos". Muita gente marca tarefas pendentes com // TODO: ("a fazer"), e os editores costumam destacar essa palavra.

Nas primeiras aulas, vale comentar mais do que o normal: escrever "o que esta linha faz" com as suas palavras ajuda a fixar. Com o tempo, os comentários ficam mais raros e mais úteis. E pode escrever em português, com acento: o compilador ignora tudo mesmo.

Os dois tipos, e qual usar

Qual usar? No dia a dia, // para quase tudo, e /* */ para textos de várias linhas. Muitos projetos antigos e o código do Linux preferem /* */ em tudo; num projeto que já existe, siga o costume dele.

Quando dá errado

$ cat aberto.c
#include <stdio.h>

int main(void) {
    printf("Lista de compras:\n");
    /* comentário que nunca fecha
    return 0;
}
$ gcc -std=c23 -Wall -Wextra aberto.c -o aberto
aberto.c: In function ‘main’:
aberto.c:5:5: error: unterminated comment
    5 |     /* comentário que nunca fecha
      |     ^
aberto.c:4:5: error: expected declaration or statement at end of input
    4 |     printf("Lista de compras:\n");
      |     ^~~~~~

$ cat barra.c
#include <stdio.h>

int main(void) {
    // pasta: C:\Users\ana\
    printf("Esta linha some!\n");
    printf("Esta aparece.\n");
    return 0;
}
$ gcc -std=c23 -Wall -Wextra barra.c -o barra
barra.c: In function ‘main’:
barra.c:4:5: warning: multi-line comment [-Wcomment]
    4 |     // pasta: C:\Users\ana\
      |     ^
$ ./barra
Esta aparece.            « cadê a outra linha?

Referência rápida

Exercícios

Missão final: o comentário que engoliu o código

Cardápio do dia:
- arroz
- feijão
- salada

#include <stdio.h>

int main(void) {
    printf("Cardápio do dia:\n");
    printf("- arroz\n");
    printf("- feijão\n");
    printf("- salada\n");
    /*
    printf("- pudim\n");   /* sobremesa de domingo */
    */
    return 0;
}

#include <stdio.h>

int main(void) {
    printf("Cardápio do dia:\n");
    printf("- arroz\n");
    printf("- feijão\n");
    printf("- salada\n");
    // printf("- pudim\n");   /* sobremesa de domingo */
    return 0;
}

Resumo

• Comentários são anotações para pessoas: o compilador ignora tudo o que está neles.
• // vai até o fim da linha (desde o C99). /* */ vai até o */ e pode ter várias linhas.
• "Comentar" uma linha desliga o código sem apagá-lo: ótimo para testar.
• Comentários de bloco não se aninham: o primeiro */ fecha tudo. Para desligar um trecho que já tem /* */, use // ou #if 0 … #endif.
• Dentro das aspas, // e /* são texto comum.
• Um bom comentário diz por quê, não o que. Ao mudar o código, atualize o comentário.
• Próximo passo: Saída com printf.