INTRODUÇÃO

PROGRAMAÇÃO

EM

LINGUAGEM C
Sumário

Introdução ............................................................................................................. 6

Lógica de Programação ..................................................................................... 6

Algoritmos ..................................................................................................... 7

Algoritmo Para o Cálculo de Média .............................................................. 8

Criar um algoritmo ........................................................................................ 9

O que é Programação em C? ........................................................................... 10

Ambiente de Desenvolvimento ........................................................................11

Características Principais ................................................................................ 12

Como Usar o Code::Blocks............................................................................. 12

Tipos de Dados e Variáveis ................................................................................. 13

Tipos Inteiros, de Ponto Flutuante, Caractere e Booleano .............................. 13

Tipos de Dados Inteiros ............................................................................... 13

Tipos de Dados de Ponto Flutuante ............................................................. 14

Tipo de Dado Caractere ............................................................................... 14

Tipo de Dado Booleano ............................................................................... 15

Declarando Variáveis ...................................................................................... 16

Atribuição de Valores .................................................................................. 17

Constantes ................................................................................................... 18

Funções de Entrada e Saída de Dados ................................................................ 20

Função printf() ................................................................................................ 20

Função scanf() ................................................................................................. 20

Operadores .......................................................................................................... 22

Operadores Aritméticos................................................................................... 22

Operadores de Atribuição ............................................................................... 22

Operadores de Comparação ............................................................................ 22

Operadores Lógicos ........................................................................................ 23

Página 2 de 50
 Operadores de Incremento e Decremento ....................................................... 23

Operador de Incremento: `++` ..................................................................... 23

Operador de Decremento: `--` ..................................................................... 24

Operadores de formatação de dados ............................................................... 24

Números em ponto flutuante ....................................................................... 25

Estruturas de Controle ........................................................................................ 27

Comando if e else ............................................................................................ 27

Explicação passo a passo ............................................................................. 27

Comando switch .............................................................................................. 28

Explicação passo a passo ............................................................................. 29

Laços de Repetição ......................................................................................... 30

for ................................................................................................................ 30

while ............................................................................................................ 32

do-while ....................................................................................................... 33

Funções ............................................................................................................... 35

O que são Funções?......................................................................................... 35

Declaração e Definição de Funções ................................................................ 35

Declaração de Função ................................................................................. 35

Definição de Função .................................................................................... 35

Tipos de Retorno ............................................................................................. 36

Passagem de Parâmetros ................................................................................. 37

Passagem por Valor ..................................................................................... 37

Passagem por Referência............................................................................. 38

Dicas Importantes ........................................................................................ 38

Funções Recursivas ......................................................................................... 38

Arrays e Matrizes ................................................................................................ 41

O que é um Array em C? ................................................................................ 41

Página 3 de 50
 Declaração de Arrays ...................................................................................... 41

Acesso a Elementos ........................................................................................ 41

Iterando sobre um Array ................................................................................. 41

Limitações dos Arrays .................................................................................... 42

Arrays Multidimensionais (Matrizes) ............................................................. 42

Declarando uma Matriz ............................................................................... 42

Inicializando uma Matriz............................................................................. 42

Acessando Elementos de uma Matriz ......................................................... 42

Iterando sobre uma Matriz .......................................................................... 43

Limitações das Matrizes .............................................................................. 43

Exemplos Práticos .............................................................................................. 44

Calculadora Simples ....................................................................................... 44

Verificação de Números Múltiplos ................................................................. 45

Manipulação de Matrizes ................................................................................ 46

Exemplo 1: Preenchendo e Imprimindo uma Matriz .................................. 46

Exemplo 2: Soma de Duas Matrizes ........................................................... 47

Exemplo 3: Transposição de Matriz ............................................................ 47

Exercícios ........................................................................................................... 49

1. Exercício: Soma de Números ...................................................................... 49

2. Exercício: Média de Números..................................................................... 49

3. Exercício: Verificador de Par ou Ímpar ....................................................... 49

4. Exercício: Calculadora Simples em loop .................................................... 49

5. Exercício: Fatorial ....................................................................................... 49

6. Exercício: Tabuada ...................................................................................... 49

7. Exercício: Conversor de Temperatura ......................................................... 49

8. Exercício: Contagem Regressiva ................................................................ 49

9. Exercício: Sequência Fibonacci .................................................................. 50

Página 4 de 50
Bibliografia ......................................................................................................... 50

Página 5 de 50
 INTRODUÇÃO
Bem-vindo à Apostila de Introdução à Programação em C! Nesta apostila, você
aprenderá os fundamentos da linguagem de programação C, incluindo tipos de dados,
operadores, variáveis, estruturas de controle, funções e matrizes. Ao final do curso, você
terá uma base sólida para criar programas simples em C e entender conceitos básicos de
programação.

Lógica de Programação
A lógica de programação é a habilidade fundamental que um programador precisa
para desenvolver soluções eficazes para problemas utilizando algoritmos. Ela envolve o
processo de planejamento, organização e estruturação das instruções que um computador
deve seguir para executar uma tarefa específica. Aqui estão os conceitos essenciais da
lógica de programação:

1. Algoritmos

Um algoritmo é uma sequência de passos bem definidos que leva a um resultado

específico. Ele é a base para resolver problemas de programação. Um bom algoritmo é
eficiente, claro e compreensível.

2. Variáveis e Tipos de Dados

As variáveis são usadas para armazenar informações temporariamente. Os tipos

de dados (inteiros, ponto flutuante, caracteres, etc.) determinam que tipo de informação a
variável pode conter.

3. Estruturas de Controle

As estruturas de controle são usadas para direcionar o fluxo de execução do

programa. Isso inclui estruturas de decisão (if, else, switch) e estruturas de repetição
(while, for, do-while) para tomar decisões e repetir tarefas.

4. Entrada e Saída

A interação com o usuário e a comunicação com o mundo externo são realizadas

por meio de entradas (dados inseridos pelo usuário ou por outros sistemas) e saídas
(resultados exibidos ou enviados).

5. Funções e Modularização

Página 6 de 50
 Funções são blocos de código que podem ser chamados várias vezes, promovendo
a reutilização e a organização do código. A modularização divide um programa em partes
menores, facilitando a manutenção e a colaboração.

6. Estruturas de Dados

Entender como usar arrays, listas, pilhas, filas e outros tipos de estruturas de dados
é fundamental para organizar e manipular informações de maneira eficiente.

7. Resolução de Problemas

A lógica de programação envolve a habilidade de dividir um problema complexo

em partes menores, analisá-las individualmente e, em seguida, combiná-las para formar
a solução completa.

8. Abstração

Abstrair significa focar apenas nos detalhes relevantes e ignorar os detalhes

irrelevantes. Isso ajuda a simplificar o processo de resolução de problemas.

9. Pseudocódigo e Diagramas de Fluxo

Pseudocódigo é uma descrição narrativa dos passos do algoritmo. Diagramas de

fluxo são representações visuais que mostram o fluxo de execução de um algoritmo.

Dominar a lógica de programação é fundamental antes de mergulhar em qualquer

linguagem de programação específica. Ela é uma habilidade transferível que ajudará você
a resolver problemas em várias áreas da ciência da computação e desenvolvimento de
software.

Algoritmos
Um algoritmo é um conjunto finito e ordenado de instruções precisas e bem
definidas que descrevem uma sequência de passos a serem seguidos para resolver um
determinado problema ou realizar uma tarefa específica. Em outras palavras, é um plano
ou procedimento lógico que guia a execução de uma série de ações para atingir um
objetivo desejado.

Características dos algoritmos:

Página 7 de 50
 1. Precisão: Cada passo do algoritmo deve ser claramente definido, sem
