C: conhecendo a Linguagem das Linguagens

Começando com Variáveis - Introdução

Olá! Na primeira parte do nosso curso de Linguagem C, trabalharemos em um jogo de adivinhação. Ao rodar o jogo, o computador perguntará um número e, cuja resposta poderia ser 10, por exemplo, e o computador poderia retrucar informando que pensou em outro número, maior que 10. Então, você tenta o número 50, e o computador diz que é menor que 50. E assim será a "brincadeira" de descobrir o número que o computador pensou.

Parece simples, mas o jogo tem muitos programas computacionais para resolvermos. Assim, aprenderemos a:

• lidar com entradas e saídas;
• como escrever no monitor;
• como ler do teclado;
• elaborar variáveis para guardar respostas e números que o computador pensar;
• gerar números randômicos (para o jogo ficar legal, toda vez que rodar, precisará de um número diferente);
• criar um programa que tome decisões - se acertar o número, o jogador vence e o jogo acaba. Se errar o número, o jogo precisa dizer se o número certo é maior ou menor
• a partir de if, gerar loops para fazer o programa repetir até que o jogador acerte o número e todas suas tentativas acabem - terá um número máximo de tentativas, caso contrário o jogo fica fácil.

Pronto para desenvolver seu primeiro jogo? Vamos lá!

Começando com Variáveis - Começando a programar

Desenvolver um programa de computador significa que faremos com que ele se comporte da maneira esperada, por meio de um conjunto de linhas e instruções escritas por nós, que o computador entenderá e executará. Nosso primeiro passo será abrir um editor de texto, no qual serão escritas as instruções.

No entanto não trabalharemos com um editor de texto comum como o Word, geralmente utilizado para escrever cartas ou fazer trabalhos de faculdade, e sim um editor de texto especial para código. Se digitarmos "IDE" (nome utilizado para editores especiais para código) no Google, encontraremos diversos tipos que podem ser utilizados para Linguagem C.

Aqui, utilizaremos um editor mais simples, o Sublime, similar ao UltraEdit ou o Bloco de Notas do Windows. Ele é simples, visualmente agradável, e tem a função de colorir o código, o que facilita na hora de lidarmos com códigos extensos. Fique à vontade para escolher o melhor editor para você. Dependendo do sistema operacional, pode-se usar o Note Pad também.

Começaremos escrevendo nosso programa, o qual se encontra em um arquivo que iremos salvar ainda em branco. Para isso, podemos utilizar o atalho "Command + S" ou "Ctrl + S". Escolha um diretório para arquivá-lo e crie uma pasta em "New Folder" para o projeto. Neste caso, usaremos o nome de adivinhacao para o jogo.

Salvaremos o arquivo como programa.c, pois sempre que fizermos um programa em C, devemos salvá-lo com a extensão .c, assim como arquivos do Word terminam com .doc e os do Excel, que terminam com .xls.

Ao ser iniciado, nosso programa exibirá uma mensagem de boas-vindas ao usuário, escreveremos simplesmente Bem-vindo ao nosso jogo de adivinhação.

Porém, ainda não é um código em C. Por enquanto, é um texto simples que o computador não entende como comando para imprimir o texto de boas-vindas. Para fazê-lo, colocaremos a mensagem entre aspas.

Agora, diremos para o programa "exiba na tela o texto 'Bem-vindo ao nosso jogo de adivinhação'". Infelizmente, programar não é tão simples assim, em português. Usaremos diversas palavras reservadas da Linguagem C. Se quisermos escrever na tela, usaremos a palavra printf, abrindo um parênteses para o nosso texto. Em inglês, print significa imprimir.

printf("Bem vindo ao nosso jogo de adivinhação")

Entenderemos adiante a função dos parênteses. Por enquanto, lembrem-se que sempre que usarmos printf, em seguida abriremos parênteses para inserir um texto entre aspas. No vocabulário de Linguagem C, falaremos string quando quisermos nos referir a um texto, e tudo que for aberto terá de ser fechado - parênteses, chaves e colchetes, por exemplo. E toda linha termina com ponto e vírgula ou chaves.

printf("Bem-vindo ao nosso jogo de adivinhação");

