paulo1205
(usa Ubuntu)
Enviado em 01/12/2018 - 05:50h
diegomrodrigues escreveu:
Sua função main() é do tipo int, então no final dela, retorne 0 com
return 0;
Eu concordo com você, mas é interessante saber que, assim como já havia sido feito com C++, agora não é mais obrigatório que a função
main () possua um comando
return explícito: se o fluxo de execução chegar ao final da função
main (), assume-se o mesmo comportamento que ocorreria se houvesse um “
return 0; ”.
[Isso não me agrada (nem em C nem em C++), pois torna a função
main () diferente de todas as outras funções do sistema, obrigando o compilador a ter regras próprias para essa função. Mesmo sem ser implementador de compiladores, a ideia de tratar de maneira uniforme todas as funções do programa me soa muito mais interessante do que ficar criando regras particulares.]
Criei uma variável TAMANHO_VETORES, onde você pode definir o tamanho dos vetores que o usuário irá entrar com os dados.
#include <stdlib.h>
int TAMANHO_VETORES = 5;
Por que você trocou a macro por uma variável? E, tendo-o feito, por que uma variável comum, em vez de constante?
Fazendo isso, você abre espaço para que alguém, até mesmo acidentalmente, possa mudar o valor da variável. Além disso, os vetores que você declarar usando essa variável não serão
arrays comuns do C, mas sim
arrays de tamanho variável (VLA), que podem ter
overhead em tempo de execução maior do que
arrays de tamanho fixo.
Se de todo você quiser deixar de usar macros, mas não quiser mexer na semântica dos
arrays e naquilo que o compilador pode resolver durante a compilação (em oposição a apenas durante a execução do programa compilado), uma alternativa é usar constantes declaradas como parte de enumerações (até mesmo enumerações anônimas).
enum { MAX_ELEMENTOS=5 };
/* ... */
int vetor1[MAX_ELEMENTOS]; // Constante de enumeração resolvida em tempo de compilação.
Veja discussão a seguir para mais motivos para preferir a resolução de dimensão em tempo de compilação, em vez de na hora da execução.
/*
* Calcular a média de 2 vetores
* Paramentro: vetor1 - Um dos vetores que será utilizado no cálculo
* Paramentro: vetor2 - O outro vetor que será utilizado no cálculo
* Retorno: Média dos 2 vetores
*/
float mediaVetores (int *vetor1, int *vetor2) {
Essa função não me parece muito coerente.
Veja bem: você moveu os vetores para dentro de
main (), obrigando sua passagem como argumentos para a função que calcula a média. Entretanto, você deixou um aspecto importante, que é o tamanho dos vetores, ainda como global. A função abre espaço para que o usuário envie um par de vetores quaisquer, mas assume que qualquer vetor que lhe seja passado vai ter um tamanho específico, o que, na prática, acaba roubando parte da liberdade que fora dada ao usuário.
Se é para dar liberdade ao usuário, deixe, então, que ele informe também o tamanho dos vetores, como um terceiro argumento passado como parâmetro da função.
Alternativamente, você poderia dar uma liberdade limitada, permitindo que ele passasse qualquer par de vetores que tivessem a dimensão requerida. Contudo, para fazer isso, você teria de mudar os tipos dos argumentos, para que se exigissem ponteiros para os
arrays inteiros de uma só vez (em lugar de ponteiros para seus primeiros elementos), especificando as dimensões permitidas como parte do tipo dos argumentos.
// O tipo dos argumentos é “ponteiro para vetor com ‘MAX_ELEMENTOS’ do tipo int”.
// Neste caso, convém MAX_ELEMENTOS seja constante (i.e.: macro ou constante de enumeração).
float mediaVetores(int (*vetor1)[MAX_ELEMENTOS], int (*vetor2)[MAX_ELEMENTOS])
Fazendo desse modo, você só poderá passar como argumentos à função vetores declarados com exatamente
MAX_ELEMENTOS , e terá de fazê-lo por meio de ponteiros.
int v1[MAX_ELEMENTOS], v2[MAX_ELEMENTOS], v3[MAX_ELEMENTOS-1], v4[MAX_ELEMENTOS+4];
mediaVetores(&v1, &v2); // OK
mediaVetores(v1, v2); // Erro de tipo: função espera ponteiros para vetores, não para os elementos de vetores.
mediaVetores(&v1, &v3); // Erro de tipo: &v3 produz um ponteiro para array com dimensão diferente da esperada pela função.
mediaVetores(&v1, &v4); // Erro de tipo: mesmo sendo v4 maior (e, portanto, seguro) que o tamanho desejado, &v4 produz tipo de ponteiro incompatível.
Se, em vez de macro ou contante de enumeração você usar uma variável (como fez no programa que você indicou), o compilador não vai ter como determinar de modo inequívoco qual deve ser o tamanho do vetor apontado, e vai acabar aceitando qualquer vetor, tenha ele a dimensão correta ou não (os dois últimos casos mostrados acima passariam a ser aceitos pelo compilador, sem qualquer mensagem de erro ou de diagnóstico).
[O mais curioso, para mim, é que não adianta nem mesmo declarar a variável com atributo
const , que é a prática mais comum no mundo C++, em substituição a macros. Infelizmente, o atributo
const do C é bem mais fraco do que o mesmo atributo em C++: ele faz com que o compilador impeça a alteração do valor da variável como parte do programa em C, e pode até fazer com que ela seja disposta num segmento de memória marcado como apenas leitura, mas não dá garantias de que o valor não possa ser alterado de alguma outra maneira, fora do controle do programa em C.]
float media = 0.0f;
for (int i = 0; i < TAMANHO_VETORES; i++) {
media += (vetor1[i] + vetor2[i]);
}
media = media/TAMANHO_VETORES;
Note que isso não calcula a média dos elementos dos vetores, mas sim a média da soma dos elementos de mesmo índice nos dois vetores.
Sem ver o enunciado, não dá para saber se isso está certo ou não. Mas eu suspeito que não esteja (o erro, se houver, não é seu; já estava no programa original).
return media;
}
/*
* Função principal do sistema
*/
int main(void) {
float media_dois_vetores = 0.0f;
int vetor1 [TAMANHO_VETORES];
int vetor2 [TAMANHO_VETORES];
// Entrada de dados pelo usuário final
printf ("\nDigite os valores do primeiro vetor:\n\n");
for (int i = 0; i < TAMANHO_VETORES; i++)
scanf ("%d", &vetor1[i]);
printf ("\nDigite os valores do segundo vetor:\n\n");
for (int i = 0; i < TAMANHO_VETORES; i++)
scanf ("%d", &vetor2[i]);
// Realizar o cálculo da média dos 2 vetores
media_dois_vetores = mediaVetores (vetor1, vetor2);
// Exibir o resultado
printf ("\nA média dos dois vetores é: \n\n%.2f\n", media_dois_vetores);
return 0;
}