Czy da się ustalić przedział zmiennych?

Question

Witam wszystkich :D Tworzę program symulujący jazdę samochodu i zastanawiam się czy jest możliwość ustalenia przedziałów zmiennej int na np. <0;160> ponieważ potrzebuję tego do zmiennej aktualnaPredkosc która idąc w górę zatrzyma się na tej przykładowej 160.kody udostępniam w linkach :

-kod główny https://codeshare.io/5NKdKV

-nagłówki do klasy https://codeshare.io/50bonD

-klasa https://codeshare.io/G7Jypk

z góry dziękuję za pomoc :D

Answer 1

Proponuję utworzyć klasę dla prędkości (czy też szybkości, jeśli to ma być skalar). W ten sposób możesz kontrolować wartości jakie przyjmują obiekty oraz jednostki, w których prędkość jest wyrażana. Kiedy zdefiniujesz podstawowe operatory arytmetyczne będziesz miał bardzo wygodne narzędzie. Dodając własne literały dla jednostek zwiększysz czytelność kodu.

Comments

Napisałem przykładową implementację dla klasy szybkości. Nie jest doskonała (np. uzależnienie implementacji od konkretnego typu i jego interpretacji, pewne niedoskonałości w przekazywaniu argumentów, itd.) ale pokazuje, jak można definiować i używać klasy opisujące wartość jakiejś wielkości.

// Speed.hpp
#pragma once

#include <algorithm>
template <typename T>
T clamp(const T& n, const T& lower, const T& upper) // małe narzędzie do pomocy
{
    return std::max(lower, std::min(n, upper));
}

using speed_value_type = long double; // zdefiniowałem alias dla typu, który jest wykorzystany do przechowywania wartości predkości wewnętrznie w klasie Speed - wskazane jest utworzenie klasy szablonowej  zamiast takiego rozwiązania :)

class Speed
{
public:
    Speed(const Speed& s);
    Speed(speed_value_type value_m_per_s = 0.0);
    Speed(speed_value_type value_m_per_s, Speed limit); // zakładam że limit jest wartością ograniczającą wartość prędkości w przedziale <-limit; limit>
    Speed& operator=(const Speed & s); // tutaj trzeba poczynić pewne założenia: czy przypisanie innego obiektu typu Speed oznacza przejęcie z niego limitu prędkości? Ja zakładam, że przypisanie oznacza tylko przepisanie wartości z uwzględnieniem 'starego' limitu.

    Speed operator-() const;

    Speed operator+(const Speed &s) const;
    Speed operator-(const Speed &s) const;

    Speed& operator+=(const Speed &s);
    Speed& operator-=(const Speed &s);

    void set(const Speed &s);

    speed_value_type as_m_per_s() const;
    void as_m_per_s(speed_value_type value);

    speed_value_type as_km_per_h() const;
    void as_km_per_h(speed_value_type value);

    speed_value_type set_limit(Speed limit);
    void remove_limit();

private:
    speed_value_type value_m_per_s;
    bool limited;
    speed_value_type limit;

    void change_value_to(speed_value_type m_per_s);
};

Speed operator""_m_per_s(speed_value_type value);
Speed operator""_km_per_h(speed_value_type value);

// Speed.cpp
#include "Speed.hpp"

Speed::Speed(const Speed &s)
    :value_m_per_s{s.value_m_per_s},
     limited{s.limited},
     limit{s.limit}
{
}

Speed::Speed(speed_value_type value_m_per_s)
    :value_m_per_s{value_m_per_s},
     limited{false},
     limit{0.0}
{
}

Speed::Speed(speed_value_type value_m_per_s, Speed limit)
        :value_m_per_s{value_m_per_s},
         limited{true},
         limit{limit.as_m_per_s()}
{
}

void Speed::change_value_to(speed_value_type m_per_s)
{
    value_m_per_s = m_per_s;
    if(limited)
    {
        value_m_per_s = clamp(value_m_per_s, -limit, limit);
    }
}

void Speed::set(const Speed &s)
{
    change_value_to(s.value_m_per_s);
}

Speed &Speed::operator=(const Speed &s)
{
    change_value_to(s.value_m_per_s);
    return *this;
}

Speed Speed::operator+(const Speed &s) const
{
    return Speed{value_m_per_s + s.value_m_per_s};
}

Speed Speed::operator-(const Speed &s) const
{
    return Speed{value_m_per_s - s.value_m_per_s};
}

speed_value_type Speed::as_m_per_s() const
{
    return value_m_per_s;
}

void Speed::as_m_per_s(speed_value_type value)
{
    change_value_to(value);
}

speed_value_type Speed::as_km_per_h() const
{
    return value_m_per_s * 3.6;
}

void Speed::as_km_per_h(speed_value_type value)
{
    change_value_to(value / 3.6);
}

speed_value_type Speed::set_limit(Speed limit)
{
    auto old_limit = this->limit;
    this->limit = limit.as_m_per_s();
    limited = true;
    return old_limit;
}

void Speed::remove_limit()
{
    limited = false;
    limit = 0.0;
}

Speed &Speed::operator+=(const Speed &s)
{
    change_value_to(value_m_per_s + s.value_m_per_s);
    return *this;
}

Speed &Speed::operator-=(const Speed &s)
{
    change_value_to(value_m_per_s - s.value_m_per_s);
    return *this;
}

Speed Speed::operator-() const
{
    Speed s{*this};
    s.change_value_to(-s.value_m_per_s);
    return s;
}

Speed operator""_m_per_s(speed_value_type value)
{
    Speed s;
    s.as_m_per_s(value);
    return s;
}

Speed operator""_km_per_h(speed_value_type value)
{
    Speed s;
    s.as_km_per_h(value);
    return s;
}

// main.cpp
#include <iostream>
#include "Speed.hpp"

void print_speed(Speed s)
{
    std::cout<<"speed = "<<s.as_m_per_s()<<" [m/s] = "<<s.as_km_per_h()<<" [km/h]\n";
}

int main()
{
    print_speed(15.0_m_per_s);
    print_speed(15.0_km_per_h);

    Speed limited{0, 50.0_km_per_h};
    print_speed(limited);

    limited = 15.0_m_per_s;
    print_speed(limited);

    limited.set_limit(55.0_km_per_h);
    limited.as_m_per_s(15.0); // lub: limited.set(15.0_m_per_s);
    print_speed(limited);

    limited -= 5.0_m_per_s;
    print_speed(limited);

    Speed first = 2.0_km_per_h;
    Speed second = -3.0_km_per_h;
    limited = first + second;
    print_speed(limited);

    limited.remove_limit();
    limited.set(100); // niejawnie użyty konstruktor, który interpretuje wartość 100 jako m/s
    print_speed(limited);
    return 0;
}

Dyskusja mile widziana. :)

---

Wow O.o Szczerze powiedziawszy dopiero zaczynam zabawę z programowaniem obiektowym i średnio rozumiem kod, ale to dobrze bo będę musiał coś poszperać w internecie żeby zrozumieć :D dzięki wielkie :3

---

Super, cieszę się że chcesz samodzielnie dojść do sposobu działania i celowości tego, co napisałem. :) Jak będziesz mieć z czymś większy problem, pytaj.