No entanto, da maneira em que está, o texto ainda não é um programa. Acrescentaremos a função int main() para que a Linguagem C entenda que, ao rodar o programa, a primeira função a ser executada deve ser o printf:

int main() {
    printf("Bem-vindo ao nosso jogo de adivinhação");
}

O importante é saber que para começar a escrever um programa em C, é necessário escrever int main(). No exemplo, fechei as chaves depois do printf, pois queremos passar a ideia de que ele está dentro desse bloco de código, que está separado pelas chaves. Falta só um detalhe. Para usarmos o printf precisamos avisar o programa em C que o jogo escreverá, e depois vai ler pelo teclado. Para avisá-lo que a função printf será utilizada, incluiremos a biblioteca (conjunto de funções que podem ser utilizadas no programa) em que ela se encontra por meio de #include <stdio.h>.

#include <stdio.h>

int main() {
    printf("Bem-vindo ao nosso jogo de adivinhação");
}

Agora, sim, temos um programa em C! Precisamos rodá-lo para ver o computador imprimir o que foi feito. O computador não entende diretamente essa linguagem, binária, em que usamos apenas os números 0 e 1. No entanto, nós, seres humanos, não a entendemos, e por isto transformaremos o código que desenvolvemos em código de máquina por meio do compilador, que transforma a Linguagem C em dígitos 0 e 1.

Para usar o compilador é necessário tê-lo instalado na máquina. A linguagem C tem diversos compiladores. Utilizaremos o GCC, disponível para Linux e MAC. Se for utilizar o Windows, basta procurar no Google por "GCC download Windows" e seguir o instalador padrão. Aberto o terminal (no Windows, é o Prompt de comando), vamos inserir o código, que localizará o programa de acordo com o diretório em que salvamos o arquivo:

Alura: codigo alura$ pwd
/Users/alura/Documents/aniche/curso-c/codigo
Alura:codigo alura $ ls
adivinhacao
Alura: codigo alura$ cd adivinhacao/
Alura: adivinhacao alura$
programa.c
Alura:adivinhacao alura$

O programa não roda ainda; é necessário compilá-lo, utilizando o comando gcc programa.c -o programa.out ou gcc programa.c -o programa.exe no Windows:

Alura: codigo alura$ pwd
/Users/alura/Documents/aniche/curso-c/codigo
Alura:codigo alura $ ls
adivinhacao
Alura: codigo alura$ cd adivinhacao/
Alura: adivinhacao alura$
programa.c
Alura:adivinhacao alura$ gcc programa.c -o programa.out

Isto significa que:

• gcc é o compilador;
• programa.c é o nome do nosso programa;
• -o é o local onde o código binário, que só a máquina entende, será escrito;
• programa.out ou programa.exeé o outro nome.

Após apertarmos "Enter", será indicado que o programa está inativo, mostrando que o nosso programa.c foi compilado com sucesso.

Alura: codigo alura$ pwd
/Users/alura/Documents/aniche/curso-c/codigo
Alura:codigo alura $ ls
adivinhacao
Alura: codigo alura$ cd adivinhacao/
Alura: adivinhacao alura$
programa.c
Alura:adivinhacao alura$ gcc programa.c -o programa.out
Alura:adivinhacao alura$

Acrescentaremos um ls e teremos o programa.out:

Alura: codigo alura$ pwd
/Users/alura/Documents/aniche/curso-c/codigo
Alura:codigo alura $ ls
adivinhacao
Alura: codigo alura$ cd adivinhacao/
Alura: adivinhacao alura$
programa.c
Alura:adivinhacao alura$ gcc programa.c -o programa.out
Alura:adivinhacao alura$ ls
programa.c         programa.out
Alura:adivinhacao alura$

Se tentarmos imprimir o programa.c com instrução cat, ele o fará na tela e conseguiremos entender.

Alura: codigo alura$ pwd
/Users/alura/Documents/aniche/curso-c/codigo
Alura:codigo alura $
Alura:adivinhacao alura$ ls
programa.c
Alura:adivinhacao alura$ gcc programa.c -o programa.exe
Alura:adivinhacao alura$ ls
programa.c         programa.out
Alura:adivinhacao alura$ cat programa.c
#include <stdio.h>

int main() {
        printf("Bem-vindo ao nosso jogo de adivinhação");
}Alura:adivinhacao alura$

