Boost logo

Boost :

From: Dietmar Kuehl (dietmar_kuehl_at_[hidden])
Date: 2002-05-04 19:44:14

Peter Dimov wrote:

> template<class T> void f(typename ptr<T>::shared p);
> ptr<int>::shared q;
> f(p); // fail

Well, you can work-around this by not depending on the concrete type
[immediately]. The first approach

   template <class SP> void f(SP p);

is, of course, inappropriate because it would be "catch all". A slight
variation (thanks to Howard Hinnant for pointing out this technique in
a different context) removes this "catch all" problem at the cost of
writing a certain default argument:

   template <class SP> void f(SP p,
                              typename is_ptr_shared<SP>::type = 0);

where 'is_ptr_shared' is a template class which has the subtype 'type'
defined if 'typename ptr<typename SP::pointer_type>::shared' is the same
type as 'SP' and otherwise does not have such a type.

Below is a short demo of this idea (needs a reasonable compiler though;
gcc-2.95 failed while EDG and gcc-3.0 compile the code correctly).

<mailto:dietmar_kuehl_at_[hidden]> <>
Phaidros eaSE - Easy Software Engineering: <>
// --- some smart pointer header ---
template <typename T, bool> struct smart_ptr {
typedef T pointer_type;
template <typename T> struct ptr {
typedef smart_ptr<T, true> shared;
template <typename SP,
     typename Aux
       = typename ptr<typename SP::pointer_type>::shared>
struct is_shared
template <typename SP>
struct is_shared<SP, SP> { typedef bool type; };
// --- user code ---
#include <iostream>
template <typename SP>
void f(SP p, typename is_shared<SP>::type = true) {
std::cout << "shared pointer\n";
void f(long) {
std::cout << "long\n";
int main()
f(smart_ptr<int, true>());
// illegal: f(smart_ptr<int, false>());

Boost list run by bdawes at, gregod at, cpdaniel at, john at