Questão 05 - Criar uma função para ler um vetor cujo número de elementos (dimensão) é passado como argumento. Crie uma outra função que receba um vetor e a sua dimensão, e faça a conversão de graus para radianos de todos os elementos desse vetor. Essa função deve retornar um vetor com os valores convertidos. Escrever um módulo de impressão (recebendo os dois vetores e sua dimensão). Escrever também o módulo principal.
Passo 1
O enunciado pede que você faça um programa com estes módulos (funções) principais:
- Uma função que leia um vetor de números cujo número de elementos (a dimensão) é passada como argumento. A função deve devolver esse vetor lido.
- Uma função que receba um vetor e a sua dimensão e faça a conversão de todos os elementos de graus para radianos. Essa função deve retornar um novo vetor contendo os valores convertidos.
- Um módulo de impressão que receba os dois vetores (o original em graus e o convertido em radianos) e a dimensão, e imprima ambos.
- O módulo principal (o programa principal) que utiliza as funções acima para ler, converter, imprimir e liberar memória.
Informações/dados relevantes que o enunciado fornece (listados claramente):
- A dimensão do vetor é passada como argumento para a função de leitura.
- A função de conversão recebe um vetor e sua dimensão e retorna outro vetor (não altera necessariamente o original).
- O módulo de impressão recebe os dois vetores e a dimensão.
- É necessário escrever o módulo principal (main).
- Não foi especificada linguagem: vou usar a linguagem C (explico o porquê nos passos seguintes).
Passo 2
Escolha da linguagem e formato das funções (explicação do método escolhido):
- Vou usar a linguagem C porque é uma escolha clássica para disciplinas de programação básica e permite trabalhar com vetores, funções que retornam ponteiros e alocação dinâmica — exatamente o que o enunciado pede. Além disso, é uma abordagem “básica” (pedagógica) que você consegue aplicar em prova.
- Estrutura que vou usar:
- Função de leitura: retorna um ponteiro para um vetor alocado dinamicamente (tipo
double *) e recebe a dimensãon(tiposize_t). - Função de conversão: recebe
const double *vet,size_t ne retorna umdouble *apontando para um novo vetor alocado contendo os radianos. - Função de impressão: recebe
const double *orig,const double *conv,size_t ne imprime linhas com índice, valor em graus e valor em radianos. main: lê a dimensão, chama as funções, faz validação simples, imprime e libera memória.
- Função de leitura: retorna um ponteiro para um vetor alocado dinamicamente (tipo
Passo 3
A regra matemática que precisamos saber (conversão graus → radianos) e por quê:
- Fórmula:
- Onde
é o ângulo em graus e é o ângulo em radianos. -
(pi) é a constante que relaciona circunferência e diâmetro; em notação numérica podemos usar .
- Onde
- Exemplo para fixar:
(ou seja, corresponde a radianos). Outro exemplo: .
Explicação didática: a fórmula multiplica por
porque uma volta completa tem
e
radianos, então
radianos. Na prova, decore ou derive rapidamente essa relação se pedirem.
Passo 4
Como implementar a função de leitura do vetor (conceito e código parcial):
- Objetivo da função: alocar espaço para
números (tipo double), ler do teclado cada elemento e devolver o ponteiro para o vetor lido. - Por que alocar dinamicamente? Porque a dimensão é passada em tempo de execução; assim o programa funciona para qualquer tamanho razoável de vetor.
- Estrutura da função (proposta de protótipo em C):
double *ler_vetor(size_t n);
- O que a função faz, passo a passo:
- Verifica se
. Se não, pode devolver NULL. - Usa
mallocpara alocarn * sizeof(double)bytes. - Verifica se a alocação retornou
NULL(falha de memória). - Em um laço
forde índiceide0atén-1, chamascanfpara ler cada valor emvet[i]. - Retorna o ponteiro para o vetor preenchido.
- Verifica se
- Observação prática para a prova: sempre verifique retorno de
malloce validescanfse quiser ser rigoroso, mas em exercícios de prova geralmente basta supor que a leitura será bem formada.
Passo 5
Como implementar a função de conversão (conceito e código parcial):
- Protótipo sugerido:
double *converter_graus_para_radianos(const double *vet, size_t n); - O que a função faz:
- Aloca um novo vetor
rescomnposições (tipodouble). - Calcula a constante multiplicadora uma vez:
. Em C podemos criar algo como const double PI = 3.141592653589793; const double F = PI / 180.0;. - Para cada índice
ide0atén-1, fazres[i] = vet[i] * F;. - Retorna
res.
- Aloca um novo vetor
- Por que retornar um novo vetor e não modificar o original? O enunciado pediu que “essa função deve retornar um vetor com os valores convertidos” — isso sugere criar e devolver um vetor novo. Em prova fique atento: se pedirem “converter in-place” você poderia alterar o vetor original, mas aqui vamos devolver um vetor novo.
Passo 6
Como implementar o módulo de impressão e o que imprimir (exemplo de layout e raciocínio):
- Protótipo sugerido:
void imprimir_vetores(const double *orig, const double *conv, size_t n); - O que imprimir e por quê:
- Queremos ver lado a lado o valor em graus e o valor convertido em radianos para checar visualmente.
- Imprimir o índice ajuda a relacionar elementos: por exemplo, “i: graus -> radianos”.
- Exemplo de linha de saída:
i: 0 | 45.000000 deg | 0.785398 rad
- Formatação: use
printf("%3zu: %10.6f deg -> %12.6f rad\n", i, orig[i], conv[i]);- Aqui
\%zuimprime umsize_t(índice),\%10.6fimprimedoublecom 6 casas decimais, etc.
- Aqui
- Lembre-se de que tudo deve ser liberado depois (no main).
Passo 7
Estrutura do
main (passos operacionais que você deve fazer no programa principal):- Perguntar ao usuário (ou ler) a dimensão
n. Ex.: imprimir um prompt e usarscanf("%zu", &n);. - Validar que
. Se inválido, imprimir mensagem e encerrar (ou pedir de novo). - Chamar
ler_vetor(n)para obter o vetor de graus (double *graus). - Chamar
converter_graus_para_radianos(graus, n)para obter o vetor de radianos (double *rads). - Chamar
imprimir_vetores(graus, rads, n). free(graus); free(rads);return 0;
- Dica de prova: sempre feche recursos (libere memória) para demonstrar boa prática. Em provas pequenas isso não é cobrado, mas ajuda a estruturar o raciocínio.
Passo 8
Código completo (aqui está o programa em C com tudo junto). Leia com calma — ele segue exatamente o que desenhamos: leitura, conversão, impressão e liberação de memória.
#include <stdio.h>
#include <stdlib.h>
double *ler_vetor(size_t n) {
if (n == 0) return NULL;
double *vet = (double *)malloc(n * sizeof(double));
if (vet == NULL) {
fprintf(stderr, "Erro: falha na alocacao de memoria.\n");
return NULL;
}
for (size_t i = 0; i < n; ++i) {
printf("Informe o elemento %zu (em graus): ", i);
if (scanf("%lf", &vet[i]) != 1) {
fprintf(stderr, "Erro: leitura falhou.\n");
free(vet);
return NULL;
}
}
return vet;
}
double *converter_graus_para_radianos(const double *vet, size_t n) {
if (vet == NULL || n == 0) return NULL;
const double PI = 3.141592653589793;
const double F = PI / 180.0;
double *res = (double *)malloc(n * sizeof(double));
if (res == NULL) {
fprintf(stderr, "Erro: falha na alocacao de memoria para conversao.\n");
return NULL;
}
for (size_t i = 0; i < n; ++i) {
res[i] = vet[i] * F;
}
return res;
}
void imprimir_vetores(const double *orig, const double *conv, size_t n) {
if (orig == NULL || conv == NULL) {
printf("Vetores invalidos para impressao.\n");
return;
}
printf("\nIndice | Graus (deg) -> Radianos (rad)\n");
printf("-------+-----------------------------------\n");
for (size_t i = 0; i < n; ++i) {
printf("%5zu | %11.6f deg -> %12.6f rad\n", i, orig[i], conv[i]);
}
}
int main(void) {
size_t n;
printf("Informe a dimensao do vetor (n > 0): ");
if (scanf("%zu", &n) != 1) {
fprintf(stderr, "Leitura da dimensao falhou.\n");
return 1;
}
if (n == 0) {
fprintf(stderr, "Dimensao invalida. Deve ser > 0.\n");
return 1;
}
double *graus = ler_vetor(n);
if (graus == NULL) return 1;
double *rads = converter_graus_para_radianos(graus, n);
if (rads == NULL) {
free(graus);
return 1;
}
imprimir_vetores(graus, rads, n);
free(graus);
free(rads);
return 0;
}
Passo 9
Como aplicar isso rapidamente na prova (resumo prático e dicas):
- Se pedirem só o esqueleto (sem alocação dinâmica), você pode declarar
double vet[100];e usar a mesma lógica; mas atenção: isso fixa tamanho máximo — declarado em tempo de compilação. - Em prova, escreva claramente os protótipos:
double *ler_vetor(size_t n);double *converter_graus_para_radianos(const double *vet, size_t n);void imprimir_vetores(const double *orig, const double *conv, size_t n);
- Lembre-se da fórmula de conversão:
. Anote se precisar calcular à mão. - Teste mental rápido: se o vetor for
você deve obter aproximadamente .
Resposta
#include <stdio.h>
#include <stdlib.h>
double *ler_vetor(size_t n) {
if (n == 0) return NULL;
double *vet = (double *)malloc(n * sizeof(double));
if (vet == NULL) {
fprintf(stderr, "Erro: falha na alocacao de memoria.\n");
return NULL;
}
for (size_t i = 0; i < n; ++i) {
printf("Informe o elemento %zu (em graus): ", i);
if (scanf("%lf", &vet[i]) != 1) {
fprintf(stderr, "Erro: leitura falhou.\n");
free(vet);
return NULL;
}
}
return vet;
}
double *converter_graus_para_radianos(const double *vet, size_t n) {
if (vet == NULL || n == 0) return NULL;
const double PI = 3.141592653589793;
const double F = PI / 180.0;
double *res = (double *)malloc(n * sizeof(double));
if (res == NULL) {
fprintf(stderr, "Erro: falha na alocacao de memoria para conversao.\n");
return NULL;
}
for (size_t i = 0; i < n; ++i) {
res[i] = vet[i] * F;
}
return res;
}
void imprimir_vetores(const double *orig, const double *conv, size_t n) {
if (orig == NULL || conv == NULL) {
printf("Vetores invalidos para impressao.\n");
return;
}
printf("\nIndice | Graus (deg) -> Radianos (rad)\n");
printf("-------+-----------------------------------\n");
for (size_t i = 0; i < n; ++i) {
printf("%5zu | %11.6f deg -> %12.6f rad\n", i, orig[i], conv[i]);
}
}
int main(void) {
size_t n;
printf("Informe a dimensao do vetor (n > 0): ");
if (scanf("%zu", &n) != 1) {
fprintf(stderr, "Leitura da dimensao falhou.\n");
return 1;
}
if (n == 0) {
fprintf(stderr, "Dimensao invalida. Deve ser > 0.\n");
return 1;
}
double *graus = ler_vetor(n);
if (graus == NULL) return 1;
double *rads = converter_graus_para_radianos(graus, n);
if (rads == NULL) {
free(graus);
return 1;
}
imprimir_vetores(graus, rads, n);
free(graus);
free(rads);
return 0;
}