Universidade Federal do Espírito Santo

Programação básica de computadores.

Engenharia Elétrica

Professora: Kamila Ribeiro Ghidetti

e-mail: rg.kamila@gmail.com
Vetores e Matrizes
Vetores

São estruturas de dados homogêneas e de

dimenção unitária.

Armazenam elementos de qualquer tipo

contando que todos sejam homogêneos (mesmo
tipo).

A declaração.
tipo_da_variável nome_da_variável [tamanho];
Vetores

Exemplo
int exemplo [20];

Acessando um elemento individual

exemplo[0] // acessa o primeiro elemento
exemplo[1] // acessa o segundo elemento
.
.
.
exemplo[19]
Vetores
#include <stdio.h>
int main (void)
{
int num[100]; /*Declara um vetor de inteiros de 100 posicoes */
int count=0;
int totalnums=0;
do
{
printf("\nEntre com um numero (-999 terminar): ");
scanf("%i",&num[count]);
count++;
}while(num[count-1]!=-999);

totalnums = count-1;
printf ("\nOs números que você digitou foram:\n");
for(count=0; count<totalnums; count++)
{
printf ("%i",num[count]);
}
return 0;
}
Vetores - Observação

O C não verifica se o índice que você usou está

dentro dos limites válidos. Sendo assim fica a
cargo do programador tomar os devidos
cuidados.

int vet[10];

vet[100] = 34;
Matrizes

São estruturas de dados homogêneas de

dimensão não unitária.

Assim como os vetores armazenam qualquer

tipo de dados desde que os mesmos sejam
homogêneos.

A declaração.
tipo_de_dado nome [t_1][t_2][t_3][t_4] ....[t_n];
Matrizes bidimensionais

A declaração.
tipo_de_dado nome [linha(s)] [coluna(s)];

Nesta estrutura, o índice da esquerda indexa as

linhas e o da direita indexa as colunas.
Matrizes bidimensionais - Exemplo
#include <stdio.h>
int main (void)
{
int mtrx [5][10];
int i=0, j=0, count=0;
count = 1;
for(i=0; i<5; i++)
{
for(j=0; j<10; j++)
{
mtrx[i][j] = count;
count++;
}
}
return 0;
}
Matrizes de strings
#include <stdio.h>
int main(void)
{
char strings [5][100];
int count=0;
for(count=0; count<5; count++)
{
printf("\nDigite uma string: ");
gets(strings[count]);
}
printf("\nAs strings que voce digitou foram:\n");
for (count=0; count<5; count++)
{
printf ("%s\n",strings[count]);
}
}
Exercício - Vetores

Faça um programa que gera a sequência de Fibonacci

até um máximo k (ja visto em sala de aula) e
armazena os valores em um vetor. O seu programa
deve imprimir a sequência gerada e a mesma
sequência multiplicando cada elemento por 2.
Exercício - Matrizes

Faça um programa que gera uma matriz em seguida

soma uma constante a cada elemento da diagonal
principal, essa constante deve ser lida do teclado.
Imprima a matriz gerada e a matriz modificada.
Exercício – Matriz x Vetor

Crie um programa para gerar uma matriz de dimensão

10 x 10 e um vetor de dimensão 10. Imprime a matriz
o vetor e o resultado da multiplicação matriz vetor.
Ponteiros
Ponteiros

• Fornecem os meios pelos quais as funções podem

modificar seus argumentos.
• São usados para suportar as rotinas de alocação
dinâmica.
• Pode aumentar a eficiência de certas rotinas.

• “É uns dos recursos mais fortes e mais perigosos do

C.”
Ponteiros

• Guardam endereços de memória.

• Operadores & (operador unário, devolve o endereço

de memória do operando) e * (operador unário que
devolve o valor da variável localizada no endereço
que o segue).

• A declaração: Forma geral

• tipo_de_dado *nome;
Ponteiros

int main (void)

{
int *m, num_a=5, j=0;

m = &num_a; // m recebe o endereço de num_a

j = *m; // j recebe o valor que está no endereço m
}
Endereço Variável na
de memória memória
1 (num_a) 5
2
3
4 (m) 1
5
6
Ponteiros - Erros

int main (void)

{
float num_a=5, j=0;
int *m,
m = &num_a;
j = *m;
}

int main (void)

{
int *m, num_a=5, j=0;

*m = j;
}
Ponteiros - Aritmética

• Seja um inteiro representado por 4 bytes, *p (100) e

o *q (100):
• p--; // equivale 96
• q++; // equivale a 104

• (*p)--; // decrementa o valor apontado por p em 1

• (*q)++; // incrementa o valor apontado por q em 1

Ponteiros e Matrizes

char str[10];
p = str;

str[4] (indexação de matrizes); equivale a *(p+4)

(aritmética de ponteiros); (Isso se deve ao fato de p ser um
ponteiro para a primeira posição de str).
Alocação
dinâmica
Alocação Dinâmica

• Variáveis globais ocupam espaço de memória

enquanto o programa estiver em execução.
• Variáveis locais ocupam espaço de memória
enquanto o escopo ao qual está relacionada estiver
em execução.
• Alocação Dinâmica a memória pode ser alocada e
desalocada em tempo de execução.
• Necessário quando não se conhece a quantidade
de memória disponível ou a utilização é intensa e
varia durante a execução do programa.
Alocação Dinâmica

• malloc(); // aloca memória

• free(); // libera memória

• Forma Geral:
• malloc(número_de_bytes)
Alocação Dinâmica

• Exemplo utilizando o tipo char

char *p;
p = malloc (1000);

