Resumo básico da linguagem C para lógica de programação
Tags: c, logicadeprogramacao, algoritmos, portugues
Published: 2020-09-30 17:12:34

---
title: Resumo básico da linguagem C para lógica de programação
published: true
description: O básico da linguagem C para a matéria de lógica de programação em faculdades, com boas práticas e erros comuns
tags: c, logicadeprogramacao, algoritmos, portugues
cover_image: https://images.unsplash.com/photo-1578307898411-f6930dadea39?ixlib=rb-1.2.1&ixid=eyJhcHBfaWQiOjEyMDd9&auto=format&fit=crop&w=920&q=80
---
Esse texto é para você que acabou de entrar na __faculdade__ e está começando na matéria de __lógica de programação__, ou que é __autodidata__ e está estudando o assunto. Este é um resumo básico da linguagem C e não contempla todos os seus aspectos, apenas o necessário para que você possa começar a escrever seus primeiros __algoritmos__.

A proposta aqui é ser um __guia rápido__, com código, significado, erros comuns e boas práticas, para que você perca menos tempo se preocupando com sintaxe (como “falar” em C por si só) e mais com a lógica e o raciocínio para resolver o problema. 

Irei tratar de:

1. Contexto de linguagens de programação e do C
2. Estrutura básica de um programa em C
3. Tipos de dados
4. Atribuição
5. Escrevendo informações na tela 
6. Lendo dados fornecidos pelo usuário
7. Sequências de escape
8. Variáveis e constantes
9. Aritmética, operador de auto-incremento e auto-decremento
10. Estruturas de decisão 
11. Operadores lógicos e operadores relacionais
12. Estruturas de repetição 
13. Vetores

Observações: não copie os códigos, escreva linha por linha para treinar. Se encontrar um erro não se desespere. Leia o erro, tente entendê-lo, depois copie e pesquise na internet, caso já não tenha encontrado a solução.

## Contexto de linguagens de programação e do C
Assim como utilizamos uma linguagem para nos comunicar (linguagem natural), também utilizamos linguagens para “conversar” com o computador. Utilizando uma linguagem podemos dizer ao computador o que fazer, por isso chamamos de linguagem de programação. 

Como no final das contas o computador só entende em binário, 1 e 0, ele precisa traduzir e/ou interpretar a linguagem que estamos usando. No caso da linguagem C, ele será __compilada__ para que o computador possa nos entender. 

