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ão n (tipo size_t).
    • Função de conversão: recebe const double *vet, size_t n e retorna um double * apontando para um novo vetor alocado contendo os radianos.
    • Função de impressão: recebe const double *orig, const double *conv, size_t n e 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.

Passo 3

A regra matemática que precisamos saber (conversão graus → radianos) e por quê:
  • Fórmula: \text{rad} = \text{deg} \times \frac{\pi}{180}
    • Onde \text{deg} é o ângulo em graus e \text{rad} é o ângulo em radianos.
    • \pi (pi) é a constante que relaciona circunferência e diâmetro; em notação numérica podemos usar \pi \approx 3{,}141592653589793.
  • Exemplo para fixar: \,180^\circ \times \dfrac{\pi}{180} = \pi (ou seja, 180^\circ corresponde a \pi radianos). Outro exemplo: 90^\circ \times \dfrac{\pi}{180} = \dfrac{\pi}{2}.
Explicação didática: a fórmula multiplica por \dfrac{\pi}{180} porque uma volta completa tem 360^\circ e 2\pi radianos, então 1^\circ = \dfrac{2\pi}{360} = \dfrac{\pi}{180} 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 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:
    1. Verifica se n > 0. Se não, pode devolver NULL.
    2. Usa malloc para alocar n * sizeof(double) bytes.
    3. Verifica se a alocação retornou NULL (falha de memória).
    4. Em um laço for de índice i de 0 até n-1, chama scanf para ler cada valor em vet[i].
    5. Retorna o ponteiro para o vetor preenchido.
  • Observação prática para a prova: sempre verifique retorno de malloc e valide scanf se 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:
    1. Aloca um novo vetor res com n posições (tipo double).
    2. Calcula a constante multiplicadora uma vez: \dfrac{\pi}{180}. Em C podemos criar algo como const double PI = 3.141592653589793; const double F = PI / 180.0;.
    3. Para cada índice i de 0 até n-1, faz res[i] = vet[i] * F;.
    4. Retorna res.
  • 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 \%zu imprime um size_t (índice), \%10.6f imprime double com 6 casas decimais, etc.
  • 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):
  1. Perguntar ao usuário (ou ler) a dimensão n. Ex.: imprimir um prompt e usar scanf("%zu", &n);.
  2. Validar que \,n > 0. Se inválido, imprimir mensagem e encerrar (ou pedir de novo).
  3. Chamar ler_vetor(n) para obter o vetor de graus (double *graus).
  4. Chamar converter_graus_para_radianos(graus, n) para obter o vetor de radianos (double *rads).
  5. Chamar imprimir_vetores(graus, rads, n).
  6. free(graus); free(rads);
  7. 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: \text{rad} = \text{deg} \times \dfrac{\pi}{180}. Anote \pi \approx 3{,}141592653589793 se precisar calcular à mão.
  • Teste mental rápido: se o vetor for [0, 90, 180] você deve obter aproximadamente [0, 1{,}570796, 3{,}141593].

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;
}

Exercícios relacionados