Czas - formatowanie wyjścia

Witam mam problem z programem dotyczącym czasu, nie mogę sformatować wyjścia :

#include <iostream>

using namespace std;
class czas{
private:
   int godzina;
   int minuta;
public:
//czas();
czas(int h,int m){
godzina=h%24;
minuta=m%60;
}
void dodaj(int m){
minuta+=m;
godzina+=minuta/60;
minuta=minuta%60;
godzina=godzina%24;
}
int podajczas(){

cout<<godzina/10<<godzina%10<<":"<<minuta/10<<minuta%10<<endl;
}
};




int main()
{   char tmp[5];
    cin>>tmp;
    czas x((((int)tmp[0]-48)*10+(int)tmp[1]-48),(((int)tmp[3]-48)*10+(int)tmp[4]-48));
    int y,i=0;
    int tab[100];
    while(cin>>y){
        x.dodaj(y);
     tab[i]=x.podajczas();
        i++;
    }




    return 0;
}

Tak wygląda kod, lecz nie wiem jak zmienić sposób wprowadzania danych, muszę zrobić aby było tak:
21:14
15
10
14

Wyjście 53
W jaki sposób to policzyć?

Ja mam wszystko na nie.

Zmiatanie overflołów pod dywan, zakres odpowiedzialności klas, magiczne stałe, zbędne elementy wynikające z nieznajomości języka, main() który nie wiadomo co ma pokazywać.
Nawet nie chce mi się ułożyć moich własnych zarzutów w kategoriach.

Zacznij od formatowania kodu, potem przejdź do wyjścia. Takiego bloba to się czytać nie chce.

Implementacja po to jest prywatna, abyś miał wolność JAK to zrobisz.
Jeśli dwa pola uwierają (a chyba tak), to możesz zmienić prywatną implementację na jedno pole MINUTY, w interpretację dwupolową (godziny / minuty 0-59) zrobić tylko na wyjściu.

UPDATE:
nie napisałem na liście zarzutów, że chyba nazwa klasy kłamie.
Więc to jest "obiektywny czas z zegarka" czy "różnica czasu, delta, odstęp"

#include <iostream>

using namespace std;
class roznica_czasu{
private:
   int godzina;
   int minuta;
public:
//czas();
    roznica_czasu(int h,int m){
    godzina=h%24;
    minuta=m%60;
    }
    void dodaj(int m){
        minuta+=m;
        godzina+=minuta/60;
        minuta=minuta%60;
        godzina=godzina%24;
        }
    int podajczas(){
        cout<<godzina/10<<godzina%10<<":"<<minuta/10<<minuta%10<<endl;
}
};




int main()
{   char tmp[5];
    cin>>tmp;
    roznica_czasu x((((int)tmp[0]-48)*10+(int)tmp[1]-48),(((int)tmp[3]-48)*10+(int)tmp[4]-48));
    int y,i=0;
    int tab[100];
        while(cin>>y){
            x.dodaj(y);
            x.podajczas();
            i++;
            }



    return 0;
}

Trochę poprawiłem formatowanie, kod działa i chciałbym go zostawić w tej formie, tylko nie mam pojęcia jak poprawić dane wyjściowe

#include <iostream>

using namespace std;
class roznica_czasu {
private:
    int godzina;
    int minuta;

public:
    //czas();
    roznica_czasu(int h, int m)
    {
        godzina = h % 24;
        minuta = m % 60;
    }
    void dodaj(int m)
    {
        minuta += m;
        godzina += minuta / 60;
        minuta = minuta % 60;
        godzina = godzina % 24;
    }
    int podajczas()
    {

        cout << godzina / 10 << godzina % 10 << ":" << minuta / 10 << minuta % 10 << endl;
    }
};

int main()
{
    char tmp[5];
    cin >> tmp;
    roznica_czasu x((((int)tmp[0] - 48) * 10 + (int)tmp[1] - 48), (((int)tmp[3] - 48) * 10 + (int)tmp[4] - 48));
    int y, i = 0;
    int tab[100];
    while (cin >> y) {
        x.dodaj(y);
        x.podajczas();
        i++;
    }

    return 0;
}

Zamiast męczyć się, skorzystaj z już istniejących bibliotek np. chrono
Możesz to przecież napisać w prostszy sposób:

#include <iostream>
#include <iomanip>
#include <ctime>
#include <chrono>

using namespace std;

struct timef
{
    int hours {0};
    int minutes {0};
    int seconds {0};

    timef( int hours_ , int minutes_ , int seconds_ )
    : hours {abs(hours_)%24} , minutes {abs(minutes_)%60} , seconds {abs(seconds_)%60}
    {}

    operator chrono::system_clock::time_point()
    {
       chrono::system_clock::time_point set_time_point {chrono::seconds(hours*60*60+minutes*60+seconds)};
       return set_time_point;
    }
};


