C++ Como limitar um valor inserido pelo endereço de memória da variável?

[cyer]

Como limitar um valor que foi inserido/alterado pelo endereço de memória?

 

PS: Eu não posso limitar pela função, essa função é apenas uma função de exemplo mostrando o problema, vou precisar passar esse objeto para funções de outras bibliotecas na qual eu não posso alterar.

#include <iostream>

template <typename type>
class Var
{
private:
    type Value               = (type)0;
    type ClampMin            = (type)0;
    type ClampMax            = (type)0;
    bool NeedClamp           = false;
public:
    Var()                                    { }
    Var(type initialVal) : Value(initialVal) { }
    Var(type initialVal, type Min, type Max)
    {
        this->NeedClamp = true;
        this->ClampMin = Min; this->ClampMax = Max;
        
        this->operator=(initialVal);
    }

    constexpr bool IsClampActive() const
    {
        return this->NeedClamp;
    }

    constexpr type Min() const
    {
        return this->ClampMin;
    }

    constexpr type Max() const
    {
        return this->ClampMax;
    }

    // Operador seguro pois consegue limitar os valores inseridos
    type& operator=(type val) noexcept
    {
        if (this->NeedClamp)
        {
            if (val > this->ClampMax)
                this->Value = this->ClampMax;
            else if (val < this->ClampMin)
                this->Value = this->ClampMin;
            else
                this->Value = val;
        }
        else
        {
            this->Value = val;
        }
        return this->Value;
    }

    // Para converter automaticamente o tipo
    // Não seguro
    // Como limitar o valor inserido nesse operador?
    operator type*()
    {
        return &this->Value;
    }

    // Para converter automaticamente o tipo
    // Não seguro
    // Como limitar o valor inserido nesse operador?
    operator type&()
    {
        return this->Value;
    }

    template <typename typeVal>
    constexpr bool operator==(typeVal val) const
    {
        return (this->Value == (type)val);
    }

    template <typename typeVal>
    constexpr bool operator!=(typeVal val) const
    {
        return (this->Value != (type)val);
    }
};

#define MIN_VALORTESTE                    1.f
#define MAX_VALORTESTE                    100.f

float problema(float& valor)
{
    valor = 200.f; // Vai alterar o valor para um valor maior que o limite definido(100.f), como limitar o valor inserido nesse caso?
    return valor;
}

int main()
{
    //Var<float> Valor_Teste = 50.f;
    Var<float> Valor_Teste = { /* Valor inicial da variável */ 50.f, /* Valor minimo permitido para a variável*/ MIN_VALORTESTE, /* Valor maximo permitido para a variável */ MAX_VALORTESTE };

    std::cout << problema(Valor_Teste) << std::endl;

    // Mostrando o novo valor da variável(vai mostrar um valor inválido, pois está maior que o limite definido(MAX_VALORTESTE))
    std::cout << Valor_Teste << std::endl;
    
    std::cin.get();

    return 0;
}