struct Foo
{
virtual int RankA( Type1& ) = 0;
virtual int RankB( Type2& ) = 0;
};
template<class A,class B>
struct Bar
{
int RankA(Type1& t) { return A::Rank(t); }
int RankB(Type2& t) { return B::Rank(t); }
};
// not legal, but shows what I'm talking about
void Func(Bar&);
template < class A, class B > void func(Bar<A,B> &);Quote:Original post by Antheus
boost any uses runtime polymorphism, just very disguised. any is a concrete, non-templated type. It stores run-time type and opaque pointer. When cast, it does run-time check to see if types are convertible, but might use some template magic internally to select proper conversion implementation.
Quote:Original post by zyrolasting
I am rewriting an enumeration library and wish to abandon dynamic binding. In code, I would go from this...
*** Source Snippet Removed ***
To something like this.
*** Source Snippet Removed ***
I want to provide my clients with several preset policies to ease their labor, but one thing stops me: Passing something like Bar above as a parameter to something without having to tack template-templates on it's object or function header. How would I do this, or something like this? boost::any made me think it was remotely possible.
I.E.
*** Source Snippet Removed ***
template<class A, class B>class bar{};template<template<class A, class B> class Param>class foo{ Param<int,double> param_one; Param<string,vector<int> > param_two;};template<class A>template<template <class A> class B>template<class A, class B>void Func(Bar<A, B>&);Quote:As for your actual problem, you can do something very similar. Have a non-templated BarBase interface that is passed to the function as a reference. The actual type that is passed can then be Bar<A, B> or whatever you user wants to use.
Quote:Original post by zyrolasting
Let me rephrase my problem for those who need clarification.
I want a different feature set per project. Every time I want another set of
features, I have to derive from a filter object and override similar code, which is messy and tedious. I may also have some of the code for what I want written already, but I would have to invoke parent implementations to get it, or copy code from other projects.
All the filter methods can be generalized into policies. Consequently, I need one policy for each method. I would have a huge template argument list!
To use the host class, I pass it to object methods. The problem is, I have to tack template-templates onto the objects I'm passing it to. I don't want to do that. The resulting code would become confusing (picture 10+ template templates following you to every working object of your library). I want to write preset policies that do several enumeration jobs to begin with, and the user can just browse through and build a new filter like a Lego set.
In short, I want to pass a templated host class around and I do NOT want every object I pass it to to be aware it's templated.
template< template<class, class> class LockingPolicy, template<class,class,class> class DestructionPolicy>class policy_simplifier{ template<class A, class B> struct lock_policy { typedef LockingPolicy<A,B>::type type; }; template<class A, class B, class C> struct destruction_policy { typedef DestructionPolicy<A,B,C>::type type; };};template<class A, class B>struct InsaneLockingPolicy{};template<class A, class B, class C>struct CrazyDestructionPolicy{};template<class Policy>void foo(){ typedef typename Policy::locking_policy<int,double>::type locker; typedef typename Policy::destruction_policy<string,int>::type destructor;}void do_something_with_insane_locking_and_crazy_destruction(){ typedef policy_simplifier<InsaneLockingPolicy, CrazyDestructionPolicy> policy; foo<policy>();}
