Re: generic NULL / INVALID extension for class
James Kanze wrote:
On 11 mar, 18:59, Kai-Uwe Bux <jkherci...@gmx.net> wrote:
Frank Bergemann wrote:
i remember to have read about how to extend existing classes
(in a generic way), so they provide some NULL or INVALID
"instance" (e.g). This then can be used e.g. by factories,
which per definition return an instance of kind of object
they are dedicated for. But in some cases, factory might
not be able to create a correct object.
For such there was a way to return dedicated instances,
which indicate conditions like NUL/nil/INVALID. So they can
be compared with result of factory.
E.g. as Class::Invalid or Class::NULL:
All this in order to do without exceptions to indicate back NULL/nil/
INVALID for this.
And to do without boost::optional or boost::variant as another option.
Can s.o. gimme a reference (book, web) to solution for that?
I usually use a "box" container for that. A box<T> can be
empty or hold exactly one element of type T. The empty state
represents NULL/nil/INVALID, but you also want to define
std::less< box<T> > so that the empty box is greater than any
non-empty box so that the state also represents infinity. I
found that simple container to be amazingly useful.
That sounds somewhat similar to the Fallible idiom, popularized
by Barton and Nackman many years ago.
If only I knew more, I wouldn't have to reinvent things over and over again.
(In my own work, I've
extended it to support a multi-valued error code.) I'm not sure
it's quite the same thing, though---at least in Fallible, the
object had to be default constructible, because there always was
an instance of the object, regardless. (The idea had occured to
me to implement it so that this requirement wasn't present, but
in practice, I've never found it to be a problem, so I haven't
bothered.)
Well, my code started with this prototype. The real version uses an
allocator (and also implements the comparison operators as free-standing
functions):
template < typename T >
struct box;
template < typename T >
void swap ( box<T> &, box<T> & );
template < typename T >
struct box {
typedef T value_type;
typedef value_type * pointer;
typedef value_type const * const_pointer;
typedef value_type & reference;
typedef value_type const & const_reference;
private:
friend void swap<> ( box &, box & );
pointer ptr;
public:
box ( void )
: ptr ()
{}
box ( value_type const & value )
: ptr ( new value_type ( value ) )
{}
box ( box const & other )
: ptr ( other.empty()
? 0
: new value_type ( other.item() ) )
{}
~box ( void ) {
this->clear();
}
box & operator= ( box const & other ) {
box dummy ( other );
swap( *this, dummy );
return( *this );
}
bool empty ( void ) const {
return ( this->ptr == 0 );
}
bool has_item ( void ) const {
return ( ! this->empty() );
}
bool has_item ( value_type const & t ) const {
return ( ! this->empty() && ( this->item() == t ) );
}
void clear ( void ) {
delete ( ptr );
ptr = 0;
}
void insert ( value_type const & value ) {
box dummy ( value );
swap( *this, dummy );
}
const_reference item ( void ) const {
assert( ! this->empty() );
return( *ptr );
}
reference item ( void ) {
assert( ! this->empty() );
return( *ptr );
}
bool operator== ( box const & other ) const {
if ( this->empty() ) {
return( other.empty() );
}
if ( other.empty() ) {
return( false );
}
return( this->item() == other.item() );
}
bool operator!= ( box const & other ) const {
return( ! this->operator==( other ) );
}
bool operator< ( box const & other ) const {
if ( this->empty() < other.empty() ) {
return( true );
}
if ( this->empty() ) {
return( false );
}
return( this->item() < other.item() );
}
bool operator<= ( box const & other ) const {
return( ! ( other < *this ) );
}
bool operator> ( box const & other ) const {
return( other < *this );
}
bool operator>= ( box const & other ) const {
return( other <= *this );
}
}; // struct box<>
template < typename T >
void swap ( box<T> & a, box<T> & b ) {
std::swap( a.ptr, b.ptr );
}
template < typename T >
std::ostream & operator<< ( std::ostream & ostr, box< T > const & b ) {
if ( b.empty() ) {
ostr << '#';
} else {
ostr << "[ " << b.item() << " ]";
}
return( ostr );
}
template < typename T >
std::istream & operator>> ( std::istream & istr, box< T > & b ) {
char chr;
istr >> chr;
if ( chr == '#' ) {
b.clear();
return( istr );
}
if ( chr == '[' ) {
typename box<T>::value_type val;
if ( istr >> val ) {
istr >> chr;
if ( chr == ']' ) {
b.insert( val );
return( istr );
}
}
}
istr.setstate( std::ios_base::failbit );
return( istr );
}
The dynamic allocation does not require T to be default constructible. I
mostly use it to add a formal infinite value to a type that supports
ordering (I rarely have use for error codes).
Alternatively, one can implement box<T> based on pair<bool,T>.
Best
Kai-Uwe Bux