O''''Reilly Network For Information About''''s Book part 67 potx

Here is how the extractor function object that operates on a container of anys works, populating a new container with a certain type collected from the source container. // Get all ints in vec std::list<int> lst; std::for_each(vec.begin(),vec.end(), make_extractor<int>(std::back_inserter(lst))); std::cout << "Found " << lst.size() << " ints in vec\n\n"; Let's clear the contents of the container vec and add some new values. vec.clear(); vec.push_back(std::string("This is a string")); vec.push_back(42); vec.push_back(3.14); Now, let's try the predicates that we created. First, we use the two predicates that indicate whether an any contains a string or an int, respectively. if (is_string(vec[0])) { std::cout << "Found me a string!\n"; } if (is_int(vec[1])) { std::cout << "Found me an int!\n"; } As we concluded earlier, defining predicates for every type we are ever interested in is tedious and utterly unnecessary, when we can use the language to our advantage in a straightforward manner. if (contains<double>(vec[2])) { std::cout << "The generic tool is sweeter, found me a double!\n"; } } Running this example gives you this output. Example of using predicates and the function object any_counter There are 10 non-empty any's in vec Found 10 ints in vec Found me a string! Found me an int! The generic tool is sweeter, found me a double! Small and simple tools like these have proven to be very useful. Of course, this is not only true for any; it's a property of the design of the Standard Library containers and algorithms. The examples show how to take advantage of function composition together with any . Providing filtering, counting, operations on certain types, and so forth are powerful ways of hiding implementation details, and simplifying the usage of any. Complying with the Requirements of Standard Library Adapters If you found the predicate contains useful, you may have noticed that it is not quite all it can be. There is no way to use it together with the Standard Library adapters. The following example is slightly outside the scope of this chapter, but because any fits so well with the container classes, it would be a shame to leave a somewhat flawed predicate of contains as is. The problem is that the Standard Library adapters (bind1st, bind2nd, not1, and not2) impose requirements on the predicates they adapt. The type of the argument and the result type must be exposed through provided typedefs, and that means that we need a function object rather than a function. First comes the definition of our new function object, contains_t . It could have inherited from the helper class std::unary_function (part of the C++ Standard Library, intended to facilitate the creation of the correct typedefs) and have the argument and result types defined automatically, but to make things clear, the required typedefs are provided explicitly. The argument type has changed from const boost::any& to boost::any, to avoid a potential reference-to- reference, which is illegal. The implementation is just as before, only here it is placed in the function call operator. template <typename T> struct contains_t { typedef boost::any argument_type; typedef bool result_type; bool operator()(boost::any a) const { return typeid(T)==a.type(); } }; To save the name contains for subsequent use in the helper function that's soon to come, the name of the function object is contains_t. Here is a helper function that creates and returns an instance of contains_t with the appropriate type set automatically. The reason is that we want to overload contains so that we are still able to provide the original predicate that we created. template <typename T> contains_t<T> contains() { return contains_t<T>(); } Finally, the good old predicate is changed to take advantage of the contains_t implementation. Now, if we need to change the implementation of contains_t for some reason, contains will reflect those changes without any further effort. template <typename T> bool contains(const boost::any& a) { return contains_t<T>()(a); } Here's a sample program that demonstrates what we have gained, using both the new function object and the predicate from the previous example. int main() { std::cout << "Example of using the improved is_type\n"; std::vector<boost::any> vec; vec.push_back(std::string("This is a string")); vec.push_back(42); vec.push_back(3.14); Using the predicate is no different than before. Testing an any for a certain type is still easy. if (contains<double>(vec[2])) { std::cout << "The generic tool has become sweeter! \n"; } vec.push_back(2.52f); vec.push_back(std::string("Another string")); Another example of the use of contains is to search a container for occurrences of a certain type. This example finds the first float. std::vector<boost::any>::iterator it=std::find_if(vec.begin(),vec.end(),contains<float>()); As yet another reminder, the two ways of retrieving the contained value of an any are demonstrated. Pass the any to any_cast by const reference for the exception-throwing version. Pass the address of the any to return a pointer to the stored value. if (it!=vec.end()) { std::cout << "\nPrint the float twice!\n"; std::cout << boost::any_cast<float>(*it) << "\n"; std::cout << *boost::any_cast<float>(&*it) << "\n"; } std::cout << "There are " << vec.size() << " elements in vec\n"; I still haven't given a good example of why contains should be a full-fledged function object. In many cases, the reasons why may not be known beforehand, because we cannot anticipate every situation that our implementations will face. That's a strong reason to comply with the requirements of the Standard Library facilities, preferably in more than just the use cases that we are currently aware of. Nevertheless, I do have an example for you: The task is to remove all elements from a container vec that do not contain strings. Of course, writing another predicate that does the exact opposite of contains is one alternative, but that's an alternative that quickly can lead to maintenance nightmares, because of proliferation of function objects with similar work descriptions. The Standard Library provides us with an adapter called not1, which negates the result of an invocation of a function object, and this makes it trivial to clean out all non- string elements from our vector vec. vec.erase(std::remove_if(vec.begin(),vec.end(), std::not1(contains<std::string>())),vec.end()); std::cout << "Now, there are only " << vec.size() << " elements left in vec!\n"; } The examples in this section have demonstrated how to make effective use of any . Because the type of the stored value is not part of any's type, any is an essential tool when providing storage without imposing requirements on the stored types, including inheriting from a certain base class. We have seen that there is a price for this type hiding. any disallows access to the stored value without knowledge of the value's type, restricting opportunities to operate on the stored v alues. To a large extent, this can be amended by creating helper classespredicates and function objectsthat provide the necessary logic to access the values. Any Summary Discriminated types can contain values of different types and are quite different from indiscriminate (read void*) types. We always depend heavily on type safety in C++, and there are few situations in which we are willing to do without it. This is for good reasons: Type safety keeps us from making mistakes and improves the performance of our code. So, we avoid indiscriminate types. Still, it is not uncommon to find oneself in need of heterogeneous storage, or to insulate clients from the details of types, or to gain the utmost flexibility at lower levels of a hierarchy. any provides this functionality while maintaining full type safety, and that makes it an excellent addition to our toolbox! Use the Any library when  You need to store values of heterogeneous types in containers  Storage for unknown types is required  Types are being passed through layers that need not know anything about the types The design of Any also serves as a valuable lesson on how to encapsulate a type without effect on the type of the enclosing class. This design can be used to create generic function objects, generic iterators, and much more. It is an example of the power of encapsulation and polymorphism in conjunction with templates. In the Standard Library, there are excellent tools for storing collections of elements. When the need for storage of heterogeneous types arises, we want to avoid having to use new collection types. any offers a solution that works in many cases with existing containers. In a way, the template class any extends the capabilities of the Standard Library containers by packaging disparate types in a homogeneous wrapper that allows them to be made elements of those aforementioned containers. Adding Boost.Any to an existing code base is straightforward. It doesn't require changes to the design, and immediately increases flexibility where it's a pplied. The interface is small, making it a tool that is easily understood. The Any library was created by Kevlin Henney, and like all Boost libraries, has been reviewed, influenced, and refined by the Boost community. . earlier, defining predicates for every type we are ever interested in is tedious and utterly unnecessary, when we can use the language to our advantage in a straightforward manner. if (contains<double>(vec[2])). Now, if we need to change the implementation of contains_t for some reason, contains will reflect those changes without any further effort. template <typename T> bool contains(const boost::any&. vec.push_back(42); vec.push_back(3.14); Using the predicate is no different than before. Testing an any for a certain type is still easy. if (contains<double>(vec[2])) { std::cout