Zmienna która posiada czas modyfikacji oraz czas ważnosci

W GUI wyświetlam dwie zmienne np. valueMhz, valueVCC
jeżeli coś zmieni wartość to chciałbym przez 5s inaczej wyświetlić te zmienne np. kolorem czerwonym

Czy taki koncept to dobry kierunek zamiast prostej zmiennej używać struktury aby mieć czas do kiedy GUI ma zaznaczyć zmienną

https://godbolt.org/z/EjEGK5z9Y

// https://godbolt.org/z/EjEGK5z9Y
#include <fmt/chrono.h>
#include <chrono>
#include <thread>

// Integer + czas modyfikacji + czas do kiedy ważny  
class IntWithTime
{
 private:
    int m_int;
    std::chrono::system_clock::time_point m_timeModification;
    std::chrono::system_clock::time_point m_timeValid;
 public:
    void set(int newInt){
        m_int = newInt;  
        m_timeModification = std::chrono::system_clock::now();
        m_timeValid = m_timeModification + std::chrono::seconds(5);
    }  
    int get(){return m_int;}  

    std::chrono::system_clock::time_point getTimeModification()
    {
        return m_timeModification;
    }
    std::chrono::system_clock::time_point getimeValid()
    {
        return m_timeValid;
    }
};

class Foo
{
public:
    Foo(){
        fmt::print("Foo::Foo()\n");
    }    
    ~Foo(){
        fmt::print("Foo::~Foo()\n");
    }    

    IntWithTime valueMhz;
    IntWithTime valueVCC;
};


int main()
{
    std::shared_ptr<Foo> foo = std::make_shared<Foo>();

    foo->valueMhz.set(1234);
    fmt::print("valueMhz modification:{} valid:{} \n", foo->valueMhz.getTimeModification(), foo->valueMhz.getimeValid()  );

    std::this_thread::sleep_for(std::chrono::milliseconds(2000));

    foo->valueVCC.set(19);
    fmt::print("valueVCC:{} valid:{} \n", foo->valueVCC.getTimeModification(), foo->valueVCC.getimeValid()  );

    // spdlog::shutdown();
}

@Marius.Maximus:

Mi się podoba.
Kilka razy stawiałem na gruncie C# / javy z podobnymi zagadnieniami.
Ja bym klasę uczynił uniwersalną, teplejtując typ zmiennej. w C++ czy C# bym zrobił bardziej natywny seter (w C++ operator), w Javie brak eleganckich syntaxów.

Lub bym mocno pociągnął jakiś nad-inżynierowany map, zyskując np kwerendę "hej, podaj mi zmienne wg czasu" (nie odniósł byś korzyści z tego w GUI???) - idea dalece nawiązuje do garażowej implementacji Cache

Imo w tej strukturze brakuje logiki, która by dyktowała, czy zmienna się niedawno zmieniła. Więc coś postaci:

class IntWithTime {
  // ...
  bool recently_modified() const {
    return std::chrono::system_clock::now() < m_timeValid;
  }
};

template<int S> class IntWithTime
{
 private:
    int m_int;
    std::chrono::system_clock::time_point m_timeValid;
 public:
    void IntWithTime(int newInt):m_int(newInt),m_timeValid(std::chrono::system_clock::now()+std::chrono::seconds(S)) {}  
    int get()const { return m_int; }
    std::chrono::system_clock::time_point getimeValid()const { return m_timeValid; }
    bool recently_modified() const { return std::chrono::system_clock::now()<m_timeValid; }
};

Moim zdaniem to niepotrzebne pomieszanie logiki z danymi i nadmierne komplikowanie sprawy. Zgaduję, że dane i tak przychodzą z osobnego, pomiarowego wątku jako typ prosty, potem ustawiasz to w swoim pośrednim typie i dopiero potem logika wyświetlania używa tej całej konstrukcji? IMHO logika, którą opisałeś nie jest warta tworzenia całego osobnego typu tylko po to, by to obsłużyć, jest na tyle prosta, że zasługuje co najwyżej na swoją własną funkcję, która zwraca przykładowo kolor jaki ma być użyty, w przestrzeni bytu, który obsługuje wyświetlanie.