Se tentarmos imprimir o programa.out:

Alura: codigo alura$ pwd
/Users/alura/Documents/aniche/curso-c/codigo
Alura:codigo alura $
Alura:adivinhacao alura$ ls
programa.c
Alura:adivinhacao alura$ gcc programa.c -o programa.exe
Alura:adivinhacao alura$ ls
programa.c         programa.out
Alura:adivinhacao alura$ cat programa.c
#include <stdio.h>

int main() {
        printf("Bem-vindo ao nosso jogo de adivinhação");
}Alura:adivinhacao alura$ cat programa.out

Em seguida, a tela exibirá códigos que apenas o seu sistema operacional consegue entender. Vamos limpar a tela com o comando clear. Encontraremos o programa.out.

Alura:adivinhacao alura$ ls
programa.c         programa.out
Alura:adivinhacao alura$ ./programa.out

No Linux ou no MAC, executaremos ./programa.out e, no caso do Windows, será necessário digitarmos ./programa.exe. Ao rodá-lo, teremos como retorno Bem-vindo:

Alura:adivinhacao alura$ ls
programa.c         programa.out
Alura:adivinhacao alura$ ./programa.out
Bem-vindo ao nosso jogo de adivinhaçãoAlura:adivinhacao alura$

Esse é nosso primeiro programa! Aprendemos a compilar, escrevemos um programa em C no Sublime Text. Após a compilação, é gerado um executável, e depois rodamos e tudo funcionou. Adiante, aprimoraremos o texto.

Começando com Variáveis - Lidando com erros

Anteriormente, estudamos:

• como iniciar um programa;
• como o código deve ficar dentro do int main();
• a necessidade de compilação para que a máquina entenda e execute o programa.

Começaremos esta aula renomeando nosso programa, pois programa.c é muito genérico. Usaremos adivinhacao.c, e para isso acrescentaremos no terminal os comandos:

Alura:adivinhacao alura$ rm programa.out
Alura:adivinhacao alura$ mv programa.c adivinhacao.c

Assim, o nome programa.c será alterado para adivinhacao.c.

Alura:adivinhacao alura$ ls
programa.c        programa.out
Alura:adivinhacao alura$ ./programa.out
Bem-vindo ao nosso jogo de adivinhaçãoAlura:adivinhacao alura$ ls
programa.c           programa.out
Alura:adivinhacao alura$ rm programa.out
Alura:adivinhacao alura$ mv programa.c adivinhacao.c
Alura:adivinhacao alura$ ls
adivinhacao.c
Alura:adivinhacao alura$

Adiante, veremos a importância da nomeação de arquivos. De volta ao editor de texto Sublime, aprimoraremos o texto que estamos desenvolvendo acrescentando funções printf().

#include <stdio.h>

int main() {
    printf("******************************************");
    printf("* Bem-vindo ao nosso jogo de adivinhação *");
    printf("******************************************");
}

Deixaremos nosso texto com aparência de banner, e em seguida compilaremos no nosso console.

Alura:adivinhacao alura$ ls
programa.c        programa.out
Alura:adivinhacao alura$ ./programa.out
Bem-vindo ao nosso jogo de adivinhaçãoAlura:adivinhacao alura$ ls
programa.c           programa.out
Alura:adivinhacao alura$ rm programa.out
Alura:adivinhacao alura$ mv programa.c adivinhacao.c
Alura:adivinhacao alura$ ls
adivinhacao.c
Alura:adivinhacao alura$ gcc adivinhacao.c -o adivinhacao.out
Alura:adivinhacao alura$ ls
adivinhacao.c     adivinhacao.out
Alura:adivinhacao alura$ ./adivinhacao.out
******************************************* Bem-vindo ao nosso jogo de adivinhação *******************************************Alura:adivinhacao alura$

O texto atualizado é apresentado, porém sem o alinhamento planejado. Para que a visualização do texto seja executada da forma planejada, será necessário adicionarmos um comando \n, que na Linguagem C equivale a "Enter". Ao adicionarmos esse comando no Sublime, ele ficará na cor vermelha.

#include <stdio.h>

int main() {
    printf("******************************************\n");
    printf("* Bem-vindo ao nosso jogo de adivinhação *\n");
    printf("******************************************\n");
}

