Retorno - 1

[alan anderxon]

Boa noite galera, gostaria que a minha funçao retornasse - 1 de uma maneira mais eficiente, ela até retorna, mas sinto que estou fazendo uma gambiarra, alguem tem alguma sugestao?

#include <stdio.h>
int cod(float *valor){
  int qnt, quantidade;
  float val, preco;
  printf("tipo quarto: \n");
  scanf("%d", &qnt);
 
printf ("\nQuantidade: ");
    scanf ("%d", &quantidade);
  switch(qnt){
    case 101:
     val = 3.50 * quantidade;
    break;
     case 102:
     val = 5.00 * quantidade;
    break;
     case 103:
    val = 7.80 * quantidade;
    break;
    case 104:
     val = 5.00 * quantidade;
    break;
    case 105:
     val = 8.20 * quantidade;
    break;
    case 106:
   val =  6.40 * quantidade;
    break;
     case 107:
     val =  4.75 * quantidade;
    break;
     case 108:
     val =   3.60 * quantidade;
    break;
     case 109:
     val =  6.00 * quantidade;
    break;
     case 110:
    val =  4.30 * quantidade;
    break;
    default:
       val = -1;
       break;
  }
  *valor = val;
}
int main(void) {
  int qnt, quantidade;
  float valor, preco;
   cod(&valor);
 
  printf ("\nValor total da conta: R$ %.2f", valor);
  return 0;
}

[fredericopissarra]

Se não há um padrão, não vejo problemas. Eu só reescreveria a coisa um pouquinho diferente:
 

// test.c
#include <stdio.h>
#include <stdlib.h>

// Note que isolei as rotinas de entrada e cálculo!

// Obtém tipo e quantidade. Retorna 1 se ok, 0 em caso de erro.
static _Bool getTypeQuant( unsigned int *type, unsigned int *quant )
{
  // Por quê fputs? Porquê é mais rápido do que printf() -- em alguns compiladores.
  fputs( "Tipo Quarto: ", stdout );
  fflush( stdout ); // stdout é "line buffered". Flushing pode ser necessário sem o '\n' final.

  // Note que verifico quantas conversões foram feitas aqui!
  if ( scanf( "%u", type ) != 1 )
    return 0;

  fputs( "Quantidade: ", stdout );
  fflush( stdout ); // stdout é "line buffered". Flushing pode ser necessário sem o '\n' final.

  if ( scanf( "%u", quant ) != 1 )
    return 0;

  return 1;
}

// Calcula a conta com base no tipo e quantidade.
// Retorna -1 se não pode calcular.
static double conta ( unsigned int type, unsigned int quant )
{
  double val = -1.0;  // Valor default, se não selecionado abaixo.

  switch ( type )
  {
    // Se não há um padrão nos fatores de escala, isso é um bom
    // jeito de fazer...
    case 101: val = 3.50 * quant; break;
    case 102: val = 5.00 * quant; break;
    case 103: val = 7.80 * quant; break;
    case 104: val = 5.00 * quant; break;
    case 105: val = 8.20 * quant; break;
    case 106: val = 6.40 * quant; break;
    case 107: val = 4.75 * quant; break;
    case 108: val = 3.60 * quant; break;
    case 109: val = 6.00 * quant; break;
    case 110: val = 4.30 * quant;
  }

  return val;
}

int main ( void )
{
  unsigned int type, quant;

  // Por quê 'double' ao invés de 'float'?
  // O formato %f de printf exige 'double'. 'float' é
  // automaticamente convertido para 'double'. Então evito essa
  // conversão automática usando o tipo certo.
  double val;

  // Note que passo os ponteiros aqui, mas não declaro objetos dentro de getTypeQuant().
  if ( ! getTypeQuant( &type, &quant ) )
  {
    fputs( "\nERRO ao tentar obter tipo e quantidade!\n"
           "Processo abortado.\n", stdout );

    return EXIT_FAILURE;
  }  

  val = conta ( type, quant );

  // Já que -1.0 é condição de erro...
  if ( val < 0.0 )
  {
    fputs ( "\nERRO ao calcular total da conta para tipo e quantidade fornecidos.\n", stderr );

    return EXIT_FAILURE;
  }

  printf ( "\nValor total da conta: R$ %.2f", val );

  return EXIT_SUCCESS;
}

[]s
Fred

[alan anderxon]

eu refiz aqui utilizando a funçao Double e mais coisas que aprendi durante a caminhada:

#include <stdio.h>
double tab(int val, int qnt){

  switch(val){
    case 101:
     return 3.50 * qnt;
    break;
     case 102:
     return 5.00 * qnt;
    break;
     case 103:
    return 7.80 * qnt;
    break;
    case 104:
     return 5.00 * qnt;
    break;
    case 105:
     return 8.20 * qnt;
    break;
    case 106:
   return 6.40 * qnt;
    break;
     case 107:
     return  4.75 * qnt;
    break;
     case 108:
     return  3.60 * qnt;
    break;
     case 109:
     return  6.00 * qnt;
    break;
     case 110:
    return  4.30 * qnt;
    break;
    default:
       return -1;
       break;
  }

}
int main(void) {
  int cod, quantidade;
  float valor, preco, total;
printf("codigo do produto: \n");
  scanf("%d", &cod);

  printf ("\nQuantidade: ");
    scanf ("%d", &quantidade);

   total = tab(cod, quantidade);

  printf ("\nCdogigo %d + quantidade: %d valor: R$ %.2f", cod, quantidade, total);
  return 0;
}

creio que tenha ficado bem melhor assim

Editado Novembro 16, 2022 em 23:07 por alan anderxon