ambiguidades, para que qualquer pessoa ou computador possa entender e seguir
as instruções.
2. Finitude: O algoritmo deve ter um número finito de passos, ou seja, ele deve
eventualmente chegar a um fim após um número finito de etapas.
3. Eficiência: Um bom algoritmo é projetado para ser eficiente, ou seja, deve atingir
o objetivo com um número mínimo de passos ou operações.
4. Entrada: O algoritmo deve receber uma entrada (dados ou informações) sobre os
quais ele vai operar para produzir uma saída.
5. Saída: O algoritmo produz uma saída (resultado) após a execução das etapas.
6. Determinismo: Cada etapa do algoritmo deve ser determinística, ou seja, para um
conjunto específico de entradas, as mesmas instruções levarão sempre ao mesmo
resultado.

Algoritmos são usados em diversas áreas, como ciência da computação,

matemática, engenharia, economia e muitas outras. Eles formam a base para a resolução
de problemas complexos e são essenciais para o desenvolvimento de software, pois guiam
os computadores na execução de tarefas específicas. Um algoritmo pode ser expresso de
várias formas, como pseudocódigo, diagramas de fluxo ou em uma linguagem de
programação.

Algoritmo Para o Cálculo de Média

Vamos analisar um exemplo básico de um algoritmo que calcula a média de dois
números:

Algoritmo: Calcular Média

Início
// Declaração de variáveis
Real numero1, numero2, media;
// Entrada de dados
Escreva("Digite o primeiro número: ")
Leia(numero1)
Escreva("Digite o segundo número: ")
Leia(numero2)
// Cálculo da média

Página 8 de 50
 media <- (numero1 + numero2) / 2

// Saída do resultado
Escreva("A média é: ", media)
Fim
Neste algoritmo:

1. As variáveis numero1, numero2 e media são declaradas para armazenar os

números inseridos e o resultado da média.
2. Os números são lidos a partir da entrada padrão (no caso, do teclado) usando a
função Leia().
3. A média é calculada somando os dois números e dividindo por 2.
4. O resultado da média é exibido na saída padrão usando a função Escreva().

Este é um exemplo simples de como um algoritmo pode ser estruturado para

realizar uma tarefa específica. Lembre-se de que em uma linguagem de programação real,
como C, C++, Java ou Python, a estrutura seria um pouco diferente, mas a lógica básica
permanece a mesma.

Criar um algoritmo
Para criar um algoritmo, siga estas etapas básicas:

1. Entenda o Problema

Antes de começar a escrever o algoritmo, você precisa compreender claramente

qual é o problema que deseja resolver. Defina o objetivo e os requisitos para chegar à
solução.

2. Dívida em Etapas

Divida o problema em etapas menores e mais simples. Isso ajuda a abordar o

problema de maneira mais gerenciável.

3. Pseudocódigo ou Fluxograma

Escreva o algoritmo em pseudocódigo (uma descrição narrativa dos passos) ou

crie um diagrama de fluxo para visualizar o fluxo das etapas. Isso ajuda a planejar a lógica
do algoritmo antes de traduzi-lo para uma linguagem de programação.

Página 9 de 50
 4. Escreva as Instruções

Comece a escrever as instruções passo a passo, descrevendo exatamente o que

cada etapa faz. Use uma linguagem simples e clara.

5. Use Estruturas de Controle

Inclua estruturas de controle como estruturas de decisão (if, else) e estruturas de

repetição (for, while) quando necessário para direcionar o fluxo do programa.

6. Teste e Revisão

Após escrever o algoritmo, revise cuidadosamente para garantir que todas as

etapas façam sentido e estejam corretas. Você também pode executar o algoritmo
mentalmente ou em um pedaço de papel para verificar se ele resolve o problema conforme
o esperado.

7. Traduza para uma Linguagem de Programação

Se você deseja implementar o algoritmo em uma linguagem de programação,

traduza-o para a sintaxe dessa linguagem. A estrutura geral do algoritmo permanecerá a
mesma, mas a sintaxe será específica da linguagem escolhida.

8. Teste a Implementação

Após traduzir o algoritmo para uma linguagem de programação, teste a

implementação com dados de exemplo para garantir que ela funcione conforme o
planejado.

Lembre-se de que a prática é fundamental. À medida que você ganha experiência,

você se tornará mais eficiente na criação de algoritmos e na resolução de problemas.
Comece com problemas simples e, gradualmente, aborde problemas mais complexos à
medida que você desenvolve suas habilidades de lógica de programação.

O que é Programação em C?
A programação em C é um processo pelo qual você cria, desenvolve e escreve
instruções em linguagem C para que um computador possa executar tarefas específicas.
A linguagem de programação C é uma das linguagens mais populares e influentes na área
de desenvolvimento de software. Foi criada originalmente por Dennis Ritchie na década

Página 10 de 50
de 1970 e desde então tem sido amplamente usada em uma variedade de aplicações, desde
sistemas operacionais até aplicativos de desktop e sistemas embarcados.

A linguagem C é conhecida por sua eficiência, portabilidade e controle de baixo

nível. Ela permite que os programadores tenham um alto nível de controle sobre o
hardware do computador, enquanto ainda oferece abstrações poderosas que tornam o
desenvolvimento mais conveniente.

Alguns conceitos chave da programação em C incluem:

➢ Tipos de Dados: C oferece diversos tipos de dados, como inteiros, ponto flutuante,
caracteres, entre outros, que permitem ao programador manipular diferentes tipos
de informações.
➢ Estruturas de Controle: Isso inclui comandos condicionais (como if e switch) para
tomar decisões em um programa, e loops (como for, while e do-while) para repetir
tarefas.
➢ Funções: As funções permitem dividir um programa em partes menores e mais
gerenciáveis. Cada função realiza uma tarefa específica.
➢ Ponteiros: Ponteiros são elementos fundamentais em C que permitem manipular
diretamente a memória e endereços de variáveis.
➢ Matrizes e Ponteiros para Funções: C oferece recursos para manipular matrizes e
usar ponteiros para funções, o que proporciona flexibilidade e poder ao
programador.

A programação em C é essencial para quem deseja entender os fundamentos da

programação de computadores e aprender conceitos que são utilizados em diversas outras
linguagens de programação. É uma ótima linguagem para aprender tanto para iniciantes
quanto para aqueles que desejam se aprofundar na área de desenvolvimento de software.

Ambiente de Desenvolvimento
O Code::Blocks é um ambiente de desenvolvimento integrado (IDE) de código
aberto que é amplamente utilizado por programadores para escrever, compilar e depurar
programas em várias linguagens de programação, incluindo C e C++. Ele oferece uma
interface amigável e várias ferramentas para facilitar o processo de desenvolvimento de
software. Aqui estão alguns aspectos chave do ambiente de desenvolvimento
Code::Blocks.

Página 11 de 50
 Características Principais
1. Interface Gráfica: O Code::Blocks possui uma interface gráfica intuitiva que
permite aos programadores criar, editar e depurar códigos de maneira conveniente.
2. Compilação e Execução: Ele suporta a compilação e execução direta de
programas em várias linguagens, incluindo C e C++.
3. Depuração Integrada: O IDE possui um depurador integrado que ajuda a
identificar e corrigir erros no código, permitindo que você inspecione variáveis,
acompanhe a execução passo a passo e defina pontos de interrupção.
4. Gerenciamento de Projetos: O Code::Blocks permite criar projetos que podem
conter vários arquivos de código-fonte. Isso ajuda a organizar o desenvolvimento
de software complexo.
5. Editor de Código: Oferece um editor de código com recursos como realce de
sintaxe, recuo automático, preenchimento automático e muito mais.
6. Gerenciamento de Bibliotecas: Permite a integração de bibliotecas externas e
oferece ferramentas para configurar e vincular bibliotecas.
7. Customização: O Code::Blocks é altamente customizável. Você pode personalizar
atalhos de teclado, esquemas de cores e mais de acordo com suas preferências.

Como Usar o Code::Blocks

1. Instalação: Baixe e instale o Code::Blocks a partir do site oficial ou de fontes
confiáveis.
2. Criar um Novo Projeto: Selecione a opção "Novo projeto" no menu e escolha o
tipo de projeto (por exemplo, Console Application para C). Siga as etapas para
configurar o projeto.
3. Escrever Código: Use o editor de código para escrever seu programa C.
4. Compilar e Executar: Pressione o botão de compilação (geralmente um ícone de
martelo ou uma engrenagem) para compilar seu programa. Em seguida, pressione
o botão de execução (geralmente um ícone de seta) para rodá-lo.
5. Depurar: Use o depurador integrado para identificar erros, rastrear a execução e
corrigir problemas.

