Re: Defining a cast on a templated class
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;
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 cell ?
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?
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);
}
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.
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. I suppose I need to create a different method other
than operation (maybe operation1) which will only do .get_value() on
the lhs. And maybe another method too which would do .get_Value() on
the rhs only...
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.
Excuse me for being annal, but you should definitely reimplement it with
counted body + composition rather than boost::function.
Sorry, lost me there. Must be some weird C++ topic I have to study
too.
Michael