C FILE não grava no arquivo

Pietra Ester · 23 de abril de 2022

Estou fazendo esse exercicio de vetores e arquivos, e esta retornando zero a soma e a diferença no arquivo, acho que não esta gravando em arquivo, alguém sabe o porque?

//BIBLIOTECAS
#include <stdio.h>
#include <stdlib.h>

//VARÁVEL GLOBAL PARA O TAMANHO DO VETOR
int tam_v;

//CRIA VETOR
int *cria_vet(int n)
{
    int *vet;
    int i;
    printf("\nDigite o tamanho do vetor: ");
    scanf("%d", &tam_v);
    //cria um vetor de n posições
    vet = (int *) malloc (tam_v*sizeof(int));
    return vet;
}

//PREENCHE O VETOR
void inicializa(float *vet, int tam_v)
{
    int i;

    //Preenche o vetor
    for(i=0; i<tam_v; i++)
    {
        printf("Elemento %d: ", i);//valores digitados pelo usuario
        scanf("%f", &vet[i]);//lê os valores
    }
}

//MOSTRA
float mostra(float *vet, int tam_v)
{
    int i;
    printf("\nVetor gerado:\n");
    for (i=0; i<tam_v; i++)
        printf("%.2f ", vet[i]);

    return vet[tam_v];//retorna o vetor
}

//CALCULA A DIFERENÇA
float diferenca(float *vet, int tam_v)
{
    int i;
    float dif, menor, maior;

    //encontra o maior
    maior = vet[0];
    for(i=1; i<tam_v; i++)
    {
        if (vet[i] > maior)
            maior = vet[i];
    }
    printf("\n\nMaior = %.2f\n", maior);

    //encontra o menor
    menor = vet[0];
    for(i=1; i<tam_v; i++)
    {
        if (vet[i] < maior)
            menor = vet[i];
    }
    printf("Menor = %.2f\n", menor);

    //calcula a diferença
    dif = maior - menor;

    //mostra a diferença
    printf("Diferenca = %.2f \n\n", dif);

    return dif;
}

//CALCULA A SOMA DOS ELEMENTOS
float soma_elementos(float *vet, int tam_v)
{
    int i;
    float soma=0;
    for(i=0; i<tam_v; i++)
    {
        soma = soma + vet[i];
    }
    printf("Soma dos elementos = %.2f\n\n", soma);

    return soma;
}

//ARMAZENA EM DISCO
float salva_le(float *vet, int tam_v, float soma, float dif)
{

    FILE *fp;
    //Modo W de write (escrita)
    fp = fopen("e:\\armazena_soma_dif.txt", "w");
    if(fp == NULL)
    {
        printf("Sem memória!\n");//verifica se existe o arquivo
    }
    else
    {
        fprintf(fp, "Soma = %f", soma);
        fprintf(fp, "Dif  = %f", dif);
        printf("Soma e diferenca gravados com sucesso!\n");
        fclose(fp);//fecha o arquivo
    }

//LÊ EM DISCO

    FILE *le;
    le = fopen("e:\\armazena_soma_dif.txt", "r");//Modo R de Read (leitura)
    if(le == NULL) //verifica se existe o arquivo
    {
        printf("\nErro ao abrir o arquivo.\n\n");
    }
    else
    {
        fscanf(le, "Soma = %.2f\n", &soma);
        fscanf(le, "Dif  = %.2f", &dif);
        printf("Soma = %.2f\nDiferenca = %.2f\n", &soma, &dif);
        fclose(fp);//fecha o arquivo
    }

    system ("pause");//pausa na tela, somente para Windows
}

int main()
{
    //VARIÁVEIS
    int n;
    float vet[tam_v], soma, dif;

    //CABEÇALHO
    printf("---> Avaliacao de Algoritmo\n");
    printf("---> 2o Semestre\n");
    printf("---------------------------------------\n");

    //FUNÇÃO QUE CRIA O VETOR
    cria_vet(n);

    //FUNÇÃO QUE INICIALIZA O VETOR
    inicializa(vet, tam_v);

    //FUNÇÃO QUE IMPRIME O VETOR
    mostra(vet, tam_v);

    //FUNÇÃO QUE CALCULA A DIFERENÇA
    diferenca(vet, tam_v);

    //FUNÇÃO SOMA
    soma_elementos(vet, tam_v);

    //FUNÇÃO QUE ARMAZENA EM DISCO FAZ A LEITURA
    salva_le(vet, tam_v, soma, dif);

    return 0;
}