class TimeManager
{

private:

    chrono::system_clock::time_point time_point {chrono::system_clock::now()};

public:

    TimeManager() = default;
    TimeManager( chrono::system_clock::time_point time_point_ ): time_point {time_point_} {}

    TimeManager& operator=( chrono::system_clock::time_point time_point_ )
    {
       time_point = time_point_;
       return *this;
    }

    template< typename T >
    TimeManager operator+( T value )
    {
        TimeManager tm {time_point};
        tm.time_point += value;
        return tm;
    }

    friend ostream& operator<<( ostream& os , const TimeManager& tm )
    {
        time_t time = chrono::system_clock::to_time_t(tm.time_point);
        os << "Time is = " << put_time(gmtime(&time), "%H:%M:%S") << '\n';
        return os;
    }
};

int main()
{
    TimeManager time {timef{5,20,21}};

    cout << time;
    cout << time + 120s;
    cout << time + 30min;
    cout << time + 1h;

    time = time + 12min;
    cout << time;

    time = timef{21,13,51};
    cout << time;
}

mikko napisał(a):

Trochę poprawiłem formatowanie, kod działa i chciałbym go zostawić w tej formie, tylko nie mam pojęcia jak poprawić dane wyjściowe

Potrafię uwierzyć, że input (wejście) bywa trudny, mogą być dopasowania się do wymogów wymagające chwili zatrzymania i pomyślenia.

Ale output po prostu się siada, i się robi. Dostałeś we własnych wątkach sporo ciekawego i prawidłowego kodu nt wyjścia. Nie mam pojęcia, jakie w tym mogą być problemy.

Jakie masz cele i jakie próby robiłeś?

Program pięknie działa, ale nadal jest ten sam problem co u mnie Wejście: 23:47 15 12 10 Wyjście: 23:47 00:02 00:14 00:24 - mikko 30 minut temu

Arytmetyka w dodaj() wywołuje moją niepewność i bezradność.. A racjonalność nie chce tego czytać. Właśnie wyznałem to psychoanalitykowi.

Moja propozycja już padła: przejście na jedną liczbę (minut / sekund, obojętne), i zrobienie extra geterów do godzin i minut. Dla intelektualnej uczciwości geter do dób.
(Tylko nie myśleć o d..ch, ciurlać wam się zachciewa)

TomaszLiMoon napisał(a):

cout << time + 120s;

Tomasz, ten literał mnie (pozytywnie) męczy.
Widziałem coś podobnego w Groovym (jest to częścią oficjalnej dokumentacji), ale tam jest pisownia 30.min (czyli mówiąc po cplusowemu przeciążenie operatora kropka).
Jakie są podstawy, że to w ogóle jest legalne? Bo widzę, że jest.
MSVC wymagało dodania #define _CRT_SECURE_NO_WARNINGS ale bez związku z pytaniem, na gmttime

Jakie są podstawy, że to w ogóle jest legalne?

Od C++11 są dostępne user-defined literals. Ja skorzystałem z już predefiniowanych w bibliotece <chrono>.

