Re: Defining a cast on a templated class
On Nov 15, 5:32 am, Michael DOUBEZ <michael.dou...@free.fr> wrote:
alan a =E9crit :
On Nov 14, 9:59 pm, Michael DOUBEZ <michael.dou...@free.fr> wrote:
inline T get_value()const{ return value();}
I suppose the above call can be turned into:
inline operator T ()const{ return value();}
Yes.
Hmm. I'm not 100% sure of its effects though, especially since I also
want to do lazy evaluation of something like:
cell<int> v = other + 42;
The whole point of using boost::function is to provide lazy evaluation.
From a basic analysis (correct me if I'm wrong) it seems that the
value is computed only when referenced (and is recomputed each time
it's referenced). Is this correct?
The value is computed only when deferenced.
There are some issue in the code I gave with consts being copied rather
than referenced. This would be solved with a counted body + composite
implementation that I mentionned.
A quick hack would be to use shared_ptr<function0<T> > instead.
Dang, and I was going to implement some crazy updating code for
this...
Anyway I recently learned that ?: can't be overloaded, so I'll have to
do some other crazy things in order to handle conditionals. If ! can
be overloaded like the above (such that !!(foo) returns either 1 or 0,
regardless if foo is 0, 1, 42, or 1838596) possibly I can simply
create a function like so:
template<class T>
cell<T> num_if(cell<T> c, cell<T> t, cell<T> e){
return !!(c) * t + !(c) * e;
}
I don't understand your funtion. You want to do a lazy selector of cel=
l ?
Yes, lazy selector.
This the implmentation I gave:
template<typename B,class T>
cell<T>& selector(B& b, cell<T>& if_true, cell<T>& if_false)
{
return b?if_true:if_false;
}
And then
template<typename B,class T>
cell<T> select(B& b, cell<T>& if_true, cell<T>& if_false)
{
//suposing cell has a constructor from function0<T>
return cell<T>(boost::bind(selector<B,T>,
boost::ref(b),
boost::ref(if_true),
boost::ref(if_false)));
}
....Mmm, suppose B is itself is a cell?
It can be anything you want provided it can evaluate to bool.
Basically I might do something like:
cell<bool> some_flag;
cell<int> value1, value2;
cell<int> result;
int
main(void){
result = select( some_flag, value1, value2);
value1 = 42;
value2 = 64;
some_flag = TRUE;
assert(result == value1);
some_flag = FALSE;
assert(result == value2);
}
Yes. That would do it.
From a basic analysis of your sample code, yes, I think it does what I
want, but I haven't quite grasped the significance of ref. Binding
yes, ref no.
If you don't ue ref(), bind will keep a copy of the parameters provided.
If you use ref, it will be a ref_wrapper that will be stored.
Practically:
cell<int> a(1);
cell<int> b(2);
//here, it is a copy of a and b that is kept
function0< cell<int> > c=bind(std::plus< cell<int> >, a,b);
//here, it is a copy of b that is kept but a ref of a
function0< cell<int> > d=bind(std::plus< cell<int> >, ref(a),b);
assert( c.get_value() == 3);
assert( d.get_value() == 3);
a=cell<int>(2);
assert( c.get_value() == 3);//old value of a is kept
assert( d.get_value() == 4);//new value of a is used
The constructor with function0<> would I think approximately be
something like:
//in class body
cell<T>(const boost::function0<T> t): value(t) {}
Also I would like to be able to do something like:
result = value1 + 42;
without having to explicitly put the 42 in another cell. I'm
currently trying to hack this through your code but I haven't
succeeded so far.
You can overload the operators
template<class T>
cell<T>& operator+(cell<T>& lhs,const T& rhs)
{
return lhs+cell<T>(rhs);}
template<class T>
cell<T>& operator+(const cell<T>& lhs,const T& rhs)
{
return lhs+cell<T>(rhs);
}
Hmm. Just a question on how C++ handles the dealloc - when is the
object created in cell<T>(rhs) above destroyed?
I was doing something like this:
template<class T>
cell<T>& operator+(cell<T>& lhs, T& rhs)
{
cell<T> ret(lhs);
cell<T> rhsT(rhs);
return ret+=rhsT;
}
However the above would cause a segfault.
Of course, you would have to provide the same with different
cv-qualifier or use some Boost MPL.
Sorry, lost me there. Must be some weird C++ topic I have to study.
A problem arise with local instances of cell<T>.
Since their lifetime is limited by the scope, you cannot use a reference
to them and you must use a copy (i.e. not use ref).
I made a quick hack that consisted in overloading function with const
specifier to identify parameters that were local and thus copy them.
Hmm. From my understanding way back from C, const in an argument
means that the function promises not to modify the data pointed to by
a pointer argument. I don't quite understand how it filters out
local.
Excuse me for being annal, but you should definitely reimplement it wi=
th
counted body + composition rather than boost::function.
Sorry, lost me there. Must be some weird C++ topic I have to study too
They are patterns. In your problem, the counted body free you from
managing the lifetime of the parameters:
- if they are locals, the content will survive the destruction of the
local
- otherwise, the change in the parameter cell will propagate to cells
using it.
The composite pattern allow you to express an object as a composition of
object. That's what we do with boost::bind(): get_value() will call a
function with parameters that can themselves be the result of a call to
a function and so on.
Retaking the implementation I gave:
//implement here detail of body composite
namespace imp
{
//interface of cell body
template<class T>
struct cell_body
{
virtual ~cell_body(){}
virtual T get_value()const=0;
};
tyedef boost::shared_ptr<cell_body> cell_body_ptr;
I read the boost Smart Pointer manuals a bit, and it seems that it is
this which handles reference counting - all reference counting -
without actually having to modify (?) the classes to be reference
counted. Wow. I really have to read how this is implemented.
//counted cell body storing value
template<class T>
struct cell_body_value: public cell_body
{
cell_body_value(const T& t=T()):t_(t){}
T get_value()const{return t_;}
private:
T t_;
};
//cell body of lazy evaluation of binary operator
template<class T,class BinaryOperator>
struct cell_body_op: public cell_body
{
cell_body_op( cell_body_ptr lhs,
cell_body_ptr rhs,
const BinaryOperator& op=BinaryOperator()):
lhs_(lhs),
rhs_(rhs),
op_(op){}
virtual T get_value(){return op(lhs->get_value(),rhs->get_value();}
private:
cell_body_ptr lhs_;
cell_body_ptr rhs_;
BinaryOperator op_;
};
//do the same for unary operator, ...
};
template<class T>
class cell
{
public:
//ensure get_value() always work
cell<T>(const T& t=T())
{
value_=new imp::cell_body_value(t);
}
//make a const version to use when rhs is local
cell<T>& operator+=(const cell<T>& c)
{
value_=new imp::cell_body_op(value_,c.value_,std::plus());
}
inline T get_value()const{ return value_->get_value();}
private:
imp::cell_body_ptr value_;
};
The code is not tested but should be close.
Thanks! It does seem to be what I want (haven't tested myself yet
though).
Sincerely,
AmkG