Resumo_Vetor

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

Resumo Vetor:
Lembra que toda variável que vc declara/cria possui um endereço? (Como se fosse uma casa).
Vetor é simplesmente um conjunto de variáveis, ou seja, um conjunto de casinhas que armazena variáveis do mesmo tipo. (int, float, etc). 
OBS: Cada vetor só pode armazenar >> um único << tipo de variável (Um vetor pode ser todo de int ou todo de float e nunca de ambos.)
------------------------------------------//----------------------------------------------
- Como se declara um vetor? 
Após decidir qual será o seu tipo: 
Ex: int valores[10]; 
 float medias[5];
Sempre que vc declara um vetor tem que ser nessa ordem:
 
O tipo, nome do vetor e Quantidade de posições (casinhas) que vc coloca entre colchetes.
OBS: Eu gosto de usar nomes sempre no plural pra vetores, isso é totalmente opcional, mas eu acho que ajuda a entender e deixa mais claro também que vetor é sempre um conjunto de valores. 
OBS2: Na linha da declaração, não tem escapatória, é obrigatório dizer a quantidade de posições entre colchetes!
Ex: float valores[10];
Mas nos parâmetros da função vc pode omitir! 
Ex: float calcula_media (float valores[], int n)
-------------------------------------------//---------------------------------------------
- Como se envia um vetor como parâmetro? 
int notas[10];
preenche_notas(notas, 10);
Exatamente da mesmo forma como enviamos uma variável comum!
Mas perai...além do vetor, eu enviei como parâmetro o número 10 também. Pq será? =O
Regra importante: 
>> Um vetor é sempre acompanhado pela sua quantidade de posições!!! <<
Então >>sempre<< que enviarmos um vetor como parâmetro pra qualquer função, também precisamos enviar a sua quantidade de posições.
Mas por que isso?
Porque quase tudo que envolve manipulação de vetor envolve sua quantidade de posições!
EX: Uma função que lê e armazena no vetor as notas que cada aluno digitar:
void preenche_vetor (int notas[], int n){
 int i;
 
 for(i=0;i<n;i++){
 printf("Digite a %d nota:\n",i+1);
 scanf("%d",&notas[i]);
 }
}
int main (void){
 int notas[10];
 
 preenche_vetor (notas, 10);
 return 0;
}
Vamos por partes, precisamos armazenar a nota de cada aluno em cada posição do vetor, pra fazer isso temos que passar por todas as posições (casinhas) do vetor, certo?
É por isso que usamos a repetição for, pois é uma repetição determinada/finita, ou seja, a cada repetição, será lida uma nota. Mas se é uma repetição finita...Qual será a condição desse for? Ele vai repetir até quando? 
É exatamente nessa parte que precisamos da quantidade de posições do vetor, pois o for vai começar da posição zero e vai rodar até a posição 9. (10 posições no total, começando de zero).
Regra importantíssima: 
TODO vetor começa >>>SEMPRE<<< da posição zero e vai até n-1 (n é a quantidade de posições do vetor), ou seja, baseado no exemplo acima, a posição 10 é totalmente inválida! Cuidado!
-----------------------------------------//-----------------------------------------------
Sobre o protótipo da função preenche_vetor:
void preenche_vetor (int notas[], int n){
Percebe que deixei os colchetes em branco?
Regra importante: 
O protótipo de uma função, é o >>>ÚNICO<<< lugar onde podemos omitir a quantidade de posições do vetor, dessa forma: notas[]. 
---------------------------------------------//-----------------------------------------
Agora vamos analisar a repetição for: 
for(i=0;i<n;i++){
 printf("Digite a %d nota:\n",i+1);
 scanf("%d",&notas[i]);
 }
}
Nesse for, o i começa sendo zero e ele vai repetir enquanto o i for menor que n (n vale 10 nesse caso).
OBS: Assim como a letra 'i' é sempre usada nas repetições, a letra 'n' é sempre usada pra representar a quantidade de posições de qualquer vetor.
scanf("%d",&notas[i]);
Como nessa repetição o i começa sendo zero, a primeira leitura feita pelo scanf irá armazenar o valor em notas[0] e a última irá armazenar em notas[9]. (Passando por todas as posições na ordem).
------------------------------------------//---------------------------------------
- Quando e como inicializar um vetor? 
Sempre que vc precisar usar um vetor como um contador (somar ou subtrair algo dele).
Levando em conta que no momento que declaramos uma variável, antes de inicializar com algum valor, ela possui lixo de memória e >não< podemos fazer nenhuma conta com lixo de memória, isso dá um erro fatal. x.x
Então pra evitar esse problema, temos que passar por todas as posições do vetor, inicializando cada posição com o valor zero.
Esse é o protótipo da função inicializa_vetor:
void inicializa_vetor (int v[], int n){
 int i;
 
 for(i=0;i<n;i++){
 v[i] = 0;
 }
}
v[] é um nome genérico de vetor , n é a quantidade de posições. 
E temos que usar a repetição pra passar por cada posição, colocando o valor zero.
Essa função é usada direto, em praticamente todas as questões que envolvem vetores, 300% de chance de cair na G2 e na G3. 
Resumindo: Decore urgentemente a função acima! =D
------------------------------------------//-----------------------------------------------
- Quando usar vetor? 
SOMENTE quando vc tiver um número (exato ou de "até no máximo") da quantidade de algo (Alunos, turmas, notas, etc, depende do enunciado) e sempre quando for um conjunto de valores. Esse número irá representar a quantidade de posições do vetor. Se NÃO for o caso, NÃO use vetor! Use uma variável comum para armazenar tal informação.
Exemplo: O enunciado diz que as notas dos alunos estão armazenados num arquivo chamado NOTAS.TXT, mas não diz quantas notas são. É exatamente nesse caso que NÃO podemos criar um vetor pra armazenar as notas, pois não sabemos quantas são!
-----------------------------------------//------------------------------------------------
Como utilizar o "#define" em vetores? 
Primeiro passo é descobrir no enunciado o que vai ser um vetor.
De acordo com a explicação acima de quando usar vetor...Se for realmente um vetor, vamos ter um número exato ou de "até no máximo" de uma quantidade, certo?
Exemplo: O enunciado diz que uma turma tem >no máximo< 20 alunos e cada um vai digitar sua nota.
Ao invés de criar um vetor dessa forma: int notas[20];
Vamos criar um define lá no começo do programa (perto do #include <stdio.h>) pra criar um "atalho":
#define MAX 20 
MAX >>NÃO<< é uma variável, é simplesmente uma palavra comum que quando vc usa no programa, ela é substituída pelo valor 20.
Então quando formos declarar o vetor, vamos escrever dessa forma:
int notas[MAX];
Dessa forma, quando o programa for executado, ele vai automaticamente interpretar a palavra MAX como o valor 20.
OBS: Se vc colocar o ponteiro do mouse em cima da palavra MAX por alguns segundos (Visual Studio), ele vai mostrar o valor 20. 
Mas qual a vantagem disso?
Imagina um programa que vc precise criar uma vetor e chamar várias funções. (enviando sempre como parâmetro o vetor e sua quantidade de posições!)
Sem usar o #define MAX 20:
#include <stdio.h>
int main(void){
 int dados[20]; 
 inicializa_vetor(dados,20);
 preenche_vetor(dados,20);
 compara_valores(dados,20);
 imprime_resultado(dados,20);
 return 0;
}
Agora imagina se o enunciado muda para 30 notas, vc teria que fazer 5 alterações no programa né? E isso pq é um programa com poucas linhas, imagina esse número 20 se repetindo umas 300 vezes, ia ser muito triste né. X.x
Usando o #define MAX 20:
#include <stdio.h>
#define MAX 20
int main(void){
 int dados[MAX]; 
 inicializa_vetor(dados,MAX);
 preenche_vetor(dados,MAX);
 compara_valores(dados,MAX);
 imprime_resultado(dados,MAX);
 return 0;
}
Dessa vez, se caso o enunciado for alterado pra 30 notas, é só colocar:
#define MAX 30
É só alterar o #define no começo do programa e essa mudança será feita
no programa inteiro!
 
OBS: As duas formas estão totalmente certas! Mas eu recomendo que vc use sempre o #define pra deixar o programa mais organizado e prático pra alterações.
---------------------------------------------//-----------------------------------------------
- Quando e como fazer busca em vetores?
Sempre que vc já tiver um vetor preenchido com valores e vc precisar buscar/verificar se um determinado valor pertence a esse vetor. E além de saber se pertence ou não, é uma forma de descobrir em qual posição o valor está armazenado.
Esse é o protótipo da função busca:
int busca (int v[], int n, int chave){
 int i;
 
 for(i=0;i<n;i++){
 if(v[i] == chave){
 return i;
 }
 }
 return -1;
}
v[] é um nome genérico de vetor, n é a quantidade de posições e chave é o valor que vc quer procurar no vetor.
Bom, pra "variar" um pouco, precisamos usar uma repetição 'for' pra passar por todas as posições do vetor, notou que esse 'for' é usado pra quase tudo? :)
A condição 'if' verifica se alguma posição do vetor possui valor igual a chave (valor que queremos achar), se for igual, retorna o i que representa a posição exata onde a chave foi encontrada.
E se após rodar o vetor todo e não encontrar, a função busca retorna -1, ou seja, o -1 quer dizer que NÃO foi encontrado a chave em nenhuma posição do vetor v[].
OBS: Sempre que vc precisar "rodar/girar" um vetor (Passar por todas as posições), inicializar um vetor, fazer busca em vetores, preencher um vetor com dados lidos. >>Sempre<< vai ser esse mesmo 'for'.
Por isso que eu recomendo usar sempre a letra 'n' pra todos os casos, justamente pra facilitar.
OBS2: Se caso for um vetor de float, obrigatoriamente a chave também será float! Pois só podemos procurar por valores do tipo float num vetor que é do tipo float, o protótipo será:
int busca (float v[], int n, float chave)
OBS3: Essa função cai em >>TODAS<< as G2 e G3! Sempre tem no mínimo uma função busca!
Sim, essa é outra função que eu recomendo que vc decore urgentemente! :)