operadores ostream e istream

[Bunitao]

Bom Dia estou com o seguinte problema abaixo:

 

Faça com que horários (registro horário) possam ser lidos com cin, exibidos com cout e subtraídos com o operador de subtração, operator-(). O resultado da subtração deve ser um valor representando a diferença em minutos. Para simplificar, considere que os horários estão sempre dentro de um mesmo dia.

 

meu codigo ficou assim:

#include<iostream>


using namespace std;

struct horario {
    int hora;
    int minuto;

};

istream& operator>>(istream&, horario&);
ostream& operator<<(ostream&, horario);
horario operator-(horario, horario);

int main() {
    horario h1, h2;
    cin >> h1;
    cin >> h2;
    cout << (h1 - h2);


}


istream & operator>>(istream & is, horario& tempo){
    char ponto =':';
    is >> tempo.hora;
    is >> ponto;
    is  >> tempo.minuto;
    

    return is;
}

ostream & operator<<(ostream & os, horario tempo)
{
     os << tempo.hora;
     
     os << tempo.minuto;
        

       
    return os;
}

horario operator-(horario h1, horario h2){
     
    
    horario tempo; 
    tempo.hora = (h2.hora - h1.hora) * 60;
    tempo.minuto = h2.minuto - h1.minuto;
    tempo.minuto += tempo.hora;
    tempo.hora = 0;
     return tempo;

}

 

 

 

mas não consigo chegar na saida que o problema pede, por exemplo 09:30 às 09:45 (15 min), minha saida fica 015 ao invés de 15 

tambem ao mostrar os horarios, por exmplo 09:30, aparece 09:3

 

alguém poderia me ajudar?

 

grato

[fredericopissarra]

Não está perfeito e nem mesmo sei se está "certo"... O detalhe é que entrada formatada por std::basic_istream não funciona como um scanf, você é quem tem que verificar o formato. Eis um exemplo rápido pra sua avaliação:

#include <cstdlib>
#include <iostream>
#include <string>
#include <sstream>
#include <iomanip>
#include <exception>

struct horario
{
  int hora;
  int minuto;

  // Só para garantir valores válidos.
  horario ( int h = 0, int m = 0 )
    : hora ( h ), minuto ( m ) {}

  bool operator<( const horario& );

  // Crie o seu operador - aqui para retornar um horario como diferença.
};

bool horario::operator<( const horario& rhs )
{ int m = hora*60 + minuto; return m < ( rhs.hora*60 + rhs.minuto ); }

static std::ostream& operator<<( std::ostream& os, const horario& h )
{
  std::stringstream ss;

  ss << std::setw(2) << std::setfill('0') << h.hora << ':' << h.minuto;
  os << ss.str();
  return os;
}

static std::istream& operator>>( std::istream& is, horario& h )
{
  std::string s;
  std::string::size_type n;

  is >> s;

  n = s.find( ':' );

  if ( n == std::string::npos )
    throw std::range_error( "Invalid format" );

  h.hora = std::stoi( s.substr( 0, n ) );
  h.minuto = std::stoi( s.substr( n + 1 ) );

  // Porque 60 no limite superior? Porque leap seconds devem ser considerados em horários!
  if ( h.minuto < 0 || h.minuto > 60 )
    throw std::range_error( "Invalid format" );

  return is;
}

// Escolhi que o operator -, quando usando duas referências a horario, deve retornar uma string.
static std::string operator-( const horario& lhs, const horario& rhs )
{
  int h, m;
  static const char *sigs[2] = { "", "-" };
  bool negative = false;

  h = lhs.hora - rhs.hora;
  m = lhs.minuto - rhs.minuto;

  m += 60*h;
  if ( m < 0 )
    negative = true;

  h = abs( m / 60 );
  m = abs( m % 60 );

  std::stringstream ss;

  ss << sigs[negative] << std::setw(2) << std::setfill('0') << h << ':' << m;

  return ss.str();
}

int main()
{
  horario h1, h2;

  std::cin >> h1;
  std::cin >> h2;

  if ( h2 < h1 )
  {
    std::cerr << "Primeiro horário precisa ser menor ou igual ao segundo.\n";
    return 1;
  }

  std::cout << "Diferença: " << h2 - h1 << '\n';

  return 0;
}

[]s
Fred