• Exemplo utilizando o tipo inteiro

int *p;
p = malloc(50 * sizeof(int));

• Desalocando
free (p);
Alocação Dinâmica

• Testando se existe memória disponível

if(! (p=malloc(100))
{
printf(“Sem memória disponível. \n);
exit(1);
}
Estrutura ou
Registro
Tipo estruturado de dados - Estrutura

• É um tipo de dado criado pelo usuário. Geralmente

é uma coleção de variáveis referenciadas por um
nome.

• Forma geral
struct identificador
{
tipo nome_da_variavel;
tipo nome_da_variavel;
tipo nome_da_variavel;
.
.
}variáveis_estrutura;
Tipo estruturado de dados - Estrutura

• Criando uma estrutura

struct aluno
{
char nome[50];
int matricula;
};

int main();
{
struct aluno alunos;
return 0;
}
Tipo estruturado de dados - Estrutura

• Acessando um elemento da estrutura

nome_da_estrutura.nome_do_elemento

• Exemplo utilizando a estrutura aluno

alunos.matricula = 10;
printf(“%i”, alunos.matricula);
scanf(“%i”, &(alunos.matricula));
Estrutura

#include <stdio.h>
#include <string.h>
struct tipo_endereco
{ char rua [50];
int numero;
char bairro [20];
char cidade [30];
char sigla_estado [3];
int CEP;
};
struct ficha_pessoal
{ char nome [50];
int telefone;
struct tipo_endereco endereco;
};
Estrutura

int main (void)

{
struct ficha_pessoal ficha;
strcpy (ficha.nome,"Luiz Osvaldo Silva");
ficha.telefone=4921234;
strcpy (ficha.endereco.rua,"Rua das Flores");
ficha.endereco.numero=10;
strcpy (ficha.endereco.bairro,"Cidade Velha");
strcpy (ficha.endereco.cidade,"Belo Horizonte");
strcpy (ficha.endereco.sigla_estado,"MG");
ficha.endereco.CEP=31340230;
return 0;
}
Atribuindo estrutura

• Só podemos atribuir que sejam do mesmo tipo.

strunct1 = struct2;

int void main()

{
struct ficha_pessoal primeira, segunda;
Le_dados(&primeira);
segunda = primeira;
Imprime_dados(segunda);
return 0;
}
Vetores e Matrizes de estrutura

int void main()

{
struct alunos a[50] , b[10][10];

a[0].matricula = 12;
b[0][0] = 13;
return 0;
}
Arquivos
Arquivos

• Declarando um arquivo
FILE *nome_do_ponteiro;

• Exemplo
FILE *Arq;
Funções do sistema de arquivos

• fopen – Abrir um arquivo

• fclose – Fechar um arquivo
• fprintf – Escrever no arquivo
• fscanf – Ler do arquivo
• feof – Devolve verdadeiro se for fim do arquivo
Abrindo arquivos

• Forma geral:
fopen (char *nome_do_arquivo,char *modo);

• Parâmetros da função:
O nome_do_arquivo determina qual arquivo
deverá ser aberto.
O modo de abertura diz à função fopen() que
tipo de uso você vai fazer do arquivo.
Valores para modos

• r – Abre um arquivo para leitura

• w – Cria um arquivo para escrita
• a – anexa a um arquivo texto
• r+ – Abre um arquivo para leitura e escrita
• w+ – Cria um arquivo para leitura e escrita
• a+ – Anexa ou cria a um arquivo texto para leitura e
escrita
Abrindo arquivos
int main(void)
{
FILE *Arq;

Arq = fopen(“Teste”, “w”);

}

int main(void)
{
FILE *Arq;

if ( (Arq = fopen(“Teste”, “w”))==NULL)

{
printf(“\nErro ao abrir o arquivo”);
}
}
Fechando arquivos
int main(void)
{
FILE *Arq;

Arq = fopen(“Teste”, “w”);

fclose(Arq);
}

int main(void)
{
FILE *Oi;

if ( (Oi = fopen(“Teste”, “w”))==NULL)

{
printf(“\nErro ao abrir o arquivo”);
}
fclose(Oi);
}
Escrevendo no arquivo
int main(void)
{
FILE *Oi;
char s[50];
if ( (Oi = fopen(“Teste.txt”, “w”))==NULL)
{
printf(“\nErro ao abrir o arquivo”);
}
fprintf(Oi, “Minha primeira linha \n”);
fclose(Oi);
if ( (Oi = fopen(“Teste.txt”, “r”))==NULL)
{
printf(“\nErro ao abrir o arquivo”);
}
while(! feof(Oi))
{
fscanf(Oi, s);
}
fclose(Oi);
}
Os parâmetros

• argc e argv
void main (int argc, char *argv[])
Números aleatórios
srand(100);
rand() % 50;

srand(time(NULL));
rand() % 50;
Números aleatórios
#include <stdio.h>
#include <stdlib.h>

/* as funções rand() e srand() estão no cabeçalho stdlib.h */

int main(void)
{
int i;

/* inicializar o gerador de números aleatórios */

/* com time(NULL) */
srand(time(NULL));
for (i=0; i<5; i++)
{
/* para gerar números aleatórios de 0 a 50 */
printf("%d ", rand() % 50);
}
return 0;
}
Recursividade

• Fatorial n!
0! = 1
n>0
int fatorial (int n) int fatorial (int n)
{ {
int prod, x; if (n == 0)
prod = 1; {
for(x=n; x>0; x--) return 1;
{ }
prod = prod * x; return (n * fatorial (n-1));
} }
return prod;
}