Default class template problem

Say I have a class:

Code:

---

template
<
        typename T,
        template<typename> class DebugPolicy = ???
>
class debug_ptr: public DebugPolicy<T>

---

This class will derive from a specified policy.

Now, I define two policies:

Code:

---

template<typename T> class DebugPtrDebugPolicy
template<typename T> class DebugPtrReleasePolicy

---

The idea, then, is to be able to invoke the class using:

debug_ptr<int, DebugPtrDebugPolicy>

Or such.
This is all good and well, but only if I explicitly select a policy as default for the class template, such as:

Code:

---

template
<
        typename T,
        template<typename> class DebugPolicy = DebugPtrDebugPolicy
>
class debug_ptr: public DebugPolicy<T>

---

However, this is short of what I want to accomplish.
If it's debug mode, it should automatically choose DebugPtrDebugPolicy, and if it's release mode, it should choose DebugPtrReleasePolicy.
This is where I hit a snag.

Determining if it's debug mode isn't a problem:

Code:

---

namespace Debug
{
#ifdef _DEBUG
        static const bool IsDebugMode = true;
        static const bool IsReleaseMode = false;
#else
        static const bool IsDebugMode = false;
        static const bool IsReleaseMode = true;
#endif
}

---

But choosing a class over the other depending on it, is.
A sort of compile-time if.
Of course, boost has one in the form of boost::mpl::if_c, but the prototype is:

template<bool, typename, typename>

So this code won't compile:

Code:

---

template
<
        typename T,
        template<typename> class DebugPolicy = boost::mpl::if_c<Debug::IsDebugMode, DebugPtrDebugPolicy, DebugPtrReleasePolicy>::type
>
class debug_ptr: public DebugPolicy<T>

---

(I'm not sure if typename is required here.)
The reason being that DebugPtrDebugPolicy is template<typename>, a non-specialized class, and boost's if only accepts specialized classes as arguments.

So is there any good alternative C++ way of a solution to this?
Because I want the user to be able to choose a policy without explicitly specializing it with the type.

I've tried all sorts of complexity, but what I got is circular template references -_-
Anyone has any ideas on thus? I'd appreciate it.

Metaprogramming can take care of the "compile-time if". Here's what I have in mind (I believe I remember seeing something like this in a tutorial before):

Code:

---

template <bool Condition, typename If_True, typename If_False> struct Static_If
{ typedef If_True Result_Type; }; // Assume condition is true

template <typename If_True, typename If_False> struct Static_If <false, If_True, If_False>
{ typedef If_False Result_Type; }; // Specialize for false conditions

---

Now, you should be able to use it like this:

Code:

---

template
<
    typename T,
    typename DebugPolicy =
        typename Static_If <Debug::IsDebugMode, DebugPtrDebugPolicy <T>, DebugPtrReleasePolicy <T> >::Result_Type
>
class debug_ptr : public DebugPolicy
{
    /* ... */
};

---

Yes, boost has such a helper.
However, it defies one of the conditions.
I should be able to create an instance of the class using:

debug_ptr<int, DebugPtrDebugPolicy>
And not
debug_ptr< int, DebugPtrDebugPolicy<int> >

That's why I was asking.

Maybe I'm too much of a C-Macro freak and not C++ template worthy, but why choose the hard, incomprehensible way when you already have that #define ?

Code:

---

template
< typename T, class DebugPolicy =
#ifdef _DEBUG
        DebugPtrDebugPolicy <T>
#else
        DebugPtrReleasePolicy <T>
#endif
>
class debug_ptr : public DebugPolicy
{
    /* ... */
};

---

Hmm, I would think the only way to do that would be by using clever macros.

But why wouldn't you want to specialize the DebugPolicy class? If you don't want to specify the debug policy's template parameter yet, you could always use more compile-time if's within the class definition, I suppose. Consider this:

Code:

---

template <typename T>
struct DebugPolicyType
{
    typedef typename Static_If <Debug::IsDebugMode, DebugPtrDebugPolicy <T>, DebugPtrReleasePolicy <T> >::Result_Type type;
};

---

Then, if you wanted to use a (possibly) different parameter for the debug policy template later on, could say
DebugPolicyType< SomeType >::type

Quote:

---

Originally Posted by nvoigt

Maybe I'm too much of a C-Macro freak and not C++ template worthy, but why choose the hard, incomprehensible way when you already have that #define ?

---

I've thought of that, but what's the fun in it? If we're C++ programmers, we should be able to do it the C++ way, without typing lots of code or annoying macros!

Quote:

---

Originally Posted by rudyman

But why wouldn't you want to specialize the DebugPolicy class? If you don't want to specify the debug policy's template parameter yet, you could always use more compile-time if's within the class definition, I suppose. Consider this:

---

Exactly, I don't want to specialize it YET.
Your code works, it's the best so far, but it has some drawbacks.
All the classes need a "type" typedef.
It's not generic.
And...
debug_ptr<int>
debug_ptr<int, DebugPtrDebugPolicy>
...aren't the same, even in debug mode!

I wonder if it's possible to overcome these problems, especially the second, and if possible, the first, as well.