```cpp <- dawaj to przy wklejaniu kodu to będzie numeracja w poście i precyzyjniej ktoś może wskazać błąd

zamiast robić jakieś modulo i dzielenia przy wyświetlaniu, przekaż manipulatory do strumienia:

#include <iomanip>
    int podajczas() {
        cout << setw(2) << setfill('0') << godzina << ':'
             << setw(2) << setfill('0') << minuta << endl;

poza tym ten kod się nie kompiluje int podajczas() nie ma returna, więc mówisz o działającym kodzie a pokazujesz inną wersję

Jeżeli chodzi o formatowanie kodu to chyba tylko notatnik tego nie ma. Jest AStyle, a przy instalacji clang dodatkowo dostajemy clang-format w pakiecie, więc wystarczy clang-format -i -style=google main.cpp i gotowe. Wklejanie niesformatowanego kodu to trochę jak pójście do dentysty z nieumytymi zębami.

Jak program jest interaktywny to trzeba użytkownika informować co się od niego oczekuję. Uruchomiłem go, zobaczyłem czarny ekran i nie wiem czy się zawiesił, czy ostro pracuje? Jakiś prompt musi być, chciałbym widzieć coś w tym stylu:

Podaj czas (HH:MM):
23:45
ok, podano czas 23:45
podaj roznice czasu w minutach:
16
ok, podano 16, biezacy czas 23:45, roznica 00:01

EDIT:
odczytanie z wejścia czasu można zrobić trochę inaczej i pozbyć się tego potworka w mainie:

    string input;
    cin >> input;

    stringstream ss(input);

    int godzina;
    char separator;
    int minuta;

    ss >> godzina >> separator >> minuta;

    roznica_czasu x(godzina, minuta);

#include <iostream>
#include <iomanip>

using namespace std;
class roznica_czasu {
private:
    int godzina;
    int minuta;

public:
    // czas();
    roznica_czasu(int h, int m)
    {
        godzina = h % 24;
        minuta = m % 60;
    }
    void dodaj(int m)
    {
        minuta += m;
        godzina += minuta / 60;
        minuta = minuta % 60;
        godzina = godzina % 24;
    }
    int podajczas()
    {
        cout << setw(2) << setfill('0') << godzina << ':' << setw(2) << setfill('0')
             << minuta << endl;
    }
};

int main()
{
    int tmp;
    string input;
    cin >> input;

    stringstream ss(input);

    int godzina;
    char separator;
    int minuta;

    ss >> godzina >> separator >> minuta;

    roznica_czasu x(godzina, minuta);

    int y, i = 0;
    int tab[100];
    while (cin >> y) {
        x.dodaj(y);
        i++;
        ;
    }
    cout << input << endl;
    x.podajczas();
    return 0;
}

Teraz już mam w ładniejszy sposób wczytywanie oraz wyświetlanie czasu, jak mogę przechwycić poszczególne godziny pomiędzy operacjami, aby móc wszystkie później wypisać ?

przed while stwórz sobie vector<roznica_czasu> etapy, a w pętli po uaktualnieniu czasu o wczytane minuty dodaj etap do wektora etapy.push_back(x). Wyświetlenie później etapów będzie banalnie proste:

for (auto etap : etapy) {
    etap.podajczas();
}

Zastanów się nad zmianą roznica_czasu na np. po prostu Czas, poza tym klasy zwykle zaczyna się z dużej litery. Zamiast podajczas zastosuj przeciążenie operatora <<. Metoda dodaj(int) może lepiej żeby się nazywała dodajMinuty, albo powinna akceptować jako parametr nie int a np. obiekt typu Minuty.

Niestety takie błedy sypie

Kod aktualnie wygląda tak:

#include <iostream>
#include <iomanip>
#include <vector>

using namespace std;

class roznica_czasu {
private:
    int godzina;
    int minuta;

public:
    // czas();
    roznica_czasu(int h, int m)
    {
        godzina = h % 24;
        minuta = m % 60;
    }
    void dodaj(int m)
    {
        minuta += m;
        godzina += minuta / 60;
        minuta = minuta % 60;
        godzina = godzina % 24;
    }
    int podajczas()
    {
        cout << setw(2) << setfill('0') << godzina << ':' << setw(2) << setfill('0')
             << minuta << endl;
    }
};

int main()
{
    int tmp;
    string input;
    cin >> input;

    stringstream ss(input);

    int godzina;
    char separator;
    int minuta;

    ss >> godzina >> separator >> minuta;

    roznica_czasu x(godzina, minuta);

    int y, i = 0;
    int tab[100];

    vector<roznica_czasu> etapy;
    while (cin >> y) {
        x.dodaj(y);
        etapy.push_back(x);
        i++;
    }
    cout << input << endl;
    for (auto etap : etapy) {
        etap.podajczas();
    }
    return 0;
}

#include <sstream>

dziękuję za rady, już prawie jest zamierzony efekt, niestety krzyczy odnośnie roznica_czasu

    for (vector<roznica_czasu>::iterator it = etapy.begin(); it != etapy.end(); ++it) {
        it->podajczas();
    }

albo dodaj do opcji kompilacji -std=c++11 lub c++14 a nawet c++17

nie wklejaj obrazków, wystarczy tekst skopiować z konsoli. Pokaż ostateczny kod bo nie jestem jasnowidzem, jedynie co mogę teraz napisać to "u mnie działa"

#include <iostream>
#include <iomanip>
#include <vector>

using namespace std;

class roznica_czasu {
private:
    int godzina;
    int minuta;

public:
    // czas();
    roznica_czasu(int h, int m)
    {
        godzina = h % 24;
        minuta = m % 60;
    }
    void dodaj(int m)
    {
        minuta += m;
        godzina += minuta / 60;
        minuta = minuta % 60;
        godzina = godzina % 24;
    }
    int podajczas()
    {
        cout << setw(2) << setfill('0') << godzina << ':' << setw(2) << setfill('0')
             << minuta << endl;
    }
};

int main()
{
    int tmp;
    string input;
    cin >> input;

    //stringstream ss(input);

    int godzina;
    char separator;
    int minuta;

   // ss >> godzina >> separator >> minuta;

    roznica_czasu x(godzina, minuta);

    int y=0, i = 0;
    int tab[100];

    vector<roznica_czasu> etapy;
    while (cin >> y) {
        x.dodaj(y);
        etapy.push_back(x);
        i++;
    }
    cout << input << endl;
   for (vector<roznica_czasu>::iterator it = etapy.begin(); it != etapy.end(); ++it) {
        it->podajczas();
    }
    return 0;
}