O Code::Blocks é uma escolha popular para programadores devido à sua interface

amigável e recursos abrangentes. No entanto, lembre-se de que existem várias outras
IDEs disponíveis, e a escolha depende das suas necessidades e preferências pessoais.

Página 12 de 50
 TIPOS DE DADOS E VARIÁVEIS
Em programação, tipos de dados e variáveis são conceitos fundamentais usados
para armazenar e manipular informações em um programa. Vamos entender melhor esses
conceitos em relação à linguagem de programação C:

Tipos de Dados e Variáveis

Os tipos de dados especificam o tipo de valor que uma variável pode armazenar. Eles
definem a faixa de valores possíveis e as operações que podem ser realizadas sobre esses
valores. Em C, existem diversos tipos de dados, como inteiros, ponto flutuante, caracteres
e mais. Alguns exemplos:

• int: Armazena números inteiros, como 42 ou -10.

• float: Armazena números de ponto flutuante, como 3.14 ou -0.5.
• char: Armazena caracteres individuais, como 'A' ou '$'.
• double: Similar ao float, mas com maior precisão.

Variáveis

Uma variável é um nome que você atribui a um local na memória do computador

para armazenar um valor específico. As variáveis são usadas para armazenar dados
durante a execução do programa. Antes de usar uma variável, você precisa declará-la,
especificando seu tipo de dados.

Em C, as variáveis devem ser declaradas antes de serem usadas, e seus nomes são
sensíveis a maiúsculas e minúsculas. Elas podem ser usadas para armazenar dados
temporários, cálculos intermediários e informações necessárias para a execução do
programa.

Resumindo, os tipos de dados definem o tipo de valor que uma variável pode
armazenar, e as variáveis são os "nomes" que você atribui aos locais de memória onde os
valores são armazenados. Juntos, esses conceitos são essenciais para a manipulação de
dados em programas C.

Tipos Inteiros, de Ponto Flutuante, Caractere e Booleano

Tipos de Dados Inteiros
Os tipos de dados inteiros em C são usados para armazenar números inteiros
(números sem parte decimal).

Página 13 de 50
 ➢ int: O tipo int é usado para armazenar números inteiros. Ele normalmente ocupa
4 bytes (32 bits) na maioria das plataformas modernas. Por exemplo:

int idade = 25;

➢ short int: É uma versão menor do tipo "int", ocupando normalmente 2 bytes (16
bits). Pode armazenar valores inteiros menores. Por exemplo:

short int contagem = 100;

➢ long int: É uma versão maior do tipo "int", ocupando normalmente 4 bytes (32
bits) ou mais. Pode armazenar valores inteiros maiores. Por exemplo:

long int populacao = 1000000;

➢ unsigned int: Também é do tipo "int", mas é usado apenas para armazenar
números inteiros positivos (não negativos). Por exemplo:

unsigned int quantidade = 42;

Tipos de Dados de Ponto Flutuante

Os tipos de dados de ponto flutuante em C são usados para armazenar números
com parte decimal (números reais).

➢ float: O tipo float é usado para armazenar números de ponto flutuante. Ele
normalmente ocupa 4 bytes (32 bits) e tem uma precisão limitada. Por exemplo:

float altura = 1.75;

➢ double: O tipo double é usado para armazenar números de ponto flutuante com
maior precisão. Ele normalmente ocupa 8 bytes (64 bits) e é mais preciso que o
float. Por exemplo:

double pi = 3.14159265;
Tipo de Dado Caractere
O tipo de dado caractere em C é usado para armazenar caracteres individuais.

➢ char: O tipo char é usado para armazenar um único caractere. Ele normalmente
ocupa 1 byte (8 bits) e pode representar letras, números e símbolos. Por exemplo:

char letra = 'A';

Página 14 de 50
 Esses tipos de dados são fundamentais em C e são usados para armazenar
diferentes tipos de informações em programas. Eles fornecem a base para a manipulação
de dados numéricos e de caracteres.

Tipo de Dado Booleano

Em C, o tipo de dado booleano não é nativamente suportado como em algumas
outras linguagens de programação. No entanto, você pode simular um tipo booleano
utilizando convenções numéricas.

Os valores de verdadeiro (true) e falso (false) são frequentemente representados

como 1 e 0, respectivamente. Para simular um tipo booleano em C, você pode usar a
biblioteca stdbool.h que introduz os identificadores true e false como macros.

Exemplo usando stdbool.h:

#include <stdbool.h>
#include <stdio.h>
int main() {
bool estaChovendo = true;
bool temSol = false;

if (estaChovendo) {
printf("Está chovendo.\n");
}
if (!temSol) {
printf("Não tem sol.\n");
}
return 0;
}
No entanto, mesmo sem a biblioteca stdbool.h, você pode usar inteiros para
representar valores booleanos:

#include <stdio.h>
int main() {
int estaChovendo = 1; // verdadeiro
int temSol = 0; // falso

Página 15 de 50
 if (estaChovendo) {
printf("Está chovendo.\n");
}
if (!temSol) {
printf("Não tem sol.\n");
}
return 0;
}
Apesar de C não ter um tipo booleano embutido, a maioria das expressões
relacionais e lógicas em C retorna 0 para falso e 1 para verdadeiro. Isso permite que você
use avaliações lógicas em seus programas. Se você preferir uma abordagem mais
explícita, a biblioteca stdbool.h pode ser útil.

Declarando Variáveis
Para declarar uma variável em C, você precisa especificar o tipo de dados da
variável, seguido pelo seu nome. Aqui está a sintaxe geral para declarar uma variável em
C:

tipo_de_dados nome_da_variavel;
Vou dar alguns exemplos para ilustrar como declarar diferentes tipos de variáveis
em C:

Exemplos:

➢ Variável Inteira:

int idade; // Declaração de uma variável inteira chamada 'idade'

➢ Variável de Ponto Flutuante:

float altura; // Declaração de uma variável de ponto flutuante chamada

'altura'

➢ Variável Caractere:

char letra; // Declaração de uma variável caractere chamada 'letra'

➢ Variável Lógica (Verdadeiro/Falso):

bool estaChovendo; // Declaração de uma variável do tipo booleana

Página 16 de 50
 Ao declarar variáveis em C, você está essencialmente reservando um espaço na
memória para armazenar valores do tipo especificado. Certifique-se de escolher nomes
significativos para suas variáveis e escolher o tipo de dados apropriado para o que você
deseja armazenar.

Atribuição de Valores
Atribuir valores a variáveis em C é feito utilizando o operador de atribuição `=`.
Você pode usar esse operador para associar um valor a uma variável que foi previamente
declarada. Aqui estão alguns exemplos de como atribuir valores a variáveis em C:

Exemplos:

➢ Variável Inteira:

int idade; // Declarando a variável inteira 'idade'

idade = 25; // Atribuindo o valor 25 à variável 'idade'
➢ Variável de Ponto Flutuante:

float altura; // Declarando a variável de ponto flutuante 'altura'

altura = 1.75; // Atribuindo o valor 1.75 à variável 'altura'
➢ Variável Caractere:

char letra; // Declarando a variável caractere 'letra'

letra = 'A'; // Atribuindo o caractere 'A' à variável 'letra'

➢ Variável Lógica (Verdadeiro/Falso):

int estaChovendo; // Declarando a variável inteira 'estaChovendo'

estaChovendo = 1; // Atribuindo o valor 1 (verdadeiro) à variável 'estaChovendo'
➢ Atribuição Direta:

Você também pode fazer a declaração e atribuição em uma única linha.

int numero = 42; // Declarando e atribuindo o valor 42 à variável 'numero'