kgin · 23 de abril de 2022

@Pietra Ester Perceba que no main você não pegou as variáveis soma e dif.

//BIBLIOTECAS
#include <stdio.h>
#include <stdlib.h>

#define ARQ_LOCAL "info.txt"

//VARÁVEL GLOBAL PARA O TAMANHO DO VETOR
int tam_v;

//CRIA VETOR
int *cria_vet(int n)
{
    int *vet;
    int i;
    printf("\nDigite o tamanho do vetor: ");
    scanf("%d%*c", &tam_v);
    //cria um vetor de n posições
    vet = (int *) malloc (tam_v*sizeof(int));
    return vet;
}

//PREENCHE O VETOR
void inicializa(float *vet, int tam_v)
{
    int i;

    //Preenche o vetor
    for(i=0; i<tam_v; i++)
    {
        printf("Elemento %d: ", i);//valores digitados pelo usuario
        scanf("%f%*c", &vet[i]);//lê os valores
    }
}

//MOSTRA
float mostra(float *vet, int tam_v)
{
    int i;
    printf("\nVetor gerado:\n");
    for (i=0; i<tam_v; i++)
        printf("%.2f ", vet[i]);

    return vet[tam_v];//retorna o vetor
}

//CALCULA A DIFERENÇA
float diferenca(float *vet, int tam_v)
{
    int i;
    float dif, menor, maior;

    //encontra o maior
    maior = vet[0];
    for(i=1; i<tam_v; i++)
    {
        if (vet[i] > maior)
            maior = vet[i];
    }
    printf("\n\nMaior = %.2f\n", maior);

    //encontra o menor
    menor = vet[0];
    for(i=1; i<tam_v; i++)
    {
        if (vet[i] < maior)
            menor = vet[i];
    }
    printf("Menor = %.2f\n", menor);

    //calcula a diferença
    dif = maior - menor;

    //mostra a diferença
    printf("Diferenca = %.2f \n\n", dif);

    return dif;
}

//CALCULA A SOMA DOS ELEMENTOS
float soma_elementos(float *vet, int tam_v)
{
    int i;
    float soma=0;
    for(i=0; i<tam_v; i++)
    {
        soma = soma + vet[i];
    }
    printf("Soma dos elementos = %.2f\n\n", soma);

    return soma;
}

//ARMAZENA EM DISCO
float salva_le(float *vet, int tam_v, float soma, float dif)
{

    FILE *fp;
    //Modo W de write (escrita)
    fp = fopen(ARQ_LOCAL, "w");
    if(fp == NULL)
    {
        printf("Sem memória!\n");//verifica se existe o arquivo
    }
    else
    {
        fprintf(fp, "Soma = %f", soma);
        fprintf(fp, " Dif  = %f", dif);
        printf("Soma e diferenca gravados com sucesso!\n");
        fclose(fp);//fecha o arquivo
    }

//LÊ EM DISCO

    FILE *le;
    le = fopen(ARQ_LOCAL, "r");//Modo R de Read (leitura)
    if(le == NULL) //verifica se existe o arquivo
    {
        printf("\nErro ao abrir o arquivo.\n\n");
    }
    else
    {
        fscanf(le, "Soma = %.2f\n", &soma);
        fscanf(le, "Dif  = %.2f", &dif);
        printf("Soma = %.2f\nDiferenca = %.2f\n", &soma, &dif);
        fclose(fp);//fecha o arquivo
    }

    /* system ("pause"); Chega a ser engraça do :b *///pausa na tela, somente para Windows
    getchar();
}

