On 3/4/11 6:46 AM, "joaquin@tid.es" <joaquin@tid.es> wrote:
Stewart, Robert escribió:
joaquin@tid.es wrote:
Daniel Larimer escribió:
I recently ran into a problem where I wanted to retrieve the value stored in a boost::any by casting to a base class. Unfortunately, boost::any requires you cast out the exact type as that held.
Boost.DynamicAny is a vairant on Boost.Any which provides more flexible dynamic casting of the underlying type. Whereas retreiving a value from Boost.Any requires that you know the exact type stored within the Any, Boost.DynamicAny allows you to dynamically cast to either a base or derived class of the held type. I misspoke, you cannot cast to a more-derived type than that held..
What's the trade-off? I mean, does Boost.DynamicAny use more memory than Boost.Any, is it slower?
Memory usage should be the same, compile times may increase slightly as a helper template was needed to separate the scalar vs non-scalar implementation. Runtime dynamic cast performance will be slower than the compile time static cast in boost::any. Static cast is still used for scalar types.
I presume you mean other than the difference between static_cast and dynamic_cast?
Couldn't this functionality be added to Boost.Any itself? That is, add another cast that does dynamic_cast so there's only one library but clients get a choice about how to extract values.
The change is perhaps a bit to fundamental. Here is the "effective difference". struct any { struct holder_base{}; template<typename T> struct holder_impl<T> : holder_base { T held; }; holder_base* data; } struct dynamic_any { struct holder_base{}; template<typename T> struct holder_impl<T> : T, virtual holder_base {}; holder_base* data; }; With the extra layer of inheritance, there is some potential for conflicts with the clone() and type() virtual methods provided by holder_impl<> and any method of the same name provided by T. These conflicts could be mitigated by changing the name to __dynamic_any__clone() /type(). I had assumed there was a solid design rational for using aggregation vs inheritance in boost::any and it is probably related to it having less restrictions on the type that can be held. In my original email I thought it would be easy to add support for casting dynamic_any(derived*) to dynamic_any(base*), but because I cannot inherit from a pointer, I have no way to get the RTTI info required to know that derived inherits base or what the offset is. If anyone has a way to polymorphically determine whether base* is inherited by derived* and if so perform the proper pointer offsets to do a cast let me know.
That is exactly my point.
Joaquín M López Muñoz Telefóinca, Investigación y Desarrollo
Este mensaje se dirige exclusivamente a su destinatario. Puede consultar nuestra política de envío y recepción de correo electrónico en el enlace situado más abajo. This message is intended exclusively for its addressee. We only send and receive email on the basis of the terms set out at. http://www.tid.es/ES/PAGINAS/disclaimer.aspx _______________________________________________ Unsubscribe & other changes: http://lists.boost.org/mailman/listinfo.cgi/boost