Re: Properties with non standard C++ (REALLY SORRY ABOUT THAT)

In article <45d4d59d$0$19026$426a74cc@news.free.fr>, richom.v@free.fr
says...


A design with lots of accessors and mutators is usually a sign of a
problematic design -- you're usually better off fixing it than
facilitating it. In particular, this usually signals somebody who's
heard that public variables are bad, but hasn't grasped _why_ they're
bad, so he makes the variables themselves private, then then provides
public access to them via the get and set methods. The result is the
worst of all worlds -- the design is still one of public variables, and
all that's really changed is that the syntax has gotten really ugly.

The variables should be private because the interface should _usually_
be one of the class providing a higher-level abstraction, so clients do
NOT just get and set values. One basic principle is generally as "don't
ask -- tell". The idea is that code outside the class should NOT request
information about the class state before making a modification. e.g.
this would be bad:

some_class x;

if (x.getsomevalue() < 10)
    x.setsomeothervalue(12);

Instead, the class itself should contain that intelligence, and the
outside code should just do something like: x.dowhatever(12);

Occassionally, however, you run into something that really makes sense
with an interface with what at least look and act like public variables.
In this case, (at least IMO) get/set methods are the wrong way to go. If
you really want unrestricted access to these variables, then just make
the public. If your get/set methods really do something (typically
range-checking) to assure the values are valid, then you should create
something that looks and acts like a public variable, but gives you the
control you need (e.g. carries out the aforementioned range-checking).

Since range-checking is so common, I've written a small template that
implements it:

#include <exception>
#include <iostream>
#include <functional>

template <class T, class less=std::less<T> >
class bounded {
    const T lower_, upper_;
    T val_;

    bool check(T const &value) {
        return less()(value, lower_) || less()(upper_, value);
    }

    void assign(T const &value) {
        if (check(value))
            throw std::domain_error("Out of Range");
        val_ = value;
    }

public:
    bounded(T const &lower, T const &upper)
        : lower_(lower), upper_(upper) {}

    bounded(bounded const &init) { assign(init); }

    bounded &operator=(T const &v) { assign(v); return *this; }

    operator T() const { return val_; }

    friend std::istream &operator>>(std::istream &is, bounded &b) {
        T temp;
        is >> temp;

        if (b.check(temp))
            is.setstate(std::ios::failbit);
        else
            b.val_ = temp;
        return is;
    }
};

This would be used like:

struct X {
    bounded<int> x;
    bounded<int> y;

    X() : x(1, 100), y(0, 200) {}
};

and now code that uses these can simply treat x and y as public
variables (since they are) but you still have full control to assure
that only valid values are assigned to them. It's also possible to pass
the bounds as template parameters, so those would look like:

bounded<int, 1, 100> x;
bounded<int, 0, 200> y;

But this doesn't work for floating point ranges (OTOH, it has some
advantages, such as making different ranges different types, so
accidentally assigning from one to another is an error -- though an
explicit cast makes it possible when needed).

--
    Later,
    Jerry.

The universe is a figment of its own imagination.