int main()
{
    //VARIÁVEIS
    int n;
    float vet[tam_v], soma, dif;

    //CABEÇALHO
    printf("---> Avaliacao de Algoritmo\n");
    printf("---> 2o Semestre\n");
    printf("---------------------------------------\n");

    //FUNÇÃO QUE CRIA O VETOR
    cria_vet(n);

    //FUNÇÃO QUE INICIALIZA O VETOR
    inicializa(vet, tam_v);

    //FUNÇÃO QUE IMPRIME O VETOR
    mostra(vet, tam_v);

    //FUNÇÃO QUE CALCULA A DIFERENÇA
    dif = diferenca(vet, tam_v);

    //FUNÇÃO SOMA
    soma = soma_elementos(vet, tam_v);

    //FUNÇÃO QUE ARMAZENA EM DISCO FAZ A LEITURA
    salva_le(vet, tam_v, soma, dif);

    return 0;
}

E esse seu código tem um vazamento de memória.

devair1010 · 23 de abril de 2022

@Pietra Ester no seu código tem nessa função

//ARMAZENA EM DISCO
float salva_le(float *vet, int tam_v, float soma, float dif)
{

    FILE *fp;
    //Modo W de write (escrita)
    fp = fopen(ARQ_LOCAL, "w");  /// cria abre e reseta o arquivo
                                 /// para gravar a partir do inicio do arquivo
    if(fp == NULL)
    {
        printf("Sem memória!\n");//verifica se existe o arquivo
    }
    else
    {
        fprintf(fp, "Soma = %f", soma);
        fprintf(fp, " Dif  = %f", dif);
        printf("Soma e diferenca gravados com sucesso!\n");
        fclose(fp);//fecha o arquivo
    }

para gravar os dados no arquivo , e toda vez que usar essa função vai resetar o arquivo , deletando o que foi gravado antes , e esses dados serão perdidos . , ficando apenas os últimos que foram gravados . então seria melhor usar outro modo de abertura do arquivo , por exemplo esse :

https://www.pucsp.br/~so-comp/cursoc/aulas/c950.html

FILE *fp;
                               /// Modo "a" de "append"
fp = fopen(ARQ_LOCAL, "a");    /// tenta abrir o arquivo para ler e gravar no final dele
if(fp == NULL)                 /// se o arquivo não existir
{
  fp = fopen(ARQ_LOCAL, "w");  /// cria e abre e reseta o arquivo para gravar no inicio dele
}
else
{
  fprintf(fp, "Soma = %f", soma);
  fprintf(fp, " Dif  = %f", dif);
  printf("Soma e diferenca gravados com sucesso!\n");
  fclose(fp);                  // fecha o arquivo
}

Pietra Ester · 24 de abril de 2022

@kgin eu declarei como float soma e dif no main, não é isso? como eu pegaria elas?

kgin · 24 de abril de 2022

10 minutos atrás, Pietra Ester disse:

eu declarei como float soma e dif no main, não é isso? como eu pegaria elas?

você está retornado eles na função diferenca() e soma_elementos().

Eu coloquei como pegar aqui

8 horas atrás, kgin disse:

    //FUNÇÃO QUE CALCULA A DIFERENÇA
    dif = diferenca(vet, tam_v);

    //FUNÇÃO SOMA
    soma = soma_elementos(vet, tam_v);

Pietra Ester · 24 de abril de 2022

1 hora atrás, Pietra Ester disse:

@kgin eu declarei como float soma e dif no main, não é isso? como eu pegaria elas?

não deu certo atribuir as variaveis no main

Pietra Ester · 24 de abril de 2022

12 horas atrás, Pietra Ester disse:

não deu certo atribuir as variaveis no main

E SE COLOCAR UM VETOR MAIOR TIPO 10 O VALOR MENOR NA FUNÇÃO DIFERENÇA CALCULA ERRADO O MENOR

14 horas atrás, kgin disse:

você está retornado eles na função diferenca() e soma_elementos().

Eu coloquei como pegar aqui

eu testei aqui e mesmo assim esta retornado e gravando zero a soma e a diferença

12 horas atrás, Pietra Ester disse:

não deu certo atribuir as variaveis no main

//BIBLIOTECAS
#include <stdio.h>
#include <stdlib.h>
//CONSTANTE LOCAL DO ARQUIVO
#define ARQ_LOCAL "soma_diferenca.txt"

//VARÁVEL GLOBAL PARA O TAMANHO DO VETOR
int tam_v;

//CRIA VETOR
int *cria_vet(int n)
{
    int *vet;
    int i;
    printf("\nDigite o tamanho do vetor: ");
    scanf("%d", &tam_v);
    //cria um vetor de n posições
    vet = (int *) malloc (tam_v*sizeof(int));
    return vet;
}

//PREENCHE O VETOR
void inicializa(float *vet, int tam_v)
{
    int i;

    //Preenche o vetor
    for(i=0; i<tam_v; i++)
    {
        printf("Elemento %d: ", i);//valores digitados pelo usuario
        scanf("%f", &vet[i]);//lê os valores
    }
}

//MOSTRA
float mostra(float *vet, int tam_v)
{
    int i;
    printf("\nVetor gerado:\n");
    for (i=0; i<tam_v; i++)
        printf("%.2f ", vet[i]);

    return vet[tam_v];//retorna o vetor
}

//CALCULA A DIFERENÇA
float diferenca(float *vet, int tam_v)
{
    int i;
    float dif, menor, maior;

    //encontra o maior
    maior = vet[0];
    for(i=1; i<tam_v; i++)
    {
        if (vet[i] > maior)
            maior = vet[i];
    }
    printf("\n\nMaior = %.2f\n", maior);
    
    //limpa o buffer do teclado
    fflush(stdin);
    
    //encontra o menor
    menor = vet[0];
    for(i=0; i<tam_v; i++)
    {
        if (vet[i] < maior)
            menor = vet[i];
    }
    printf("Menor = %.2f\n", menor);
    
    //calcula a diferença
    dif = maior - menor;

    //mostra a diferença
    printf("Diferenca = %.2f \n\n", dif);

    return dif;
}

//CALCULA A SOMA DOS ELEMENTOS
float soma_elementos(float *vet, int tam_v)
{
    int i;
    float soma=0;
    for(i=0; i<tam_v; i++)
    {
        soma = soma + vet[i];
    }
    printf("Soma dos elementos = %.2f\n\n", soma);

    return soma;
}

//ARMAZENA EM DISCO
float salva_le(float *vet, int tam_v, float soma, float dif)
{

    FILE *fp;
    //Modo W de write (escrita)
    fp = fopen(ARQ_LOCAL, "a");
    if(fp == NULL)
    {
        fopen(ARQ_LOCAL, "w");// cria e abre e reseta o arquivo para gravar no inicio dele
    }
    else
    {
        fprintf(fp, "Soma = %.2f", soma);
        fprintf(fp, "Dif  = %.2f", dif);
        fclose(fp);//fecha o arquivo
    }
    printf("Soma e diferenca gravados com sucesso!\n");

//LÊ EM DISCO

    FILE *le;
    le = fopen(ARQ_LOCAL, "r");//Modo R de Read (leitura)
    if(le == NULL) //verifica se existe o arquivo
    {
        printf("\nErro ao abrir o arquivo.\n\n");
    }
    else
    {
        fscanf(le, "Soma = %.2f\n", &soma);
        fscanf(le, "Dif  = %.2f", &dif);
        printf("Soma = %.2f\nDiferenca = %.2f\n", &soma, &dif);
        fclose(fp);//fecha o arquivo
    }

    system ("pause");//pausa na tela, somente para Windows
}

int main()
{
    //VARIÁVEIS
    int n;
    float vet[tam_v], soma, dif;

    //FUNÇÃO QUE CRIA O VETOR
    cria_vet(n);

    //FUNÇÃO QUE INICIALIZA O VETOR
    inicializa(vet, tam_v);

    //FUNÇÃO QUE IMPRIME O VETOR
    mostra(vet, tam_v);

    //FUNÇÃO QUE CALCULA A DIFERENÇA
    dif = diferenca(vet, tam_v);

    //FUNÇÃO SOMA
    soma = soma_elementos(vet, tam_v);

    //FUNÇÃO QUE ARMAZENA EM DISCO FAZ A LEITURA
    salva_le(vet, tam_v, soma, dif);

    return 0;
}

devair1010 · 24 de abril de 2022

@Pietra Ester você está usando variáveis Globais , que não é bom , e além disso você não inicializou as variáveis n e tam_v , e mesmo assim enviou elas por parâmetro para as funções , e nesse caso vai criar um vetor com zero qtd de elementos , pois as variáveis globais são inicializadas pelo compilador automaticamente e com o valor zero , mas n tem um valor desconhecido , e melhor inicializar as variáveis maior e menor usando uma macro que já existe na biblioteca

#include <float.h>

que são FLT_MAX e FLT_MIN

e algumas função não necessidade como a de criar um veto dinâmico , ali você pode cria lo na função main mesmo , e seu código poderia ser assim

//BIBLIOTECAS
#include <stdio.h>
#include <stdlib.h>
#include <float.h>
//CONSTANTE LOCAL DO ARQUIVO
#define ARQ_LOCAL "soma_diferenca.txt"

//VARÁVEL GLOBAL PARA O TAMANHO DO VETOR
int tam_v; // variaveL Global , é ruim

//CRIA VETOR
int *cria_vet( int n )  /// recebe variavel  n  , que tem valor desconhecido
{
    int *vet;
    int i;
    printf("\nDigite o tamanho do vetor: ");
    scanf("%d", &tam_v);
    //cria um vetor de n posições
    vet = (int *) malloc (tam_v*sizeof(int));
    //return vet;  vetor dinamico não precisa ser retornado
}

//PREENCHE O VETOR
void inicializa(float *vet, int tam_v)
{
  int i;
  //Preenche o vetor
  for(i=0; i<tam_v; i++)
  {
    printf("Elemento %d: ", i); /// valores digitados pelo usuario
    scanf("%f", &vet[i]);       /// lê os valores
  }
}
//MOSTRA
float mostra(float *vet, int tam_v)
{
  int i;
  printf("na Funcao Mostar\n");
  printf("Vetor gerado: ");
  for (i=0; i<tam_v; i++)
    printf("%.2f ", vet[i]);
  /// return vet[tam_v];    /// retorna o vetor
  /// não precisa retornar pois o vetor eh dinamico
  /// e não se pode retornar nem vetor nem string , mas apenas um valor simples
}

//CALCULA A DIFERENÇA
float diferenca(float *vet, int tam_v)
{
  int i;
  float dif, menor = FLT_MAX, maior = FLT_MIN;
  printf("\nna Funcao diferenca\n");
  //encontra o maior
  printf("tam_v = %d\nvet[0]= %.2f\n",tam_v,vet[0]); /// apenas para ver a saida
  printf("vet[0]= %.2f\n%.2f\n",vet[0]);
  printf("Maior= %.2f\n",maior);
  printf("Menor= %.2f\n",menor);
  for(i=0; i<tam_v; i++)
  {
    /// printf("vet[%d]= %.2f\n",i,vet[i]);
    if (vet[i] > maior)
      maior = vet[i];
    else
      if( vet[i] < menor )
        menor = vet[i];
  }
  printf("\n\nMaior = %.2f\n", maior);
  printf("Menor = %.2f\n", menor);
  //calcula a diferença
  dif = maior - menor;
  //mostra a diferença
  printf("Diferenca = %.2f \n\n", dif);
  return dif;
}

//CALCULA A SOMA DOS ELEMENTOS
float soma_elementos(float *vet, int tam_v)
{
    int i;
    float soma=0;
    for(i=0; i<tam_v; i++)
    {
        soma = soma + vet[i];
    }
    printf("Soma dos elementos = %.2f\n\n", soma);

    return soma;
}

//ARMAZENA EM DISCO
float salva_le(float *vet, int tam_v, float soma, float dif)
{

    FILE *fp;
    //Modo W de write (escrita)
    fp = fopen(ARQ_LOCAL, "a");
    if(fp == NULL)
    {
        fopen(ARQ_LOCAL, "w");// cria e abre e reseta o arquivo para gravar no inicio dele
    }
    else
    {
        fprintf(fp, "Soma = %.2f", soma);
        fprintf(fp, "Dif  = %.2f", dif);
        fclose(fp);//fecha o arquivo
    }
    printf("Soma e diferenca gravados com sucesso!\n");

//LÊ EM DISCO

    FILE *le;
    le = fopen(ARQ_LOCAL, "r");//Modo R de Read (leitura)
    if(le == NULL) //verifica se existe o arquivo
    {
        printf("\nErro ao abrir o arquivo.\n\n");
    }
    else
    {
        fscanf(le, "Soma = %.2f\n", &soma);  /// fscanf só le até encontrar um espaco em branco na linha
        fscanf(le, "Dif  = %.2f", &dif);     /// assim só vai ler o primeiro numero
        printf("Soma = %.2f\nDiferenca = %.2f\n", soma, dif);
        fclose(fp);//fecha o arquivo
    }

    system ("pause");//pausa na tela, somente para Windows
}

int main()
{
  //VARIÁVEIS
  int n; /// variavel local eh bom , mas esta sem ser inicializada e com valor desconhecido
  float *vet, soma, dif;
  /// FUNÇÃO QUE CRIA O VETOR
  /// cria_vet(n);                         /// não precisa de uma funcao que cria um vetor unico
  printf("\nDigite o tamanho do vetor: "); /// pode cria lo aqui na funcao main mesmo
  scanf("%d", &tam_v);
  //cria um vetor de n posições
  vet = (int *) malloc ( tam_v * sizeof( int ) );
  //FUNÇÃO QUE INICIALIZA O VETOR
  inicializa(vet, tam_v);
  int i;
  //Preenche o vetor
  printf("na funcao main\n");
  for(i=0; i<tam_v; i++)
  {
    printf("%.2f\n",vet[i]);
  }
  //FUNÇÃO QUE IMPRIME O VETOR
  mostra(vet, tam_v);
  //FUNÇÃO QUE CALCULA A DIFERENÇA
  dif = diferenca(vet, tam_v);
  //FUNÇÃO SOMA
  soma = soma_elementos(vet, tam_v);
  //FUNÇÃO QUE ARMAZENA EM DISCO FAZ A LEITURA
  salva_le(vet, tam_v, soma, dif);
  return 0;
}

kgin · 25 de abril de 2022

@Pietra Ester Eu acho melhor você reescrever porque tem muita coisa errada aí.

Veja que aqui você declarou o ponteiro para a variável vet e nunca usou

10 horas atrás, Pietra Ester disse:

//CRIA VETOR
int *cria_vet(int n)
{
    int *vet;
    int i;
    printf("\nDigite o tamanho do vetor: ");
    scanf("%d", &tam_v);
    //cria um vetor de n posições
    vet = (int *) malloc (tam_v*sizeof(int));
    return vet;
}

você ignora o vetor criado no main

10 horas atrás, Pietra Ester disse:
    //FUNÇÃO QUE CRIA O VETOR
    cria_vet(n);

era pra ser algo como

	vet = cria_vet(tamanho_vetor);

E você declarou vet como vetor sendo que era para declarar como ponteiro.

Errado!

10 horas atrás, Pietra Ester disse:
float vet[tam_v]

Correto!

	float *vet = NULL;

Tome um exemplo de como fazer para criar o vetor.

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define NOME_ARQUIVO "teste.txt"

float
*vetor_cria(int tamanho)
{
    /* Cria um vetor do tamanho dado pela variavel tamanho */
    float *vetor = malloc(sizeof(*vetor)*tamanho);
    /* Checa se foi possível criar o vetor */
    if (vetor != NULL) {
        /* Devolve o vetor para a função que o chamou */
        return(vetor);
    }
    
    /* Retorna NULL caso não for possível reservar a memória para o vetor */
    return(NULL);
}

void
vetor_apaga(float **vetor)
{
    /* Verifica se o ponteiro é valido */
    if (*vetor != NULL) {
        /* Libera a memória reservada */
        free(*vetor);
    }
    /* Invalida o ponteiro */
    *vetor = NULL;
}

/*
 * Coloca numeros aleatorios de 0 a 100 no vetor
 */
void
vetor_inicializa_aleatorios(float *vetor, int tamanho)
{
    int contador;
    /* Passa a hora e a data do sistema como semente para o gerador de numeros */
    srand(time(NULL));
    /* Coloca os numeros no vetor */
    for (contador = 0; contador < tamanho; contador++) {
        vetor[contador] = rand()%100;
    }
}

void
vetor_inicializa_usuario(float *vetor, int tamanho)
{
    int contador;
    printf("Por favor digite %i numeros para o vetor\n", tamanho);
    for (contador = 0; contador < tamanho; contador++) {
        printf("[%i]:", contador+1);
        scanf("%f%*c", &vetor[contador]);
    }
}

float
vetor_soma_elementos(float *vetor, int tamanho)
{
    float soma = 0;
    int contador;
    for (contador = 0; contador < tamanho; contador++) {
        soma+=vetor[contador];
    }
    return(soma);
}

float
vetor_maior_elemento(float *vetor, int tamanho, float menor_elemento)
{
    int contador;
    float maior = menor_elemento;
    for (contador = 0; contador < tamanho; contador++) {
        if (vetor[contador] > maior) {
            maior = vetor[contador];
        }
    }
    return(maior);
}

float
vetor_menor_elemento(float *vetor, int tamanho, float maior_elemento)
{
    int contador;
    float menor = maior_elemento;
    for (contador = 0; contador < tamanho; contador++) {
        if (vetor[contador] < menor) {
            menor = vetor[contador];
        }
    }
    return(menor);
}

void
vetor_mostra(float *vetor, int tamanho)
{
    int contador;
    for (contador = 0; contador < tamanho; contador++) {
        printf("[%i]:%.2f\n", contador+1, vetor[contador]);
    }
}

int main(void)
{
    /* Variaveis para guardar os valores retornados */
    float
        soma = 0,
        maior = 0,
        menor = 0,
        diferenca = 0;
        
    /* Nosso vetor dinamico */
    float *vetor = NULL;
    
    /* tamanho do vetor */
    int vetor_tamanho = 0;
    
    char opcao;
    
    /* Pergunta o tamanho do vetor */
    printf("Digite o tamanho do vetor:");
    scanf("%i%*c", &vetor_tamanho);
    
    /* Cria o vetor */
    vetor = vetor_cria(vetor_tamanho);
    
    /* Checa se foi possível criar o vetor */
    if (vetor == NULL) {
        perror("Erro: não foi possível reservar memória!");
        exit(EXIT_FAILURE);
    }
    
    /* Inicia o vetor */
    vetor_inicializa_aleatorios(vetor, vetor_tamanho);
    
    /* Mostra o vetor */
    printf("Vetor gerado!\n");
    vetor_mostra(vetor, vetor_tamanho);
    
    /* Pega o maior elemento do vetor */
    maior = vetor_maior_elemento(vetor, vetor_tamanho, 0);
    
    /* Pega o menor elemento do vetor */
    menor = vetor_menor_elemento(vetor, vetor_tamanho, maior);
    
    printf("O maior elemento do vetor e %.2f e o menor e %.2f\n", maior, menor);
    
    /* Mostra a diferenca */
    diferenca = maior-menor;
    
    printf("E a diferenca e %.2f\n", diferenca);
    
    /* Libera o vetor */
    vetor_apaga(&vetor);
    
    getchar();      /* Espera a tecla enter */
    
    return(0);
}

Exemplo online!

Ansi C · 26 de abril de 2022

No caso em questão, fez alocação dinâmica e estática do vet.

Em 23/04/2022 às 12:53, Pietra Ester disse:

    float vet[tam_v], soma, dif;

    //CABEÇALHO
    printf("---> Avaliacao de Algoritmo\n");
    printf("---> 2o Semestre\n");
    printf("---------------------------------------\n");

    //FUNÇÃO QUE CRIA O VETOR
    cria_vet(n);

E segue bipolar, conflita entre alocações estática e dinâmica do vetor `vet` em todas as funções. Seria|será|é sábio escolher uma das abordagens. Penso que alocação estática tem mais indicações para o caso de estrutura simples como os vetores.