float preco = 9.99; // Declarando e atribuindo o valor 9.99 à variável 'preco'
char inicial = 'J'; // Declarando e atribuindo o caractere 'J' à variável 'inicial'
Lembre-se de que, após atribuir um valor a uma variável, você pode usar essa
variável em cálculos, exibições e outras operações dentro do seu programa. Certifique-se

Página 17 de 50
de usar o tipo de dados correto ao atribuir um valor, para que o valor seja compatível com
o tipo de variável que você está usando.

Constantes
Constantes em C são valores fixos que não podem ser alterados após serem
definidos. Elas são usadas para representar informações que permanecem constantes
durante a execução de um programa, como números, caracteres e valores especiais.
Constantes tornam o código mais legível, evitam erros e facilitam a manutenção.

Existem dois tipos principais de constantes em C: constantes literais e constantes

simbólicas.

Constantes Literais:

Constantes literais são valores específicos que são usados diretamente no código.
Eles podem ser de diferentes tipos de dados, como inteiros, ponto flutuante, caracteres
e strings. Aqui estão alguns exemplos de constantes literais:

➢ Constantes Inteiras: `42`, `-10`

➢ Constantes de Ponto Flutuante: `3.14`, `-0.5`
➢ Constantes de Caractere: `'A'`, `'x'`
➢ Constantes de String: `"Olá, Mundo"`

Constantes Simbólicas

Constantes simbólicas são definidas usando a diretiva de pré-processamento

`#define`. Elas são substituições de texto que ocorrem antes da compilação, e permitem
que você defina um nome para um valor constante. As constantes simbólicas são
frequentemente usadas para evitar valores "mágicos" no código e facilitar a manutenção.
Aqui está um exemplo de como criar uma constante simbólica:

#define PI 3.14159265
#define TAMANHO_MAXIMO 100
No exemplo acima, PI será substituído por 3.14159265 sempre que for usado no
código, e TAMANHO_MAXIMO será substituído por 100.

Para criar constantes simbólicas, você utiliza a diretiva `#define` seguida pelo
nome da constante e seu valor. Geralmente, essas definições são colocadas no início do
arquivo de código.

Página 18 de 50
 Exemplo:

#include <stdio.h>
#define PI 3.14159265
int main() {
float raio = 5.0;
float area = PI * raio * raio;
printf("Área do círculo: %f\n", area);
return 0;
}
Neste exemplo, a constante simbólica PI é usada para calcular a área de um
círculo. O uso de constantes torna o código mais claro e evita a repetição de valores.

Página 19 de 50
 FUNÇÕES DE ENTRADA E SAÍDA DE DADOS
As funções de entrada e saída de dados em C estão presentes na biblioteca padrão
stdio.h. Essas funções permitem que você interaja com o usuário (entrada) e exiba
informações (saída) durante a execução do programa. As duas principais funções de
entrada/saída são printf() e scanf().

Função printf()
A função printf() é usada para imprimir (exibir) informações na saída padrão
(geralmente a tela). Ela é usada para formatar e exibir dados na forma de texto.

Sintaxe básica:

int printf(const char *formato, ...);

➢ formato: Uma string que especifica como os argumentos devem ser formatados
e exibidos. Pode conter caracteres normais e especificadores de formato, como
%d, %f, %c, %s, etc.
➢ ...: Representa os argumentos que você deseja imprimir de acordo com os
especificadores de formato na string.

Exemplo:

int idade = 25;

printf("Minha idade é %d anos.\n", idade);
Função scanf()
A função scanf() é usada para ler dados da entrada padrão (geralmente o teclado).
Ela permite que o programa receba dados do usuário.

Sintaxe básica:

int scanf(const char *formato, ...);

➢ formato: Uma string que especifica como os dados devem ser lidos. Ela contém
os mesmos especificadores de formato que o printf().
➢ ...: Ponteiros para as variáveis onde os dados lidos serão armazenados.

Exemplo:

int numero;
printf("Digite um número inteiro: ");

Página 20 de 50
 scanf("%d", &numero);
Importante:

➢ Os especificadores de formato são usados para definir o tipo de dado que será lido
ou impresso.
➢ O scanf() deve ser usado com cuidado para evitar problemas de entrada inválida
ou inadequada.
➢ O printf() permite formatação de saída, permitindo que você controle o layout e a
aparência dos dados impressos.
➢ Os parâmetros para printf() e scanf() são separados por vírgulas.

Ambas as funções são parte da biblioteca padrão stdio.h em C. O uso correto dessas
funções é importante para interagir eficientemente com o usuário e exibir informações
formatadas.

Página 21 de 50
 OPERADORES
Os operadores em C são símbolos especiais usados para realizar operações em
variáveis e valores. Eles permitem que você realize cálculos, comparações e outras
manipulações de dados em seus programas. Os operadores em C podem ser divididos em
várias categorias, como operadores aritméticos, operadores de atribuição, operadores de
comparação, operadores lógicos, entre outros. Aqui estão alguns exemplos das categorias
mais comuns de operadores em C:

Operadores Aritméticos
Esses operadores são usados para realizar operações matemáticas em variáveis.

➢ + (Adição): Soma dois valores.

➢ - (Subtração): Subtrai um valor do outro.
➢ \* (Multiplicação): Multiplica dois valores.
➢ / (Divisão): Divide um valor pelo outro.
➢ % (Módulo): Retorna o resto da divisão entre dois valores.

Operadores de Atribuição
Esses operadores são usados para atribuir valores a variáveis.

➢ = (Atribuição): Atribui o valor à variável.

➢ += (Atribuição de Adição): Adiciona o valor à variável e atribui o resultado.
➢ -= (Atribuição de Subtração): Subtrai o valor da variável e atribui o resultado.
➢ *= (Atribuição de Multiplicação): Multiplica o valor da variável e atribui o
resultado.
➢ /= (Atribuição de Divisão): Divide o valor da variável e atribui o resultado.

Operadores de Comparação
Esses operadores são usados para comparar valores.

➢ == (Igual a): Retorna verdadeiro se os valores forem iguais.

➢ != (Diferente de): Retorna verdadeiro se os valores forem diferentes.
➢ < (Menor que): Retorna verdadeiro se o valor da esquerda for menor que o da
direita.
➢ (Maior que): Retorna verdadeiro se o valor da esquerda for maior que o da direita.
➢ <= (Menor ou igual a): Retorna verdadeiro se o valor da esquerda for menor ou
igual ao da direita.
Página 22 de 50
 ➢ >= (Maior ou igual a): Retorna verdadeiro se o valor da esquerda for maior ou
igual ao da direita.

Operadores Lógicos
Esses operadores são usados para combinar expressões lógicas.

➢ && (E lógico): Retorna verdadeiro se ambas as expressões forem verdadeiras.

➢ || (OU lógico): Retorna verdadeiro se pelo menos uma das expressões for
verdadeira.
➢ ! (NÃO lógico): Inverte o valor de verdadeiro para falso e vice-versa.

Esses são apenas alguns dos operadores disponíveis em C. Eles são fundamentais
para realizar tarefas como cálculos, decisões e manipulação de dados em seus programas.

Operadores de Incremento e Decremento

Os operadores de incremento e decremento em C são utilizados para aumentar ou
diminuir o valor de uma variável em uma unidade. Eles são úteis para realizar operações
de contagem, iteração e atualização de valores de forma conveniente. Os operadores de
incremento e decremento podem ser pré-fixados ou pós-fixados. Aqui estão os detalhes:

Operador de Incremento: `++`

O operador de incremento aumenta o valor de uma variável por uma unidade.

1. Pré-fixado: ++variável
➢ Incrementa a variável antes de usar seu valor.
2. Pós-fixado: variável++
➢ Usa o valor atual da variável e, em seguida, incrementa.

Exemplos:

int numero = 5;
int resultado;
// Pré-fixado
resultado = ++numero; // 'numero' é incrementado para 6
antes de ser atribuído a 'resultado'
// Pós-fixado
resultado = numero++; // 'numero' é atribuído a
'resultado' (valor 6), então é incrementado para 7

Página 23 de 50
 Operador de Decremento: `--`
