Re: They ALL suck! [Was: On Java and C++]
In article <1146755237.231059.87100
@g10g2000cwb.googlegroups.com>, roberts.noah@gmail.com
says...
[ ... ]
Don't know if you meant to imply that C++ works that way but it
doesn't. "public" is not the default inheritance mode, private is.
In C++, private inheritance is the default for classes,
but public inheritance is the default for structs. Lots
of people routinely write:
class X : public Y {
public:
// ...
};
which is equivalent to:
struct X : Y {
// ...
};
Getters and Setters are another good example. Sure, the IDE can generate
them. But C#s properties are a lot more elegant. You can start with
simple public members and introduce getters and setters later without
any need to change the clients of the class.
Getters and Setters are just poor design indicating that perhapse a
class is not the best data type to represent your data or that your
classes are lazy.
Or that your variables aren't really of the correct type
to start with. From what I've seen, the majority of
getters and setters don't really do anything, and are
exactly equivalent to public data with a really ugly
syntax.
Of the (small) minority that really do something, most do
nothing more than enforce the variable being within a
fixed range (e.g. an integer restricted to the range
0..1024). Some languages (e.g. Ada) provide that
capability directly, and exposing the data publicly works
just fine, because the compiler enforces the constraint
without explicit help beyond the definition of the
variable's range.
Other languages (e.g. C++) have the flexibility to allow
the programmer to do the job by defining the correct type
for the variable in question, and enforcing its
constraints explicitly (but still centralizing the
enforcement). For the simple range constraint, for
example, you can write a small template like:
template <class T, T lower, T upper, class less=std::less
<T> >
class bounded {
T val;
static bool check(T const &value) {
return less()(value, lower) ||
less()(upper, value);
}
public:
bounded() : val(lower) { }
bounded(T const &v) {
if (check(v))
throw std::domain_error("out of range");
val = v;
}
bounded(bounded const &init) : val(init.v) {}
bounded &operator=(T const &v) {
if (check(v))
throw std::domain_error("Out of Range");
val = v;
return *this;
}
operator T() const { return val; }
friend std::istream &
operator>>(std::istream &is, bounded &b)
{
T temp;
is >> temp;
if (check(temp))
is.setstate(std::ios::failbit);
b.val = temp;
return is;
}
};
With this, we can make a data member public, keep (even
tighter) encapsulation, and still get nice syntax that's
easy to read and use. At least as it stands right now, I
don't see a way to do this in Java, but Java is close
enough now that I can imagine enough being added at some
point to support it...
--
Later,
Jerry.
The universe is a figment of its own imagination.