x023.h

Go to the documentation of this file.

#pragma once

#include "x022.h"
#include <string>
#include <utility>
#include <vector>

namespace nmx::apps::x023 {

class UserInput
{
    using Value = std::pair<std::string, double>;

    //Zugriff auf die Eingabewerte
    enum Idx { x0, v0, a, time };

private:
    //Eingabe (Name,Wert),...
    std::vector<Value> _in;
    //Ausgabe (Name,Wert),...
    std::vector<Value> _out;

protected:
    double read(std::string &label) {
        double val;
        std::cout << label << "=?\t";
        std::cin >> val;
        //Fehler wenn val nicht vom Typ double ist
        if (std::cin.fail()) {
            throw std::invalid_argument(label);
        }
        return val;
    }

public:
    inline UserInput() {
        //Namen für Eingabevariablen werden initialisiert
        for (const auto label : { "x0", "v0", "a", "t1" }) {
            _in.push_back(Value{ label, 0 });
        }
        //Namen für Ausgabevariablen werden initialisiert
        for (const auto &label : { "x", "v", "s", "vbar" }) {
            _out.push_back(Value{ label, 0 });
        }
    }

    inline void calculate() {
        //Komponente zur Berechnung der Ergebnisse
        x022::Motion motion{ 1, _in[Idx::a].second, { _in[Idx::x0].second, _in[Idx::v0].second } };
        //Wertezuweisung
        double t1 = _in[Idx::time].second;
        _out[0].second = motion.x(t1);
        _out[1].second = motion.v(t1);
        _out[2].second = motion.distance(t1);
        _out[3].second = motion.vmean(t1);
    }

    inline void input() {
        for (auto &vals : _in) {
            vals.second = read(vals.first);
        }
        //letzte Eingabe: Zeit
        if (_in.back().second <= 0) {
            throw std::domain_error("time must be >0");
        }
    }

    inline void output() {
        std::cout << std::fixed << std::setprecision(2);
        std::cout << "------------output-------" << std::endl;
        //iteriere über Ausgabewerte (Name,Wert),...
        for (const auto &[label, val] : _out) {
            std::cout << label //
                      << "=" << val << std::setw(3) << "\t";
        }
        std::cout << std::endl;
    }

    inline void ui() {
        constexpr auto maxstreamsize = std::numeric_limits<std::streamsize>::max();
        try {
            // Eingabe -> Auswertung ->Ausgabe
            input();
            calculate();
            output();
        } catch (std::domain_error ex1) {
            //wenn negative Zeiten eingegeben werden
            //Fehlerbits werden zurückgesetzt,
            // sonst kann cin nicht mehr genutzt werden
            std::cin.clear();
            //verwerfe alle Zeichen bis \n
            std::cin.ignore(maxstreamsize, '\n');
            std::cerr << "input error:" << ex1.what() << std::endl;
        } catch (std::invalid_argument ex2) {
            //wenn statt Zahlen Buchstaben eingegeben werden
            std::cin.clear();
            std::cin.ignore(maxstreamsize, '\n');
            std::cerr << "input error for:" << ex2.what() << std::endl;
        }
    }

    inline void run() {
        char cmd = 'y'; // die Schleife soll wiederholt werden
        std::cout << "------------input-------------" << std::endl;
        while (cmd == 'y') {
            ui(); //starte Eingabe,Berechnung,Ausgabe
            do {
                std::cout << "new calculation? y[yes] / n[no]" << std::endl;
                std::cin >> cmd;
            } while (cmd != 'y' && cmd != 'n');
        }
    }
};

inline void ex1() {
    UserInput ui;
    ui.run();
}

} // namespace nmx::apps::x023