O operador de decremento diminui o valor de uma variável por uma unidade.

1. Pré-fixado: --variável
➢ Decrementa a variável antes de usar seu valor.
2. Pós-fixado: variável--
➢ Usa o valor atual da variável e, em seguida, decrementa.

Exemplos:

int numero = 10;

int resultado;
// Pré-fixado
resultado = --numero; // 'numero' é decrementado para 9
antes de ser atribuído a 'resultado'
// Pós-fixado
resultado = numero--; // 'numero' é atribuído a
'resultado' (valor 9), então é decrementado para 8
Os operadores de incremento e decremento são muito úteis em loops e iterações,
onde você precisa alterar o valor de uma variável para percorrer elementos ou realizar
contagens. Certifique-se de compreender a diferença entre o uso pré-fixado e pós-fixado,
pois isso pode afetar o comportamento do seu código.

Operadores de formatação de dados

Em C, os operadores de formatação são usados com funções de entrada/saída para
especificar o formato no qual os dados devem ser lidos ou exibidos. Eles são usados
principalmente com as funções printf() (saída) e scanf() (entrada) da biblioteca padrão
stdio.h.

Aqui estão alguns dos operadores de formatação mais comuns em C:

➢ %d: Formatação para números inteiros (decimal).

➢ %f: Formatação para números de ponto flutuante.
➢ %c: Formatação para caracteres.
➢ %s: Formatação para strings (arrays de caracteres).
➢ %x ou %X: Formatação para números inteiros em formato hexadecimal.
➢ %o: Formatação para números inteiros em formato octal.

Página 24 de 50
 ➢ %u: Formatação para números inteiros sem sinal.
➢ %%: Representa o próprio caractere de porcentagem (%).

Exemplos de uso:

int numero = 42;

float valor = 3.14;
char letra = 'A';
char nome[] = "João";
printf("Número inteiro: %d\n", numero);
printf("Número de ponto flutuante: %f\n", valor);
printf("Caractere: %c\n", letra);
printf("String: %s\n", nome);
No caso do scanf(), os operadores de formatação são usados para indicar o tipo
de dado que está sendo lido:

int idade;
float altura;
char nome[50];
scanf("%d", &idade);
scanf("%f", &altura);
scanf("%s", nome);
Lembre-se de que é importante usar os operadores de formatação corretamente
para corresponder ao tipo de dado que você está manipulando. O uso incorreto de
operadores de formatação pode levar a comportamentos imprevisíveis e erros na leitura
ou exibição dos dados.

Números em ponto flutuante

Em C, você pode usar o operador de formatação %f para formatar números em
ponto flutuante ao imprimir ou exibir valores. Aqui estão alguns exemplos de como
formatar números em ponto flutuante:

#include <stdio.h>
int main() {
float numero1 = 3.14159;
double numero2 = 1234.56789;

Página 25 de 50
 // Exemplo 1: Imprimir com precisão padrão
printf("Número 1: %f\n", numero1);
printf("Número 2: %f\n", numero2);
// Exemplo 2: Imprimir com precisão limitada
printf("Número 1 com 2 casas decimais: %.2f\n", numero1);
printf("Número 2 com 3 casas decimais: %.3f\n", numero2);
// Exemplo 3: Notação científica
printf("Número 1 em notação científica: %e\n", numero1);
printf("Número 2 em notação científica: %e\n", numero2);
// Exemplo 4: Largura mínima de campo
printf("Número 1 com largura mínima de campo 10: %10f\n",
numero1);
printf("Número 2 com largura mínima de campo 15: %15f\n",
numero2);
return 0;
}
Neste exemplo, o programa demonstra diferentes formas de formatar números em
ponto flutuante usando o operador %f juntamente com outras opções de formatação. Note
que:

➢ %f: imprime o número em notação decimal padrão.

➢ .2 após % especifica que você deseja imprimir com 2 casas decimais.
➢ %e é usado para notação científica.
➢ %10f indica que você deseja que o número seja impresso com uma largura
mínima de campo de 10 caracteres, o que pode ser útil para alinhar valores em
uma coluna.

Lembre-se de que a formatação de números em ponto flutuante depende das suas

necessidades específicas e pode variar de acordo com o contexto de uso.

Página 26 de 50
 ESTRUTURAS DE CONTROLE
Em C, as estruturas de controle são usadas para controlar o fluxo de execução de
um programa. Elas permitem que você tome decisões, repita ações e realize diferentes
caminhos de acordo com condições específicas. As três principais estruturas de controle
em C são:

➢ Estrutura de Decisão (if, else if, else)

➢ Estrutura de Seleção (switch)
➢ Estrutura de Repetição (for, while, do while)

Essas estruturas de controle permitem que você escreva programas que se adaptem
a diferentes cenários, tornando seu código mais dinâmico e eficiente. Elas são
fundamentais para a lógica de programação em C.

Comando if e else
A estrutura if`, else if`, else em C é usada para tomar decisões em um programa
com base em diferentes condições. Ela permite que você execute diferentes blocos de
código, dependendo de qual condição é verdadeira. Aqui está como essa estrutura
funciona:

if (condicao1) {
// Código a ser executado se a condicao1 for verdadeira
} else if (condicao2) {
// Código a ser executado se a condicao1 for falsa e a
condicao2 for verdadeira
} else {
// Código a ser executado se nenhuma das condições
anteriores for verdadeira
}
Explicação passo a passo
1. O bloco começa com um if`, onde você fornece uma condição que será avaliada
como verdadeira ou falsa.
2. Se a condicao1 for verdadeira, o bloco de código dentro do primeiro if` será
executado. O restante das cláusulas (else if` e else) será ignorado.

Página 27 de 50
 3. Se a condicao1 for falsa, o programa verificará a próxima condição na cláusula
else if`, ou seja, condicao2. Se essa condição for verdadeira, o bloco de código
dentro do else if` será executado.
4. Se ambas as condições condicao1 e condicao2 forem falsas, o bloco de código
dentro da cláusula else será executado.

A estrutura if`, else if`, else permite que você lide com diferentes cenários e
execute o código apropriado com base nas condições. Lembre-se de que apenas o bloco
de código correspondente à primeira condição verdadeira será executado. Se nenhuma
das condições for verdadeira e houver um bloco else, esse bloco será executado.

Exemplo:

int idade = 18;

if (idade < 18) {
printf("Você é menor de idade.\n");
} else if (idade == 18) {
printf("Você completou 18 anos.\n");
} else {
printf("Você é maior de idade.\n");
}
Neste exemplo, o programa verifica a idade e imprime uma mensagem apropriada
com base nas diferentes faixas etárias.

Comando switch
A estrutura switch em C é utilizada para tomar decisões com base no valor de uma
expressão. Ela permite que você selecione um dos vários blocos de código para ser
executado, dependendo do valor da expressão. A estrutura switch é frequentemente usada
quando você tem múltiplas opções a serem escolhidas, como quando você quer realizar
ações diferentes para diferentes casos.

Aqui está como a estrutura switch funciona:

switch (expressao) {
case valor1:
// Código a ser executado se expressao for igual a
valor1

Página 28 de 50
 break;
case valor2:
// Código a ser executado se expressao for igual a
valor2
break;
// ...
default:
// Código a ser executado se nenhum dos valores
anteriores for correspondido
}
Explicação passo a passo
1. A estrutura switch começa com a palavra-chave switch seguida pela expressão que
você deseja avaliar.
2. O programa avalia o valor da expressão e verifica se corresponde a um dos valores
especificados nos casos (case).
3. Se a expressão corresponder a um valor do case, o bloco de código dentro desse
case será executado.
4. O bloco de código dentro de um case deve ser finalizado com a palavra-chave
break. Isso evita que o programa execute os outros blocos de código abaixo dos
casos correspondentes.
5. Se nenhum dos valores nos case corresponder ao valor da expressão, o bloco de
código dentro do default será executado. O default é opcional e pode ser usado
para lidar com casos que não foram especificamente tratados nos case.

Exemplo:

int opcao = 2;
switch (opcao) {
case 1:
printf("Opção 1 selecionada.\n");
break;
case 2:
printf("Opção 2 selecionada.\n");
break;

Página 29 de 50
 case 3:
printf("Opção 3 selecionada.\n");
break;
default:
printf("Opção inválida.\n");
}
Neste exemplo, o programa avalia o valor da variável opcao e executa o bloco de
código correspondente ao valor. Se opcao for 2, o programa imprimirá "Opção 2
selecionada." Se opcao não corresponder a nenhum dos valores nos case, ele imprimirá
"Opção inválida."

Laços de Repetição
Em C, os laços de repetição são utilizados para executar um bloco de código várias
vezes, permitindo que você automatize tarefas que precisam ser realizadas repetidamente.
Existem três tipos principais de laços de repetição: for, while e do while. Cada um deles
tem sua própria maneira de controlar a repetição com base em uma condição.

1. Laço de Repetição for

➢ O laço for é ideal quando você sabe exatamente quantas vezes deseja repetir
um bloco de código.
2. Laço de Repetição while:
➢ O laço while é utilizado quando você quer repetir um bloco de código enquanto
uma condição específica for verdadeira.
3. Laço de Repetição do while:
➢ O laço do while é semelhante ao while, mas garante que o bloco de código seja
executado pelo menos uma vez, mesmo se a condição for inicialmente falsa

Os laços de repetição são fundamentais para automatizar tarefas repetitivas em

programas C, tornando o código mais eficiente e legível. Escolha o tipo de loop
apropriado com base nas suas necessidades e no fluxo de execução do seu programa.

for
O laço de repetição for em C é utilizado quando você sabe exatamente quantas
vezes deseja repetir um bloco de código. Ele é especialmente útil quando você precisa
iterar por uma sequência específica de valores. A estrutura do laço for é a seguinte:

Página 30 de 50
for (inicializacao; condicao; atualizacao) {
// Código a ser repetido
}
Explicação dos componentes do laço `for`
➢ inicializacao: É a parte onde você inicializa uma variável de controle antes do
início do loop. Isso é executado apenas uma vez no início. Pode ser uma
declaração de variável ou uma atribuição.
➢ condicao: É a condição que deve ser verdadeira para continuar executando o
loop. A cada iteração, a condição é verificada.
➢ atualizacao: É a parte onde você atualiza a variável de controle após cada
iteração. Geralmente é uma operação de incremento ou decremento.

#include <stdio.h>
int main() {
// Exemplo de uso do laço for
for (int i = 0; i < 5; i++) {
printf("Iteração %d\n", i);
}
return 0;
}
Explicação passo a passo
1. A declaração int i = ` é executada apenas uma vez no início, inicializando a
variável i com o valor 0.
2. A condição i < 5 é verificada antes de cada iteração. Se for verdadeira, o bloco de
código dentro do for é executado; caso contrário, o loop é encerrado.
3. O bloco de código dentro do for (entre as chaves) é executado.
4. A atualização i++ incrementa o valor de i após cada iteração.
5. O processo se repete até que a condição i < 5 se torne falsa.

A saída desse exemplo seria:

Página 31 de 50
 O laço for é eficaz quando você sabe quantas iterações são necessárias, tornando-
o uma escolha comum para iterar por matrizes, sequências e outras estruturas de dados
definidas.

while
O laço de repetição while em C é usado para executar um bloco de código
repetidamente enquanto uma determinada condição for verdadeira. Ele permite que você
crie iterações baseadas em uma condição específica, garantindo que o bloco de código
seja executado apenas enquanto essa condição for atendida.

A estrutura básica do laço de repetição while é a seguinte:

while (condicao) {
// Código a ser repetido
}
Explicação passo a passo
1. O laço while começa com a palavra-chave while seguida de uma condição entre
parênteses. Essa condição é uma expressão lógica que é avaliada como verdadeira
(1) ou falsa (0).
2. Antes de cada iteração (execução do bloco de código), a condição é avaliada. Se
a condição for verdadeira, o bloco de código dentro do while é executado. Se for
falsa, o loop é interrompido e a execução continua após o bloco while.

int contador = 0;
while (contador < 5) {
printf("Contagem: %d\n", contador);
contador++; // Incrementa o contador para controlar o
número de iterações
}
Neste exemplo, o bloco de código dentro do while será executado enquanto a
condição contador < 5 for verdadeira. A cada iteração, o contador é incrementado. O
resultado será a impressão da contagem de 0 a 4.

Observações:

➢ É importante garantir que a condição eventualmente se torne falsa, caso contrário,

você terá um loop infinito.

Página 32 de 50
 ➢ Se a condição for falsa desde o início, o bloco de código dentro do while nunca
será executado.
➢ Certifique-se de atualizar a variável que controla a condição dentro do loop, caso
contrário, o loop pode não terminar.

O laço de repetição while é útil quando você não sabe antecipadamente quantas
iterações serão necessárias, mas quer repetir um bloco de código enquanto uma
determinada condição for verdadeira.

do-while
O laço de repetição do-while em C é uma estrutura que permite executar um bloco
de código pelo menos uma vez, e então repetir esse bloco enquanto uma condição
específica for verdadeira. Ao contrário do laço while, onde a condição é verificada antes
da primeira execução do bloco de código, no laço do-while, o bloco de código é executado
primeiro e a condição é verificada depois.

A sintaxe básica do laço do-while é a seguinte:

do {
// Código a ser repetido
} while (condicao);
Passo a passo de como o laço do-while funciona
1. O bloco de código dentro do do é executado.
2. Após a execução do bloco de código, a condição especificada após o while é
verificada.
3. Se a condição for verdadeira, o bloco de código é executado novamente, repetindo
o processo a partir do passo 1.
4. Se a condição for falsa, o loop do-while é interrompido e a execução continua
após o bloco while.

Exemplo:

#include <stdio.h>
int main() {
int contador = 1;
do {
Página 33 de 50
 printf("Contador: %d\n", contador);
contador++;
} while (contador <= 5);

return 0;
}
Neste exemplo, o bloco de código dentro do do imprime o valor do contador e o
incrementa. O loop continuará a ser executado enquanto o contador for menor ou igual a
5. Mesmo que o contador seja 1, o bloco de código será executado pelo menos uma vez
antes que a condição seja verificada.

O laço do-while é especialmente útil quando você precisa garantir que um bloco
de código seja executado pelo menos uma vez, independentemente da condição.
Certifique-se de que a condição do while seja verificada somente após a primeira
execução do bloco de código.

Página 34 de 50
 FUNÇÕES
O que são Funções?
Em C, as funções são blocos de código independentes que podem ser chamados e
executados em qualquer parte do programa. Elas são utilizadas para modularizar o código,
permitindo que você divida tarefas complexas em partes menores e mais gerenciáveis. As
funções também ajudam a reutilizar o código, tornando-o mais organizado e legível.

Declaração e Definição de Funções

A declaração e definição de funções em C envolve separar o processo em duas
etapas: primeiro, você declara a função, indicando seu tipo de retorno, nome e parâmetros;
depois, você define a função, implementando o código que será executado quando a
função for chamada.

Declaração de Função
A declaração informa ao compilador a assinatura da função, permitindo que o
código que a chama seja verificado quanto à corretude dos tipos e quantidade de
parâmetros.

A sintaxe de uma declaração de função é:

tipo_retorno nome_funcao(tipo_parametro parametro1,

tipo_parametro parametro2, ...);
Exemplo de declaração:

int somar(int a, int b);

Definição de Função
A definição é onde você implementa o código que será executado quando a função
for chamada. Ela contém o corpo da função, onde você pode realizar operações e cálculos.

A sintaxe de uma definição de função é:

tipo_retorno nome_funcao(tipo_parametro parametro1,

tipo_parametro parametro2, ...) {
// Corpo da função
// Código a ser executado
return valor_retorno; // Opcional, se a função tem um tipo
de retorno
}

Página 35 de 50
 Exemplo de definição:

int somar(int a, int b) {

int resultado = a + b;
return resultado;
}
Lembrando que a declaração da função deve estar visível antes de sua chamada,
seja porque ela foi definida antes ou porque você a incluiu por meio de um cabeçalho.

Tipos de Retorno
Em C, as funções podem ter diferentes tipos de retorno, indicando qual tipo de
valor a função irá retornar após sua execução. Aqui estão alguns dos tipos de retorno de
função mais comuns:

1. int (inteiro): A função retorna um valor inteiro.

Exemplo:

int somar(int a, int b) {

return a + b;
}
2. float (ponto flutuante): A função retorna um valor de ponto flutuante (número
real).

Exemplo:

float dividir(float a, float b) {

return a / b;
}
3. double (ponto flutuante de precisão dupla): A função retorna um valor de ponto
flutuante com maior precisão.

Exemplo:

double calcularPotencia(double base, double expoente) {

return pow(base, expoente);
}
4.char (caractere): A função retorna um caractere.

Página 36 de 50
 Exemplo:

char obterPrimeiraLetra(char* palavra) {

return palavra[0];
}
5. void (vazio): A função não retorna um valor. Isso é usado quando a função
apenas executa uma tarefa sem retornar um resultado.

Exemplo:

void imprimirMensagem() {
printf("Olá, mundo!\n");
}
Lembre-se de que o tipo de retorno especificado na declaração da função deve
corresponder ao tipo de valor que a função realmente retorna. O uso correto de tipos de
retorno é fundamental para garantir que seu código seja compreensível e que funcione
conforme o esperado.

Passagem de Parâmetros
Em C, a passagem de parâmetros para funções permite que você envie valores ou
referências de variáveis para serem usados dentro do corpo da função. Existem dois tipos
de passagem de parâmetros: por valor (passagem por valor) e por referência (passagem
por referência).

Passagem por Valor

Quando você passa um parâmetro por valor para uma função, uma cópia do valor
da variável é passada para a função. Isso significa que as alterações feitas na variável
dentro da função não afetarão o valor original fora da função.

void duplicarValor(int numero) {

numero = numero * 2;
}
int main() {
int x = 5;
duplicarValor(x);
// O valor de x aqui ainda é 5, pois a função recebeu uma
cópia de x

Página 37 de 50
 return 0;
}
Passagem por Referência
A passagem por referência envolve passar um ponteiro que aponta para a
localização da variável. Isso permite que a função modifique diretamente o valor da
variável original.

void triplicarValor(int* numero) {

*numero = *numero * 3;
}
int main() {
int y = 7;
triplicarValor(&y);
// Agora o valor de y aqui é 21, porque a função modificou
diretamente y
return 0;
}
Em C, os ponteiros são frequentemente usados para permitir a passagem por
referência. Isso permite que a função altere o valor original da variável.

Dicas Importantes
➢ A passagem por valor é usada quando você não quer que a função modifique o
valor original da variável.
➢ A passagem por referência é usada quando você deseja que a função modifique o
valor original da variável.
➢ Lembre-se de usar ponteiros na passagem por referência para garantir que a
função possa acessar e modificar a variável original.

Ao decidir como passar parâmetros para uma função, considere se você deseja que as
alterações na variável dentro da função afetem a variável original.

Funções Recursivas
Imagine que você está resolvendo um quebra-cabeça complexo, onde você precisa
resolver várias partes menores do mesmo quebra-cabeça. Em uma função recursiva, você

Página 38 de 50
divide um grande problema em partes menores e resolve cada parte da mesma maneira
que você resolveria o problema geral.

Em termos mais técnicos, uma função recursiva é uma função que se chama a si
mesma para resolver um problema. É como se você estivesse dando um passo de cada
vez para resolver uma tarefa maior.

Aqui está um exemplo prático: imagine que você quer calcular o fatorial de um
número. O fatorial de um número é o resultado da multiplicação de todos os números
inteiros positivos até aquele número. Por exemplo, o fatorial de 5 é 5 * 4 * 3 * 2 * 1 =
120.

Agora, em vez de tentar calcular o fatorial de 5 diretamente, você pode usar uma
função recursiva para dividir o problema em partes menores. Veja como:

1. Se o número for 1, o fatorial é 1.

2. Caso contrário, o fatorial do número é o número multiplicado pelo fatorial do
número menos 1.

Aqui está como essa lógica é implementada em uma função recursiva em C:

#include <stdio.h>
int fatorial(int num) {
if (num == 1) {
return 1;
} else {
return num * fatorial(num - 1);
}
}
int main() {
int numero = 5;
int resultado = fatorial(numero);
printf("O fatorial de %d é %d\n", numero, resultado);
return 0;
}

Página 39 de 50
 O que acontece aqui é que a função fatorial chama a si mesma com um valor
menor a cada vez, até que atinja o caso base (quando num é 1). Isso permite que ela
resolva a multiplicação de todos os números inteiros de forma recursiva.

Embora seja poderoso, o uso de funções recursivas deve ser cuidadoso para evitar
loops infinitos. Mas, no geral, essa técnica é uma maneira elegante de resolver problemas
complexos, dividindo-os em partes menores e mais gerenciáveis.

Página 40 de 50
 ARRAYS E MATRIZES
O que é um Array em C?
Um array em C é uma estrutura de dados que armazena um conjunto de elementos
do mesmo tipo. Cada elemento do array é identificado por um índice, que começa em 0
para o primeiro elemento, 1 para o segundo, e assim por diante. Os arrays são usados
para armazenar coleções de dados de maneira organizada e acessível.

Declaração de Arrays
Você declara um array especificando seu tipo de dado, nome e tamanho entre
colchetes [ ]. Aqui está um exemplo de declaração de um array de inteiros com 5
elementos:

int numeros[5];
Você também pode inicializar o array durante a declaração:

int numeros[5] = {10, 20, 30, 40, 50};

Se você não especificar valores para todos os elementos, os elementos não
mencionados serão preenchidos com zero (para tipos numéricos) ou com o caractere nulo
`\0` (para strings).

Acesso a Elementos
Você pode acessar elementos de um array usando seus índices. Lembre-se de que
os índices começam em 0. Por exemplo, para acessar o primeiro elemento de `numeros`,
você usaria `numeros[0]`.

int primeiroNumero = numeros[0]; // Acessando o primeiro

elemento
Iterando sobre um Array
Você pode usar loops para percorrer os elementos de um array e realizar
operações. Um loop for é frequentemente usado para isso:

for (int i = 0; i < 5; i++) {

printf("Elemento %d: %d\n", i, numeros[i]);
}

Página 41 de 50
 Limitações dos Arrays
➢ O tamanho do array precisa ser definido no momento da declaração e não pode
ser alterado.
➢ Arrays não podem armazenar tipos de dados diferentes. Todos os elementos do
array devem ser do mesmo tipo.

Nota:

O uso correto de índices é importante para evitar erros de acesso à memória e

vazamentos de informações. Certifique-se de que os índices estejam dentro dos limites
válidos (0 a tamanho-1) do array.

Arrays são uma ferramenta fundamental para armazenar e manipular conjuntos de

dados em C. Eles são amplamente usados para várias aplicações, desde armazenar
números até caracteres de texto.

Arrays Multidimensionais (Matrizes)

Uma matriz em C é uma estrutura de dados multidimensional que armazena
elementos em linhas e colunas. Matrizes são usadas para representar tabelas, grades e
estruturas de dados bidimensionais. Aqui está uma explicação mais detalhada sobre
matrizes em C:

Declarando uma Matriz

A declaração de uma matriz é semelhante à declaração de um array
unidimensional, mas você fornece o número de linhas e colunas entre colchetes `[][]`.

tipo_dados nome_matriz[linhas][colunas];
Exemplo de declaração de uma matriz 3x3 de inteiros:

int matriz[3][3];
Inicializando uma Matriz
Você pode inicializar uma matriz da mesma maneira que
inicializa um array.
int matriz[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
Acessando Elementos de uma Matriz
Os elementos de uma matriz são acessados usando dois índices: um para a linha e
outro para a coluna. Lembre-se de que os índices começam em 0.

Página 42 de 50
int elemento = matriz[1][2]; // Acessando o elemento na
segunda linha e terceira coluna
Iterando sobre uma Matriz
Você pode usar loops aninhados para percorrer todos os elementos de uma matriz.

for (int i = 0; i < 3; i++) {

for (int j = 0; j < 3; j++) {
printf("Elemento (%d, %d): %d\n", i, j,
matriz[i][j]);
}
}
Limitações das Matrizes
➢ O tamanho da matriz precisa ser definido no momento da declaração e não pode
ser alterado.
➢ Matrizes são mais complexas do que arrays unidimensionais e podem ser menos
eficientes em termos de memória e desempenho em comparação com estruturas
de dados mais avançadas.

As matrizes são úteis para representar dados em formato de tabela ou grade, como
planilhas, imagens e mapas. Elas são uma ferramenta poderosa para lidar com
problemas que envolvem duas dimensões de informações.

Página 43 de 50
 EXEMPLOS PRÁTICOS
Calculadora Simples
Aqui está um exemplo simples de código em C para uma calculadora que realiza
operações básicas de adição, subtração, multiplicação e divisão:

#include <stdio.h>
int main() {
char operador;
double numero1, numero2, resultado;
printf("Digite um operador (+, -, *, /): ");
scanf("%c", &operador);
printf("Digite dois números: ");
scanf("%lf %lf", &numero1, &numero2);
switch (operador) {
case '+':
resultado = numero1 + numero2;
break;
case '-':
resultado = numero1 - numero2;
break;
case '*':
resultado = numero1 * numero2;
break;
case '/':
if (numero2 != 0) {
resultado = numero1 / numero2;
} else {
printf("Não é possível dividir por zero.\n");
return 1;
}
break;
default:

Página 44 de 50
 printf("Operador inválido.\n");
return 1;
}
printf("Resultado: %.2lf\n", resultado);
return 0;
}
Este código solicita ao usuário um operador (+, -, *, /) e dois números. Com base
no operador escolhido, a calculadora realiza a operação correspondente e exibe o
resultado. Certifique-se de que os números sejam inseridos corretamente para evitar erros
de cálculo. Note também que estamos verificando se o segundo número é zero antes de
realizar a divisão.

Lembre-se de que este é um exemplo simples e que uma calculadora real poderia
ser mais complexa e incluir mais funcionalidades e validações.

Verificação de Números Múltiplos

Este exemplo de código em C que verifica se dois números são múltiplos um do
outro:

#include <stdio.h>
int main() {
int numero1, numero2;
printf("Digite dois números: ");
scanf("%d %d", &numero1, &numero2);
// Verificando se um número é múltiplo do outro
if (numero1 % numero2 == 0) {
printf("%d é múltiplo de %d.\n", numero1, numero2);
} else if (numero2 % numero1 == 0) {
printf("%d é múltiplo de %d.\n", numero2, numero1);
} else {
printf("Os números não são múltiplos um do outro.\n");
}
return 0;
}

Página 45 de 50
 Neste código, o programa lê dois números da entrada e verifica se um número é
múltiplo do outro. Ele utiliza o operador de módulo `%` para determinar se o resto da
divisão entre os números é igual a zero, o que indica que eles são múltiplos.

Lembre-se de que a ordem dos números é importante para determinar qual número
é múltiplo do outro. Este código verifica ambas as direções para garantir que a verificação
seja correta.

Manipulação de Matrizes
Aqui estão alguns exemplos de códigos em C que mostram como manipular
matrizes, realizando operações como preenchimento, impressão, soma de matrizes e
transposição. Esses exemplos demonstram algumas operações básicas, mas você pode
expandir essas ideias para realizar outras manipulações mais complexas.

Exemplo 1: Preenchendo e Imprimindo uma Matriz

#include <stdio.h>
int main() {
int matriz[3][3];
// Preenchendo a matriz com valores
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
matriz[i][j] = i * 3 + j + 1;
}
}
// Imprimindo a matriz
printf("Matriz:\n");
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
printf("%d ", matriz[i][j]);
}
printf("\n");
}
return 0;
}