A linguagem C foi criada em 1972 por Dennis Ritchie e é bastante influente até hoje. Para saber mais sobre ela [dê uma lida na página do Wikipédia sobre a linguagem](https://pt.wikipedia.org/wiki/C_(linguagem_de_programa%C3%A7%C3%A3o)).  

## Estrutura básica de um programa em C
Depois de baixar o software indicado pelo(a) professor(a), crie uma estrutura básica de C assim:

```c
#include <stdio.h>
 
int main()
{

}
```

A diretiva `#include` está dizendo que queremos incluir algo pronto no programa e o `<stdio.h>` é uma biblioteca padrão do C, que significa *standard input/output* (“entrada/saída padrão”). Uma biblioteca é como uma coleção de recursos prontos que podemos adicionar ao nosso código. 

*__Erro comum__*: para fazer qualquer coisa básica no C você precisa colocar `#include <stdio.h>` no início do seu programa, senão dará erro de compilação.

O `int` é um indicativo de *inteiro* (pode pensar em números mesmo), e o `main` quer dizer *função principal*. O `main` será executado primeiro depois que o programa for compilado. 

O que estamos expressando nas linhas de 3 a 6 é que queremos iniciar o programa com a função principal e que essa função tem um retorno inteiro. Os `()` indicam que o main é uma função, e as `{}` indicam o corpo da função: é onde você, inicialmente, colocará seus códigos.

*__Erro comum__*: nunca se esqueça de fechar parênteses, colchetes e chaves nos programas, sempre fazendo os pares.

Sempre que for iniciar um exercício de lógica de programação aproveite e escreva logo essa estrutura básica, para não se esquecer.

Para fazer comentários no programa utilize `// comentário` e escreva numa linha, ou então utilize o bloco de comentário `/* comentário */`.

Obs: é possível que seu professor utilize algo como `int main(int argc, char *argv[]){}`, mas essa estrutura vai mais a fundo na linguagem.

## Tipos de dados
Para lidar com diferentes dados, como números ou letras, precisaremos utilizar __diferentes tipos de dados__. Basicamente você irá lidar com:

* `int`: use para números inteiros, entre −32,767 e +32,767
* `float`: use para números de ponto flutuante (com parte decimal), como 1555.456  (para o computador o ponto é a vírgula)
* `double`: use para números de ponto flutuante bem grandes (tem duas vezes mais “espaço” que o `float`)
* `char`: use para caracteres, como “a”, “M”, etc

No geral esses são os tipos mais comuns, mas você pode consultar essa [tabela de tipos mais completa da linguagem C](https://en.wikipedia.org/wiki/C_data_types).

*__Erro comum__*: se você declarar uma variável de um tipo e guardar, escrever ou ler um dado de outro tipo tem grande chances de dar erro de compilação. 

## Atribuição
O sinal de igual `=` é um sinal de __atribuição__. Isso quer dizer que estamos atribuindo algum dado a uma variável ou constante no nosso programa, ou seja, guardaremos um dado na memória.

Exemplo:

```c
#include <stdio.h>
 
int main()
{
    int numero = 10;
}
```
 
Declaramos o tipo da nossa variável, demos o nome de `número` a ela e atribuímos o valor 10, que agora está guardado.

Se formos utilizar um `char`, por exemplo, declaros assim:

```c
#include <stdio.h>
 
int main()
{
    char sexo = 'M';
}
```

Não é necessário atribuir um valor logo que declaramos a variável ou constante, você pode apenas inicializá-la, como em `int idade;`.

## Escrevendo informações na tela 
Para escrever informações na tela para o usuário faça assim:

```c
#include <stdio.h>

int main()
{
    printf("Olá, mundo");
}
```

O `printf` é uma função que temos acesso por causa do `<stdio.h>`. Ela __indica que algo será apresentado na tela para o usuário__, e para mostrar a frase nós utilizamos aspas duplas.

*__Erro comum__*: lembre-se sempre de fechar as aspas da frase. 

O __uso de ponto e vírgula ao final de cada instrução é extremamente importante__ na linguagem C. 

*__Erro comum__*: se você se esquecer do ponto e vírgula ao final dará erro de compilação.

Para “printar” um `int` na tela faça o seguinte:

```c
#include <stdio.h>

int main()
{
    int numero = 10;
    printf("%d", numero);
}
```

Veja como utilizamos o símbolo `%d` no `printf` para indicar que estamos printando um inteiro, fechamos as aspas duplas para representar o fim da frase, usamos uma vírgula e colocamos o nome da variável (iremos entender mais de variáveis depois). Cada tipo de dado, para ser printado ou lido, tem um indicador diferente. Veja:

* `int`: use `%d`
* `float`: use `%f`
* `double`: use `%lf`
* `char`: use `%c`

*__Erro comum__*: verifique se você usou o `%` ou se esqueceu de colocá-lo.

Se estiver printando um número de ponto flutuante e quiser definir o número de casas decimais, pode usar `%.2f`, por exemplo, para limitar para duas casas decimais.

## Lendo dados fornecidos pelo usuário
Para ler dados do usuário que está interagindo com o seu programa, faça o seguinte:

```c
#include <stdio.h>

int main()
{
    int idade;

    printf("Digite sua idade: ");
    scanf("%d", &idade);
  
    printf("Você tem %d anos", idade);
}
```

Inicializamos uma variável e a deixamos pronta para receber um dado do tipo inteiro, perguntamos a idade com o `printf`, utilizamos a função `scanf` para “escanear” o que o usuário digitar, que deve ser um `%d`, e guardamos na variável `idade` utilizando o `&` (“e” comercial ou *ampersand*).

*__Erro comum__*: se você se esquecer de colocar o `&` o dado não será lido e dará erro. 

Obs: para guardar uma string (uma sequência de caracteres, como “Olá”) você pode utilizar um vetor de `char` com o número de elementos que precisa, como, por exemplo `char ola[3]`. 

## Sequências de escape
Em algum momento você verá que um print final está “colado” ao terminal, ou então precisará dar um espaço na margem, ou então tentará imprimir aspas duplas dentro de aspas duplas. Para resolver essas situações utilizamos o __caracter de escape__ (*backslash*): `\`.

Algumas situações comuns e como representá-las:

* Para pular uma linha use `\n`
* Para adicionar uma tabulação (tab) use `\t`
* Para mostra um backslash no print use `\\`
* Para usar aspas duplas dentro de aspas duplas use `\"`

Escreva, compile e rode o código abaixo para ver o resultado:

```c
#include <stdio.h>

int main()
{
    int idade;
  
    printf("\tOlá! Bem-vindo.\n\n");

    printf("Digite sua idade: \n");
    scanf("%d", &idade);
  
    printf("Você tem \"%d anos\" de idade\n", idade);
}
```

Faça um teste: remova todos os `\t`, `\n` e `\”`, salve o código, compile e rode novamente para ver a diferença. 

*__Erro comum__*: verifique se você está usando a barra invertida mesmo ou se por engano usou a barra comum (`/`).

## Variáveis e constantes
Como já falamos aqui, utilizamos __variáveis__ para guardar um dado no nosso programa. Como o nome já diz, esses dados podem *mudar*. Para guardar um dado que não deve mudar no seu código utilize __constantes__. 

Variáveis e constantes são guardadas na memória do nosso computador, podendo ser declaradas de imediato (atribuindo um dado) ou apenas inicializadas (sem valor pronto, aguardando serem utilizadas).

Exemplos de variáveis:

```c
#include <stdio.h>
 
int main()
{
    int idade;
    float area_do_quadrado;
    char sexo = 'M';
    double numero_double = 1222223.999999; 
}
```

Para declarar constantes, coloque-as logo após a declaração de bibliotecas e utilize a diretiva `#define`:

```c
#include <stdio.h>

#define SEXO = 'M'
#define PI = 3.14159265359

int main()
{
    int idade;
    float area_do_quadrado;
}
```

*__Erro comum__*: não coloque ponto e vírgula ao final da declaração das constantes e não coloque a diretiva dentro da função `main`.

Obs: __utilize nomes descritivos para as variáveis e constantes__. Não é pecado usar um `i` numa estrutura `for`, por exemplo, mas sempre que possível tente dar nomes autoexplicativos. O código fica mais fácil de ler, para os outros e também para você mesmo.

## Aritmética, operador de auto-incremento e auto-decremento
Lidar com aritmética em C é bastante simples. Veja como representar as expressões: matemáticas:

```c
#include <stdio.h>

int main()
{
    int resultado;
    
    // soma
    resultado = 10 + 5; 
    printf("%d\n", resultado);

    // subtração
    resultado = 10 - 5;
    printf("%d\n", resultado);

    // multiplicação
    resultado = 10 * 5;
    printf("%d\n", resultado);

    // divisão
    resultado = 10 / 5;
    printf("%d\n", resultado);

    // resto da divisão
    resultado = 10 % 5;
    printf("%d\n", resultado);
}
```

O operador `%` numa expressão aritmética é o __módulo da divisão__, ou seja, é o __resto da divisão__.  

*__Erro comum__*: assim como na matemática, na linguagem C temos precedência de operadores, então utilize parênteses para indicar que alguma expressão deve ser calculada antes.

Quando quiser incrementar ou decrementar uma variável de forma automática, faça o seguinte:

* `i++`: significa `i = i + 1` 
* `i--`: significa `i = i - 1`

Essas estruturas são muito úteis principalmente em estruturas de repetição. Repare que, como `i` é uma variável, ela pode ter seu valor atualizado.

## Estruturas de decisão 
Quando precisamos tomar uma decisão no nosso código utilizamos __estruturas de decisão__. Alguns exemplos do que isso significa:

* *Se x for igual a 10, incremente*: aqui a estrutura que usamos é o `if` (se)
* *Se x for igual a 10, incremente. Senão, decremente*: aqui usamos `if else` (se… senão)
* *Escolha x caso 1, senão caso 2, senão caso 3*: para essa ideia, usamos `switch...case` (escolha-caso)

Essas situações acima podem ser representadas assim:

```c
#include <stdio.h>

int main()
{
    int numero = 10;

    if (numero == 10)
    {
        print("O número é igual a 10");   
    }
    else
    {
        print("O número não é igual a 10");   
    }
}
```

O programa acima vai printar “O número é igual a 10”, pois a variável `numero` é igual a 10. Leia da seguinte forma: “se a variável `numero` for igual a 10, print que o número é igual a 10, senão, print que não é igual a 10”.

Observe que você pode utilizar somente `if` sem `else`, exemplo: “se isso, faça aquilo”. Mas não pode utilizar o `else` sem um `if` antes, até porque não faz sentido. Podemos aninhar quantos ifs e elses forem necessários para nossa lógica.

Temos também o `else if`, onde podemos adicionar mais uma opção para o caso de não cair no 1º `if`. Observe:

```c
#include <stdio.h>

int main()
{
    int numero = 12;

    if (numero == 10)
    {
        numero++;
    }
    else if (numero == 12)
    {
        printf("Igual a 12.\n");
    }
    else
    {
        printf("Não é igual a nenhuma das opções!\n");
    }
}
```

Como aqui o `numero` é igual a 12, irá cair no `else if` e irá printar “Igual a 12” na tela.

Por fim, temos a estrutura de decisão `switch...case`, onde pré-determinamos todas as opções que podem ocorrer:

```c
#include <stdio.h>

int main ()
{
  int numero;
  
  printf ("Digite um numero de 1 a 3: ");
  scanf("%d", &numero);
  
  switch (numero)
  {
    case 1 :
        printf ("Digitou 1\n");
    break;
    
    case 2 :
        printf ("Digitou 2\n");
    break;
    
    case 3 :
        printf ("Digitou 3\n");
    break;

    default :
        printf ("Número inválido!\n");
  }
}
```

Cairemos no `default` quando o número digitado não for 1, 2 ou 3. 

Obs: preste atenção na __indentação do seu código__. Indentar é dar aquele espacinho entre a margem esquerda e o começo do código, de modo a deixar a estrutura mais legível. Para o C é muito comum usar 4 espaços (spaces), e basta dar um “Tab” para ajustar. Sempre que você estiver aninhando uma estrutura dentro de outra, por exemplo, é interessante utilizar um recuo.

## Operadores lógicos e operadores relacionais
Para __relacionar expressões__ usamos os seguinte operadores:

* Maior que: `>`
* Maior que ou igual a: `>=`
* Menor que: `<`
* Menor que ou igual a: `<=`
* Igual: `==`
* Diferente `!=`

Pense como na matemática: você estará relacionando duas ou mais expressões.

Veja o exemplo:

```c
#include <stdio.h>

int main()
{
    int idade = 17;

    if(idade > 18)
    {
        printf("Você é maior de idade.\n");
    }
    else
    {
        printf("Você não é maior de idade.\n");
    }
}
```

Como 17 não é maior que 18, o `else` entra em ação e printa a mensagem adequada.

Já para fazer __expressões lógicas__ (verdadeiro ou falso) em C temos alguns operadores: 

* E (and): use `&&`
* OU (or): use `||`
* NÃO (not): use `!`

Exemplo:

```c
#include <stdio.h>

int main()
{
    int idade;

    printf("Digite sua idade: \n");
    scanf("%d", &idade);

    if(idade < 18 && idade >=  16)
    {
        printf("Voto facultativo.\n");
    }
}
```

Repare que na expressão `idade < 18 && idade >=  16` estamos relacionando para ver se a idade é menor que 18 __E__ se também é maior ou igual a 16.

Para entender melhor as expressões lógicas, veja a tabela-verdade abaixo:

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/k0zv3qxe636t1ba5bgo4.png)

O `&&` só retorna verdadeiro se ambas expressões forem verdadeiras, o `||` só precisa que uma seja verdadeira para retornar verdadeiro e o `!` inverte a expressão (se for falsa, vira verdadeiro, se for verdadeiro, vira falso). Você pode [ler um pouco mais sobre tabelas-verdade aqui](https://pt.wikipedia.org/wiki/Tabela-verdade).

*__Erro comum__*: para evitar confusão em quais expressões lógicas serão verificadas primeiro, adicione parênteses, por exemplo, `(idade < 18 && idade >=  16) || (idade > 70)`. 

## Estruturas de repetição 
Quando precisamos repetir alguma lógica utilizamos as seguintes estruturas:

* __Enquanto__ houver a condição x, faça isso: aqui utilizamos um `while`
* __Repita__ x __até__ que y: é o caso do `for`
* __Faça__ x, __enquanto__ houver a condição y: utilizamos o `do...while`

```c
#include <stdio.h>

int main()
{
    int numero;

    while (numero > 0)
    {
        printf("Digite um número: ");
        scanf("%d", &numero);
    }
}
```

O programa acima pede para você digitar um número, e enquanto esse número for positivo, ele continuará te perguntando e lendo os números que você digitar. Ou seja, só vai sair da estrutura [`while`](http://linguagemc.com.br/o-comando-while-em-c/) quando você digitar um número negativo.

```c
#include <stdio.h>

int main()
{
    int soma = 0;
    int contador;

    for (contador = 1; contador <= 5; contador++)
    {
        soma = soma + contador;
    }

    printf("Soma: %d\n", soma);
}
```

Nesse programa nós declaramos que a `soma` inicial é 0 e inicializamos a variável `contador`. No [`for`](http://linguagemc.com.br/a-estrutura-de-repeticao-for-em-c/), começamos com o contador em 1, e enquanto o contador for menor que ou igual a 5 ele irá atualizar o valor da soma, somando o que já tinha com o valor atual do contador. No final das contas teremos “Soma: 15” printado na tela, que é a soma de 1 + 2 + 3 + 4 + 5.

Repare que:

1. `contador = 1` só é utilizado no começo
2. verificamos se `contador <= 5`, ou seja, se o valor atual do `contador` ainda satisfaz essa condição
4. realizamos a ação de dentro do bloco do `for`, ou seja, dentro dos `{}` 
5. incrementamos 1 ao valor atual do `contador`
6. verificamos se `contador <= 5`
7. realizamos a operação do bloco
8. incrementamos 1…

E por aí vai, até que o `contador` não satisfaça mais a condição.

Agora vamos ao exemplo de `do...while`:

```c
#include <stdio.h>

int main()
{
    int numero = 1;
	
    do
    {
        printf("Numero: %d\n", numero);
        numero++;
    }while (numero <= 3);
}
```

No exemplo acima iremos printar o `numero` atual, incrementar 1 a variável `numero` e continuar fazendo isso enquanto ela seja menor ou igual a 3. A diferença do [`do...while`](http://linguagemc.com.br/comando-do-while/) para o `while` é que __no `do...while` nós iremos entrar no bloco independente se a condição no while do final é verdadeira ou falsa__. No `while` se a condição não for satisfeita inicialmente nem vamos entrar no bloco.

*__Erro comum__*: analise bem se você está utilizando a estrutura correta para resolver o problema.

## Vetores
Usamos vetores para armazenar uma quantidade certa de dados do mesmo tipo. Declaramos assim:

```c
#include <stdio.h>

int main()
{
    int tabuada[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    char sexo[2];
    char iniciais = {"F", "G", "V"};
}
```

No código acima nós declaramos um vetor do tipo inteiro chamado `tabuada`, sendo que o `[10]` expressa a quantidade de elementos que temos no vetor, que são os números de 1 a 10. Se o vetor tivesse 5 elementos teríamos `[5]`.

Para identificar cada elemento do vetor usamos o seu __índice__, que começa a ser contado no 0. Exemplo: cada elemento `{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}` do exemplo acima poderá ser acessado com `tabuada[0]` que corresponde ao 1, `tabuada[1]` que corresponde ao 2, `tabuada[2]` que corresponde ao 3 e por aí vai.

*__Erro comum__*: lembre-se de verificar se você está olhando o número correto a partir do seu índice, ou se está contando erroneamente a partir do 1 ao invés de 0.

---
Por hora é isso. Acompanhe as aulas ou tutoriais que esteja fazendo e acompanhe com esse artigo para se lembrar da sintaxe. Para aprofundar seu conhecimento na linguagem C recomendo fortemente o livro *[Linguagem C: Completa e descomplicada](https://www.amazon.com.br/Linguagem-Completa-descomplicada-Andr%C3%A9-Backes-ebook/dp/B07K27L496/ref=sr_1_2?__mk_pt_BR=%C3%85M%C3%85%C5%BD%C3%95%C3%91&dchild=1&keywords=linguagem+c&qid=1593858199&sr=8-2)*, do professor [André Backes](https://www.youtube.com/user/progdescomplicada/featured). 

---
_Fontes:_
[Photo by CDC on Unsplash](https://unsplash.com/@cdc?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText)
[C data types](https://en.wikipedia.org/wiki/C_data_types)
[Truth table Wikipedia](https://commons.wikimedia.org/wiki/File:Truth_table_for_AND,_OR,_and_NOT.png)

---
_Esse texto não tem intenção de esgotar o tema. Acrescente nos comentários, e também aponte erros quando os identificar._