Re: Any dot-operator proposals out there?
Patrik Kahari wrote:
This particular use case is not convincing because the access to the
static count should probably happen through a static function.
Agreed, the example was no good because the wrapper only added a
static interface. I do belive there are other valid examples. I'll
have another try;
Say you make a "copy on write" wrapper class. The wrapper behaves like
the wrapped object, the only difference is that the actual wrapped
object (that you moved/copied onto the heap) can be shared by many
wrappers. When a wrapper object is copy constructed the destination
will only get a shallow copy, a full deep copy is delayed until
needed. A deep copy will be needed when the wrapped object is written
to or when its address is taken.
Hm, I have doubts that a cow_wrapper is capable of making wise decisions on
when to issue a deep copy. Consider the following basic implementation
(using operator-> to forward calls):
#include <iostream>
#include <tr1/memory>
struct X {
void print ( void ) {
std::cout << "non-const\n";
}
void const_print ( void ) const {
std::cout << "const\n";
}
};
template < typename T >
class cow_wrapper {
typedef T value_type;
typedef value_type & reference;
typedef value_type const & const_reference;
typedef value_type * pointer;
typedef value_type const * const_pointer;
mutable
std::tr1::shared_ptr< value_type > the_ptr;
void make_unique ( void ) {
std::cout << "deep copy\n";
std::tr1::shared_ptr< value_type > new_ptr
( new value_type ( *the_ptr ) );
the_ptr = new_ptr;
}
public:
explicit
cow_wrapper ( const_reference val = value_type() )
: the_ptr ( new value_type ( val ) )
{}
// other methods omitted.
// using operator-> instead of dot-operator:
pointer operator-> ( void ) {
make_unique();
return ( the_ptr.operator->() );
}
const_pointer operator-> ( void ) const {
return ( the_ptr.operator->() );
}
};
int main ( void ) {
cow_wrapper<X> x;
x->const_print();
}
Running this, you will find that a deep copy is done although we just call a
const member function (so that in principle no writing should happen). The
key problem is that operator-> cannot look ahead and detect whether the
called member a const method. Whether const or non-const operator-> is
called is determined by whether the wrapper object is const or non-const.
The wrapper interface could then be
extended to allow the user to force a deep copy (on a per object
basis, as in not on a static class basis). Why would that be useful?
Say the client enters some part of his system that has multiple
threads using these objects. The user wants to make sure that the two
wrappers dont share any internal data before entering so that he wont
have to do any syncing between the two objects.
Or say that at certain times the clients system has to be fast, and at
other times the system waits around doing nothing. The user could then
use this idle time to do deep copying so that the system wont be
forced to do that the next time the system is under time preassure.
I hope this example makes better sense than the previous one.
Sure does. You seem to think of a member function within the wrapper class
like
deep_assign ( cow_wrapper const & other );
However, I do not see the need for such a member function. Here is how I
would go about this problem:
#include <iostream>
#include <tr1/memory>
struct X {};
template < typename T >
class cow_wrapper {
typedef T value_type;
typedef value_type & reference;
typedef value_type const & const_reference;
typedef value_type * pointer;
typedef value_type const * const_pointer;
mutable
std::tr1::shared_ptr< value_type > the_ptr;
void make_unique ( void ) {
std::cout << "deep copy\n";
std::tr1::shared_ptr< value_type > new_ptr
( new value_type ( *the_ptr ) );
the_ptr = new_ptr;
}
public:
friend
cow_wrapper deep ( cow_wrapper const & other ) {
cow_wrapper result ( other );
result.make_unique();
return ( result );
}
explicit
cow_wrapper ( const_reference val = value_type() )
: the_ptr ( new value_type ( val ) )
{}
// rest omitted
};
int main ( void ) {
cow_wrapper<X> x;
cow_wrapper<X> y ( x );
cow_wrapper<X> z ( y );
z = y;
z = x;
z = deep( x ); // as opposed to: z.deep_assign( x );
cow_wrapper<X> a ( deep( x ) );
}
The user would just say deep( ... ) whenever a deep copy or deep assignment
is needed. Note that this also allows a deep copy-constructor call, as
opposed to:
cow_wrapper<X> a;
a.deep_assign( x );
Best
Kai-Uwe Bux
---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:std-c++@ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html ]