Página 46 de 50
 Exemplo 2: Soma de Duas Matrizes
#include <stdio.h>
int main() {
int matriz1[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int matriz2[3][3] = {{9, 8, 7}, {6, 5, 4}, {3, 2, 1}};
int soma[3][3];
// Somando as matrizes
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
soma[i][j] = matriz1[i][j] + matriz2[i][j];
}
}
// Imprimindo a matriz resultante da soma
printf("Matriz Soma:\n");
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
printf("%d ", soma[i][j]);
}
printf("\n");
}
return 0;
}
Exemplo 3: Transposição de Matriz
#include <stdio.h>
int main() {
int matriz[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10,
11, 12}};
int transposta[4][3];
// Transpondo a matriz
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 4; j++) {
transposta[j][i] = matriz[i][j];

Página 47 de 50
 }
}
// Imprimindo a matriz transposta
printf("Matriz Transposta:\n");
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 3; j++) {
printf("%d ", transposta[i][j]);
}
printf("\n");
}
return 0;
}
Esses exemplos ilustram algumas das operações básicas que você pode realizar
com matrizes em C. A manipulação de matrizes é fundamental para muitos problemas em
ciência da computação e engenharia.

Página 48 de 50
 EXERCÍCIOS
Conjunto de exercícios para praticar os conceitos aprendidos em cada capítulo.

