Re: Polymorphic abstract base class with operator=3D=3D or e= quivalen= t functionality; design considerations
On 22 Sep., 06:31, BanMido <smartrefere...@gmail.com> wrote:
[..]
Second, I have only seen *rare* cases, where
a virtual operator==/!= makes sense and I
would always ensure that these are const
functions.
So, if your really want this, I suggest to
provide a single virtual function like this:
virtual bool is_equal_to(const IString&) const = 0;
and *possibly* (but not necessarily) the following
two non-member functions:
};
inline bool operator==(const IString& lhs, const IString& rhs) {
return lhs.is_equal_to(rhs);
}
inline bool operator!=(const IString& lhs, const IString& rhs) {
return !(lhs == rhs);
Yes, what I basically want is that the IString interface to guarantee
that all its implementers will provide a way to check for equality
among their objects.
The syntactic sugar provided by operator overloading is not really
necessary.
So, for that specific purpose, does my approach seem reasonable?
If your code is intended to work through dynamic polymorphism
this is probably a reasonable approach, assuming you make
operator== and operator!= non-virtual as shown above. The question
arises, whether you really need and want that. An alternative
approach would be to provide functionality based on templates, in
this case you could write your code using == and/or != and define
the precondition that both operators shall exist and what the
expected semantics are.
Don't forget to define the required semantics on == and != in
either case! People that have to implement a dozen of functions
without specified semantics tend to provide "dummy" implementations
as you originally did. It is IMO an essential design quality of an
API that it precisely defines requirements for customization
points. Among others, "boost" belongs to such high-quality
libraries.
HTH & Greetings from Bremen,
Daniel Kr?gler
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]