Vetores em C
9 pág.

Vetores em C


DisciplinaAlgoritmos e Programação de Computadores563 materiais5.560 seguidores
Pré-visualização2 páginas
1 
LINGUAGEM E TÉCNICA DE PROGRAMAÇÃO I 
 
Profa. Gisele Busichia Baioco 
gisele@ft.unicamp.br 
 
 
Algoritmos Estruturados e 
Linguagem de Programação Estruturada 
 
Vetores em C 
1 Variáveis Compostas Homogêneas Unidimensionais \u2013 Vetores em C 
As Variáveis Compostas Homogêneas Unidimensionais ou Vetores correspondem 
a posições de memória (variáveis) identificadas por um mesmo nome, onde uma posição 
individual é acessada por um índice e cujo conteúdo é do mesmo tipo de dado. Em outras 
palavras, um vetor pode ser definido como um conjunto finito e ordenado de elementos 
homogêneos. Por finito entende-se que existe um número específico de elementos no vetor; 
por ordenado entende-se que os elementos do vetor são organizados de tal forma que exista 
um elemento 0, um elemento 1, elemento 2, um elemento 3 e assim por diante, onde 0, 1, 2, 
3,... são os índices; por homogêneo entende-se que todos os elementos do vetor precisam ser 
do mesmo tipo de dados. 
Sintaxe de declaração em C: 
 
tipo-de-dado nome[tamanho]; 
 
onde: 
nome: é o nome do vetor; 
tamanho: é a quantidade máxima de elementos (posições) do vetor; 
tipo-de-dado: é um tipo de dado válido em C. 
 
 A referência ao conteúdo do n-ésimo elemento de um vetor tem a sintaxe: 
 
nome[n] 
 
onde: 
nome: é o nome do vetor; 
n é o índice que corresponde a um número inteiro ou uma variável do tipo inteiro. 
 
Em C, considera-se que o primeiro elemento tem o índice 0. 
 
 Exemplo de vetor: 
 
/* Declaração de um vetor de nome nota que pode conter até 10 
 elementos */ 
float nota[10]; 
 
 2 
Esquematicamente tem-se: 
 
nota 5.5 6.0 9.0 2.5 4.5 9.5 7.0 8.5 7.5 3.0 
 0 1 2 3 4 5 6 7 8 9 
 
 
 
 
Para atribuir um valor a n-ésima posição de um vetor, usa-se a seguinte sintaxe: 
 
 nome[n] = valor; 
 
onde: 
nome: é o nome do vetor; 
n é o índice que corresponde a um número inteiro ou uma variável do tipo inteiro; 
valor é uma variável ou um valor do mesmo tipo de dado do vetor. 
 
 Considerando o vetor do exemplo anterior, para atribuir o valor 9.5 para a posição 5, 
faz-se: 
 nota[5] = 9.5; 
2 Usando Vetores 
Um vetor é usado para manter uma grande quantidade de elementos de dados na 
memória e para referenciar todos os elementos de maneira uniforme. 
Supor a necessidade de ler 100 notas, calcular sua média aritmética e determinar o 
quanto cada nota se desvia dessa média. Nesse caso é necessário que as 100 notas lidas sejam 
armazenadas em variáveis para que o desvio seja calculado após o cálculo da média 
aritmética. Utilizar 100 variáveis para armazenar as 100 notas seria uma solução, mas o 
código do programa ficaria um tanto extenso, pois além de declarar 100 variáveis, seria 
necessário escrever código para 100 leituras de variáveis e 100 cálculos de desvios. Então, a 
solução é agrupar as 100 notas em uma única variável composta homogênea, ou seja, em um 
vetor. 
Algoritmo 
 início 
 declare soma, media, desvio, 
 nota[100] /* vetor de notas */: numérico real; 
 i /* conterá os índices do vetor */: numérico inteiro; 
 soma \u2190 0; /* valor inicial para a sumarização das notas */ 
 para i \u2190 0 até 99 passo 1 faça 
 início 
 escreva(\u201cDigite uma nota\u201d); 
 leia(nota[i]); 
 soma \u2190 soma + nota[i]; 
 fim 
 media \u2190 soma/100; 
 escreva(\u201cMedia = \u201d, media); 
 /* Cálculo dos devios */ 
 para i \u2190 0 até 99 passo 1 faça 
 início 
desvio \u2190 nota[i] \u2013 media; 
escreva(\u201cDesvio da nota \u201d, nota[i], desvio); 
 fim 
fim 
nota[5] 
 3 
Em C fica: 
 
#include <stdio.h> 
main() 
 { 
 float soma, media, desvio, nota[100] /* vetor de notas */; 
 int i /* conterá os índices do vetor */; 
 soma = 0; /* valor inicial para a sumarização das notas */ 
 for (i = 0; i < 100; i++) 
 { 
 printf(\u201cDigite uma nota: \u201d); 
 scanf(\u201c%f\u201d, &nota[i]); 
 soma = soma + nota[i]; 
 } 
 media = soma/100; 
 printf(\u201cMedia = %f\u201d, media); 
 /* Cálculo dos devios */ 
 for (i = 0; i < 100; i++) 
 { 
 desvio = nota[i] \u2013 media; 
 printf(\u201cDesvio da nota %f = %f\u201d, nota[i], desvio); 
 } 
} 
 