1. Exercício: Soma de Números

Escreva um programa que peça ao usuário para inserir dois números inteiros e, em
seguida, imprima a soma desses números.

2. Exercício: Média de Números

Peça ao usuário para inserir três números inteiros e, em seguida, calcule e imprima
a média desses números.

3. Exercício: Verificador de Par ou Ímpar

Escreva um programa que leia um número inteiro e determine se é par ou ímpar.

4. Exercício: Calculadora Simples em loop

Crie uma calculadora que permita ao usuário inserir dois números e um operador
(+, -, *, /). O programa deve calcular e exibir o resultado. A calculadora deverá ser
executada até que o usuário escolha a opção de sair.

5. Exercício: Fatorial
Peça ao usuário para inserir um número inteiro e, em seguida, calcule e imprima
o fatorial desse número.

6. Exercício: Tabuada
Peça ao usuário para inserir um número inteiro e imprima a tabuada desse número.

7. Exercício: Conversor de Temperatura

Crie um programa que converta uma temperatura em Celsius para Fahrenheit.
Peça ao usuário para inserir a temperatura em Celsius e exiba a temperatura equivalente
em Fahrenheit.

8. Exercício: Contagem Regressiva

Escreva um programa que conte regressivamente de 10 até 1, imprimindo cada
número.

Página 49 de 50
 9. Exercício: Sequência Fibonacci
Crie um programa que gera e imprime os primeiros n números da sequência de
Fibonacci, onde n é inserido pelo usuário.

Esses exercícios abrangem uma variedade de conceitos básicos de programação

em C. À medida que você avança, pode aumentar a complexidade dos exercícios para
continuar aprimorando suas habilidades.

BIBLIOGRAFIA
BACKES, A. Linguagem C - Completa e Descomplicada. 1ª. ed. [S.l.]: GEN
LTC, 2022.

DEITEL, P.; DEITEL, H. C Como Programar. 6ª. ed. [S.l.]: Pearson

Universidades, 2011.

GOOKIN, D. Começando a programar em C Para leigos. 1ª. ed. [S.l.]: Alta

Books, 2016.

SCHILDT, H. C Completo e Total. 3ª. ed. [S.l.]: Pearson Universidades, 1997.

SOUZA, F. Domine a linguagem C: Tudo o que você precisa saber em um único

lugar. Embarcados. Disponivel em: <https://embarcados.com.br/linguagem-c-guia-
completo/>. Acesso em: 03 Outubro 2023.

W3SCHOOLS. C Tutorial. W3Schools. Disponivel em:

<https://www.w3schools.com/c/index.php>. Acesso em: 03 Outubro 2023.

Página 50 de 50