Documente Academic
Documente Profesional
Documente Cultură
Algoritmos
É uma sequência de passos claros e objetivos que levam a execução de uma tarefa.
Exemplo:
1. Colocar uniforme;
2. Preparar o material;
3. Dirigir-se à escola;
4. Entrar na escola;
5. Aguardar o sinal;
- Imaginar que está desenvolvendo um algoritmo para pessoas que não trabalham com
informática;
- Ser objetivo;
Fases de um algoritmo:
Deve ser calculada a média de quatro notas (P1, P2, P3, P4).
Fases:
Algoritmo:
1. Receba a nota 1;
2. Receba a nota 2;
3. Receba a nota 3;
4. Receba a nota 4;
5. Some os valores das 4 notas;
6. Divida o resultado por 4;
7. Mostre o resultado da divisão.
Fluxograma:
Processamento em geral
Estrutura condicional
Conector
Início
Receba nota 1
Receba nota 2
M = (N1 + N2)/2
Mostra o valor de M
Fim
Início
Recebe a nota do
aluno
N >= 6
N<4
Fim
Exercícios:
5- Faça um algoritmo para calcular o estoque médio de uma peça, sendo que:
ESTOQUEMÉDIO= (QUANTIDADE MÍNIMA + QUANTIDADE MÁXIMA) /2;
Introdução a linguagem C
Compiladores e interpretadores
Extensão Função
.c Código fonte do programa
.h Arquivo “header”, utilizado para armazenar os cabeçalhos das bibliotecas
.exe Arquivo compilado e pronto para ser executado
/*Função principal*/
void main()
{
/*Função utilizada para escrever um texto na tela*/
/*Esta é uma função retirada da biblioteca “stdio.h”
declarada no início da programação.*/
printf("Este e um programa em linguagem C...");
}
Observe os textos que estão depois de “//” ou “/* */”, isso significa que ele não
será compilado, é apenas um COMENTÁRIO do seu programa.
Tipos de dados
Quando são utilizadas as palavras signed e unsigned significa que a variável pode
ou não ser sinalizada.
Declaração de variáveis
int i, j, l;
Neste caso foram criadas as variáveis i, j e l com o tipo inteiro (int) e a variável
“letra” do tipo caractere (char).
#include <stdio.h>
#include <stdlib.h>
void main()
{
unsigned char caractere;
unsigned int numero;
Exercícios:
5. É necessário desenvolver um menu onde as opções são escolhidas por letras. Qual
o tipo de variável indicado para esta aplicação?
Operadores Aritméticos
Operadores aritméticos:
São utilizados para efetuar os cálculos no programa, abaixo segue uma tabela com
os operadores aceitos na linguagem C:
Operador Ação
= Atribuição de valor em uma variável
- Subtração
+ Adição
* Multiplicação
/ Divisão
% Módulo da divisão (resto)
-- Decremento
++ Incremento
Exemplo:
#include <stdio.h>
#include <stdlib.h>
void main()
{
//Declaração das variáveis
float a=0, b=0, c=0, d=0, e=0, f=0, g=0;
//Cálculos
c = a+b;
d = a-b;
e = a*b;
f = a/b;
g = (int)a%2;
a++;
b--;
Exercícios:
6. Elaborar um programa que leia dois valores inteiros, os quais devem representar
a base e o expoente de uma potência, calcule a potência e apresente o resultado
obtido.
Estruturas condicionais
Início
Fim
Operadores relacionais
Operador Ação
> Maior que
>= Maior que ou igual
< Menor que
<= Menor que ou igual
== Igual
!= Diferente
Operadores lógicos
Operador Ação
&& AND
|| OR
! NOT
Uma condição dita como verdadeira em linguagem C pode ser dada de duas
formas:
- Por meio do resultado de uma operação relacional, por exemplo:
Se (5 > 3), neste caso o número 5 é maior do que 3, logo a condição é
verdadeira!
Se (a == b), agora é fácil de observar que as letras são diferentes, logo a
condição é falsa!
- Ou caso o valor colocado no comando for diferente de 0:
Se (10), aqui a condição é verdadeira, pois o valor utilizado no comando é
diferente de 0!
Se (0), agora a condição é falsa, pois o valor é igual a 0!
Exemplo:
#include <stdio.h>
#include <stdlib.h>
void main()
{
float media_aluno=0;
// Se não foi...
else
{
//Pergunta se está de recuperação...
if(media_aluno >= 4 && media_aluno < 6)
{
printf("O aluno esta de recuperacao...");
}
Comando switch()
Neste comando uma variável é testada e pode assumir várias condições diferentes,
não limitando somente para verdadeiro ou falso. É muito comum utilizá-lo em
aplicações onde existem diversas possibilidades diferentes para uma determinada
variável. A sintaxe da função é:
switch(variável)
{
case 0: {
//ações realizadas caso a variável seja 0
Break;
}
case 1: {
//ações realizadas caso a variável seja 1
Break;
}
Default: {
//ações realizadas caso a variável não seja nenhuma
//das opções.
Break;
}
}
Podem existir outros casos além destes seguindo a mesma sintaxe, e o valor da
variável não precisa ser sempre numérico, também podem assumir valores do tipo
caracteres, neste caso o valor teria que ter aspas simples, por exemplo:
case ‘a’:...
case ‘1’:...
Exemplo:
#include <stdio.h>
#include <stdlib.h>
void main()
{
//variável que receberá o valor testado pelo switch
int selecao=0;
scanf("%d", &selecao);
case 1: {
case 2: {
printf("\nVoce digitou o numero 2!");
break;
}
case 3: {
printf("\nVoce digitou o numero 3!");
break;
}
case 4: {
printf("\nVoce digitou o numero 4!");
break;
}
case 5: {
printf("\nVoce digitou o numero 5!");
break;
}
default: {
printf("Opcao incorreta!!!");
break;
}
}
}
Exercícios:
Laços de repetição
São utilizados para criar blocos que serão repetidos no programa enquanto uma
condição, testada periodicamente pelo bloco do laço de repetição, é verdadeira. Quando
esta condição atingir um valor e for considerada falsa o programa para de executar o laço.
Início
Ação do laço
Verdadeira
Condição do
laço
Falsa
Fim
Neste tipo de laço sua estrutura é repetida até que a condição atribuída pelo
programador seja verdadeira (diferente de zero). Os comandos destes laços são:
E:
do //Faça...
{
//ações do laço do while...
}while(condição); //Enquanto essa condição for verdadeira
Exemplo:
#include <stdio.h>
#include <stdlib.h>
void main()
{
unsigned int condicao=0;
#include <stdio.h>
#include <stdlib.h>
void main()
{
unsigned int condicao=0;
do
{
printf("Digite 1 para repetir programa e 0 para encerrar...");
scanf("%d",&condicao);
/*Testa se a condição é verdadeira, se for, repete o laço*/
}while(condicao);
}
Laço “for”:
Exemplo:
#include <stdio.h>
#include <stdlib.h>
void main()
{
unsigned int contador;
Exercícios:
4. Elaborar um programa que leia valores positivos inteiros até que um valor
negativo seja informado. Ao final devem ser apresentados o menor e o maior valor
informado pelo usuário.
Imagine uma situação onde é necessária a implementação de uma agenda eletrônica para
efetuar o registro de pelo menos 100 números. Logo a primeira impressão seria de criar 100
variáveis, uma para cada número, o que de certa forma não está errado, porém se torna inviável
quando percebemos o tamanho que ficaria o código. Para contornar este problema foram criados
os arrays, ou melhor, os vetores e as matrizes.
Os arrays nada mais são do que um conjunto de variáveis de mesmo tipo agrupadas por
um mesmo nome, por exemplo: Para criar a agenda poderia ser criada a variável número contendo
100 posições.
Onde o que está em negrito é o tipo da variável, “num_tel” é o nome dado àquele conjunto
de dados, e o número dentro dos colchetes é a quantidade de “variáveis” de mesmo tipo contido
em “num_tel”.
Os arrays podem assumir qualquer tipo de variável: char, int, float, double. O tipo
utilizado depende da aplicação onde será utilizada.
O exemplo acima foi de um array chamado vetor, ou matriz unidimensional, pois possui
apenas uma linha e várias colunas, nas quais essas colunas devem ser localizadas por meio de
seus índices.
OBS: Todo índice de vetor inicia sua contagem no 0!!! Portanto um vetor de 10 posições
terá da posição 0 até a posição 9:
Valor Valor_1 Valor_2 Valor_3 Valor_4 Valor_5 Valor_6 Valor_7 Valor_8 Valor_9 Valor_10
Índice 0 1 2 3 4 5 6 7 8 9
E durante o programa ele deverá ser iniciado item a item, da seguinte maneira:
Numero[0] = 0;
Numero[1] = 1;
Numero[2] = 2;
Numero[3] = 3;
Numero[4] = 4;
O acesso aos seus dados é feito de forma semelhante aos vetores, e seus índices também
iniciam com 0. Abaixo é mostrado como fica organizada uma matriz 3x3:
Linha Coluna 0 1 2
0 Valor_00 Valor_01 Valor_02
1 Valor_10 Valor_11 Valor_12
2 Valor_20 Valor_21 Valor_22
Uma aplicação comum dos vetores é na declaração das strings, ou seja, uma cadeia de
caracteres que formam uma palavra ou uma frase.
#include <stdio.h>
#include <stdlib.h>
void main()
{
/*O vetor criado é unidimensional, logo o
texto será limitado pelo laço for.*/
unsigned char nome[20];
unsigned char indice;
Para preencher uma matriz com números deve ser utilizada a função scanf, como no
exemplo abaixo:
#include <stdio.h>
#include <stdlib.h>
void main()
{
unsigned int matriz[3][3];
unsigned char linha=0,coluna=0;
for(coluna=0;coluna<3;coluna++)
{
scanf("%d",&matriz[linha][coluna]);
}
}
}
}
}
Exercícios:
7- Desenvolva um programa que leia uma matriz 3x3 e calcule sua determinante.
8- Desenvolva uma matriz de 5x10 onde cada linha deverá ser digitado um nome de
até 10 caracteres.
Criação de funções
Toda função criada pode receber ou retornar um valor da função principal, para
isso basta informar o tipo de dado que irá enviar, receber ou ambos. Abaixo é demonstrada
a sintaxe de criação de uma função:
Tipo_do_retorno nome_da_função (tipo_do_argumento)
OBS: Uma função pode receber quantos argumentos forem necessários, separados
por vírgula, porém pode retornar apenas uma variável.
Outro detalhe importante se dá pelo fato de ser necessário criar os protótipos das
funções, que nada mais são do que os nomes das funções com “ ; ” no final para indicar
ao compilador que aquela função existe naquele arquivo. Estes protótipos não precisam
ser adicionados caso as funções sejam criadas antes da função main.
Como exemplo será criada uma função responsável por receber quatro argumentos
e retornar a média aritmética para o programa principal:
Float media(float valor_1, float valor_2, float valor_3, float valor_4)
{
Float resultado=0;
Resultado = (valor_1 + valor_2 + valor_3 + valor_4)/4;
Return resultado;
}
Caso seja necessário utilizar esta função na função principal (main), basta colocar
seu nome e os argumentos que serão utilizados:
void main()
{
Float nota_1, nota_2, nota_3, nota_4, media_final;
Media_final = Media(nota_1,nota_2,nota_3,nota_4);
}
//Protótipo da função
//Pode ser eliminado caso a função seja criada antes da função main
float calcula_media(float nota_1, float nota_2, float nota_3, float
nota_4);
//--------------------------------------------------------------------
//Função principal
void main()
{
float nota[4], media;
unsigned int contador;
media = calcula_media(nota[0],nota[1],nota[2],nota[3]);
//--------------------------------------------------------------------
//Função criada para o calculo da média
float calcula_media(float nota_1, float nota_2, float nota_3, float
nota_4)
{
float resultado=0;
resultado = (nota_1+nota_2+nota_3+nota_4)/4;
return resultado;
}
//--------------------------------------------------------------------
No exemplo acima a função foi criada no mesmo arquivo, por isso foi necessário
criar o protótipo antes da função main, e a função criada está localizada depois da função
main.
//Protótipo da função
float calcula_media(float nota_1, float nota_2, float nota_3, float
nota_4);
//-----------------------------------------------------------------------
-
//Função criada para o calculo da média
float calcula_media(float nota_1, float nota_2, float nota_3, float
nota_4)
{
float resultado=0;
resultado = (nota_1+nota_2+nota_3+nota_4)/4;
return resultado;
}
Programa principal:
#include <stdio.h>
#include <stdlib.h>
#include "funcao_media.h"
//-----------------------------------------------------------------------
----
//Função principal
void main()
{
float nota[4], media;
unsigned int contador;
media = calcula_media(nota[0],nota[1],nota[2],nota[3]);
É importante ressaltar que na diretiva #include, o argumento que está entre aspas
é o nome do arquivo onde a função foi criada e está localizado na mesma pasta do projeto.
Caso este arquivo esteja localizado em outra pasta, este argumento deve ser o caminho
completo até a pasta onde ele se encontra, por exemplo:
#include “c:/projetos/calculo_media/funcao_media.h”.
Variáveis globais
Antes de fazer o uso de funções próprias, todas as variáveis foram criadas dentro
da função main, porém é comum a necessidade de se utilizar as mesmas variáveis dentro
de funções diferentes. A melhor forma para enviar estes valores para uma função é por
meio dos argumentos, porém, como foi visto neste tópico, uma função tem a capacidade
de retornar apenas um valor, mas, e se fosse necessário retornar dois ou mais valores, ou
então receber um vetor como argumento? A forma mais simples para resolver estes
problemas é utilizando variáveis globais.
As variáveis globais são criadas fora de qualquer função, por isso podem ser lidas
e modificadas em qualquer parte do programa. Ao criar uma variável global deve se
prestar atenção em alguns detalhes:
a) Não poderá existir outra variável com o mesmo nome no programa inteiro, se
existir ocorrerá um erro na compilação;
b) Variáveis locais (aquelas criadas dentro da própria função) são apagadas da
memória sempre que a função acaba de ser executada, liberando espaço. Já as
variáveis globais não são apagadas, ou seja, possuem um endereço fixo na
memória durante toda a execução do programa. Este detalhe não é extremamente
impactante em programas pequenos para computadores, porém em dispositivos
com uma capacidade de memória menor é um agravante, por isso a recomendação
de se evitar variáveis globais sempre que possível;
c) Variáveis globais podem ser modificadas a qualquer momento e em qualquer
função, por isso deve se tomar cuidado para não alterar seus valores em momentos
indesejáveis.