É possível escrever o algoritmo anterior, solicitando do usuário a quantidade de notas 
ao invés de fixar em 100. O problema é que um vetor tem que ter um tamanho máximo e, 
nesse caso, é necessário garantir que o usuário entre com a quantidade de notas menor ou 
igual ao tamanho máximo. Ou seja, não há necessidade de utilizar todas as posições de um 
vetor, mas nunca se deve utilizar posições além de seu tamanho máximo. O tamanho mínimo 
também deve ser garantido \u2013 maior que 0. 
Algoritmo 
 início 
 declare soma, media, desvio, 
 nota[100] /* vetor de notas */: numérico real; 
 tam, i /* índices do vetor */: numérico inteiro; 
 /* Entrada da quantidade de notas e verificação dos limites 
 do vetor */ 
repita 
 escreva(\u201cDigite a quantidade de notas \u2013 mínimo 1 e máximo 
100: \u201d); 
 leia(tam); 
 se (tam > 100 ou tam \u2264 0) 
 então escreva(\u201cQuantidade de notas inválida\u201d); 
 até (tam > 0 e tam \u2264 100); 
 soma \u2190 0; /* valor inicial para a sumarização das notas */ 
 para i \u2190 0 até tam-1 passo 1 faça 
 início 
 escreva(\u201cDigite uma nota\u201d); 
 leia(nota[i]); 
 soma \u2190 soma + nota[i]; 
 fim 
 media \u2190 soma/tam; 
 escreva(\u201cMedia = \u201d, media); 
 /* Cálculo dos devios */ 
 para i \u2190 0 até tam-1 passo 1 faça 
 início 
desvio \u2190 nota[i] \u2013 media; 
 4 
escreva(\u201cDesvio da nota \u201d, nota[i], desvio); 
 fim 
fim 
 
Em C ainda é possível dar um nome ao tamanho máximo do vetor por meio de 
#define, sendo que se for necessário modificar o tamanho máximo do vetor, basta alterar o 
valor que estiver definido no #define. 
 
#include <stdio.h> 
 
#define MAXVET 100 /* define o tamanho máximo do vetor como MAXVET */ 
main() 
 { 
 float soma, media, desvio, nota[MAXVET] /* vetor de notas */; 
 int tam, i /* conterá os índices do vetor */; 
 /* Entrada da quantidade de notas e verificação dos limites 
 do vetor */ 
 do { 
printf(\u201cDigite a quantidade de notas \u2013 mínimo 1 e máximo %d: \u201d, 
MAXVET); 
 scanf(\u201c%d\u201d, &tam); 
 if (tam > MAXVET || tam <= 0) 
 printf(\u201cQuantidade de notas inválida\u201d); 
 } while (tam > MAXVET ||tam <= 0); 
 soma = 0; /* valor inicial para a sumarização das notas */ 
 for (i = 0; i < tam; i++) 
 { 
 printf(\u201cDigite uma nota: \u201d); 
 scanf(\u201c%f\u201d, &nota[i]); 
 soma = soma + nota[i]; 
 } 
 media = soma/tam; 
 printf(\u201cMedia = %f\u201d, media); 
 /* Cálculo dos devios */ 
 for (i = 0; i < tam; i++) 
 { 
 desvio = nota[i] \u2013 media; 
 printf(\u201cDesvio da nota %f = %f\u201d, nota[i], desvio); 
 } 
} 
3 Exemplos de Programas 
1) Faça um algoritmo que: 
\u2022 leia dois vetores, contendo 5 números inteiros cada um; 
\u2022 intercale os elementos dos dois vetores, formando um novo vetor de 10 elementos; 
\u2022 escreva o vetor resultante da intercalação. 
Solução: 
Entrada: dois vetores de 5 números inteiros; 
Processo: intercalação dos dois vetores gerando um vetor de 10 elementos; 
Saída: vetor de 10 elementos resultante. 
Algoritmo 
início 
 /* Declaração de variáveis */ 
 declare v1[5], v2[5], vr[10], i: numérico inteiro; 
 /* Entrada de dados */ 
 escreva(\u201cCarregando o primeiro vetor:\u201d); 
 5 
 para i \u2190 0 até 4 passo 1 faça 
 início 
 escreva(\u201cDigite um número inteiro: \u201d); 
 leia(v1[i]); 
 fim 
 escreva(\u201cCarregando o segundo vetor:\u201d); 
 para i \u2190 0 até 4 passo 1 faça 
 início 
 escreva(\u201cDigite um número inteiro: \u201d); 
 leia(v2[i]); 
 fim 
 /* Processo \u2013 Intercalação dos vetores */ 
para i \u2190 0 até 4 passo 1 faça 
 início 
 vr[2*i] = v1[i]; 
 vr[2*i+1] = v2[i]; 
 fim 
/* Saída de dados */ 
escreva(\u201cVetor resultante:\u201d); 
para i \u2190 0 até 9 passo 1 faça 
 escreva(vr[i]); 
fim 
 
#include <stdio.h> 
 
#define MAXVET 5 
#define MAXVETRES MAXVET*2 
main() 
{ 
 /* Declaração de variáveis */ 
 int v1[MAXVET], v2[MAXVET], vr[MAXVETRES], i;