Voltaremos ao terminal para compilar o código atualizado e, com o comando clear limparemos a tela e inseriremos o código do programa:

Alura:adivinhacao alura$ ls
adivinhacao.c     adivinhacao.out
Alura:adivinhacao alura$ gcc adivinhacao.c -o adivinhacao.out
Alura:adivinhacao alura$ ./adivinhacao.out
******************************************
* Bem-vindo ao nosso jogo de adivinhação *
******************************************
Alura:adivinhacao alura$

Agora que adicionamos \n, o texto ficou da maneira que planejamos. É necessário compilar para verificarmos o código, considerando que se escrevermos algo errado, o compilador não funcionará. Testaremos isso retirando o ponto e vírgula do terceiro printf() do código no Sublime.

#include <stdio.h>

int main() {
    printf("******************************************\n");
    printf("* Bem-vindo ao nosso jogo de adivinhação *\n");
    printf("******************************************\n")
}

Salvo o arquivo no editor de texto, compilaremos o programa no terminal, e por meio do clique da seta para cima, o comando gcc adivinhacao.c -o adivinhacao.out será acrescentado automaticamente:

Alura:adivinhacao alura$ gcc adivinhacao.c -o adivinhacao.out

Como retorno, teremos o seguinte erro:

adivinhacao.c:6:56: error: expected ';' after expression
        printf("******************************************\n")
                                                              ^
                                                              ;
1 error generated.
Alura:adivinhacao alura$

O compilador indica como localizar o erro:

• Localização: adivinhacao.c:6:56 – linha 6, coluna 56. Lembrando que no Sublime, a contagem de espaços ou colunas é maior, porque ele não considera o "Tab".
• Erro: error: expected ';' after expression – o compilador esperava um ponto e vírgula após a expressão.
• Expressão que deveria ter ponto e vírgula no final: printf("******************************************\n").

Cada item que esquecemos gera um erro diferente. Se não fecharmos a chave do código no Sublime, por exemplo:

#include <stdio.h>

int main() {
    printf("******************************************\n");
    printf("* Bem-vindo ao nosso jogo de adivinhação *\n");
    printf("******************************************\n");

O erro comunicado no terminal será diferente:

adivinhacao.c:7:1: error: expected '}'
^
adivinhacao.c:3:12: note: to match this '{'
int main() {
           ^
1 error generated.

O computador aponta onde estão os erros, mas não os corrige. Nesse caso, ele apontou que a chave não foi fechada, então temos que fazê-lo. Corrigido o erro no editor de texto:

#include <stdio.h>

int main() {
    printf("******************************************\n");
    printf("* Bem-vindo ao nosso jogo de adivinhação *\n");
    printf("******************************************\n");
}

Compilaremos no terminal e o programa é executado sem problemas:

Alura:adivinhacao alura$ gcc adivinhacao.c -o adivinhacao.out
Alura:adivinhacao alura$ ./adivinhacao.out
******************************************
* Bem-vindo ao nosso jogo de adivinhação *
******************************************
Alura:adivinhacao alura$

Por meio de comentários no C com o uso de //, antes que o programa comece a crescer, sinalizaremos o que cada trecho de código faz:

#include <stdio.h>

int main() {
    // imprime cabecalho do nosso jogo
    printf("******************************************\n");
    printf("* Bem-vindo ao nosso jogo de adivinhação *\n");
    printf("******************************************\n");
}

Ao compilarmos no terminal, veremos que isto não altera a execução do programa. O compilador oculta o que estiver após //. Utilizaremos esse comando para organizar e facilitar a leitura do código, quando necessário.

Nesta aula, estudamos:

• Equivalentes em Linguagem C:

  • Enter = \n, dentro da string

  • para adicionar comentários – visíveis somente para quem está programando – colocamos // antes do texto

• Quando há erros no código, o compilador avisa e aponta onde encontrá-los.

Sobre o curso C: conhecendo a Linguagem das Linguagens

O curso C: conhecendo a Linguagem das Linguagens possui 165 minutos de vídeos, em um total de 57 atividades. Gostou? Conheça nossos outros cursos de C e C++ em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Começando com Variáveis
• Condicionais e Loops com Ifs, For e While
• Tipos de dados e Operações Matemáticas
• Finalizando o jogo