looking for elegant C++ abstraction around pthread_key_t...

Here is what I am playing around with now:
_________________________________________________________________
/* Simple TSD Object
______________________________________________________________*/
#include <pthread.h>
#include <cstdio>

#if defined(_MSC_VER)
# define DECLSPEC_CDECL __cdecl
#elif defined(__GNUC__)
# define DECLSPEC_CDECL __attribute__((cdecl))
#else
# error MSVC or GCC REQUIRED!!!!! ;^(...
#endif

template<typename T>
class tsd {
  pthread_key_t m_key;

  static void DECLSPEC_CDECL tsd_dtor(void* state) {
    delete reinterpret_cast<T*>(state);
  }

public:
  struct main_guard {
    tsd& m_tsd;

    main_guard(tsd& tsd_) : m_tsd(tsd_) {

    }

    ~main_guard() {
      m_tsd.clear();
    }
  };

  tsd() {
    pthread_key_create(&m_key, tsd_dtor);
  }

  ~tsd() {
    pthread_key_delete(m_key);
    std::printf("(%p)->tsd<T>::~tsd()\nhit <ENTER> to continue...",
      (void*)this);
    std::fflush(stdout);
    std::getchar();
  }

  T& instance() const {
    T* obj = reinterpret_cast<T*>(pthread_getspecific(m_key));
    if (! obj) {
      obj = new T();
      pthread_setspecific(m_key, obj);
    }
    return *obj;
  }

  void clear() {
    delete reinterpret_cast<T*>(pthread_getspecific(m_key));
    pthread_setspecific(m_key, NULL);
  }
};

/* Simple Usage Example
______________________________________________________________*/
#include <cassert>

static tsd<struct foo> g_foo_tsd;
static tsd<struct foo2> g_foo2_tsd;
static tsd<struct foo3> g_foo3_tsd;

struct foo {
  foo() {
    std::printf("(%p)->foo::foo()\n", (void*)this);
  }

  ~foo() {
    std::printf("(%p)->foo::~foo()\n", (void*)this);
  }
};

struct foo2 {
  foo2() {
    std::printf("(%p)->foo2::foo2()\n", (void*)this);
  }

  ~foo2() {
    std::printf("(%p)->foo2::~foo2()\n", (void*)this);
  }
};

struct foo3 {
  foo3() {
    std::printf("(%p)->foo3::foo3()\n", (void*)this);
  }

  ~foo3() {
    std::printf("(%p)->foo3::~foo3()\n", (void*)this);
  }
};

extern "C" void* thread_entry(void* state) {
  {
    foo& f1 = g_foo_tsd.instance();
    foo& f2 = g_foo_tsd.instance();
    foo& f3 = g_foo_tsd.instance();
    assert(&f1 == &f2 && &f2 == &f3);
  }

  {
    foo2& f1 = g_foo2_tsd.instance();
    foo2& f2 = g_foo2_tsd.instance();
    foo2& f3 = g_foo2_tsd.instance();
    assert(&f1 == &f2 && &f2 == &f3);
  }

  {
    foo3& f1 = g_foo3_tsd.instance();
    foo3& f2 = g_foo3_tsd.instance();
    foo3& f3 = g_foo3_tsd.instance();
    assert(&f1 == &f2 && &f2 == &f3);
  }

  return 0;
}

int main(void) {
  {
    tsd<foo>::main_guard tsd_main_guard(g_foo_tsd);
    tsd<foo2>::main_guard tsd_main_guard2(g_foo2_tsd);
    tsd<foo3>::main_guard tsd_main_guard3(g_foo3_tsd);

    pthread_t tid[2];
    pthread_create(&tid[0], NULL, thread_entry, NULL);
    pthread_create(&tid[1], NULL, thread_entry, NULL);

    {
      foo& f1 = g_foo_tsd.instance();
      foo& f2 = g_foo_tsd.instance();
      foo& f3 = g_foo_tsd.instance();
      assert(&f1 == &f2 && &f2 == &f3);
    }

    {
      foo2& f1 = g_foo2_tsd.instance();
      foo2& f2 = g_foo2_tsd.instance();
      foo2& f3 = g_foo2_tsd.instance();
      assert(&f1 == &f2 && &f2 == &f3);
    }

    {
      foo3& f1 = g_foo3_tsd.instance();
      foo3& f2 = g_foo3_tsd.instance();
      foo3& f3 = g_foo3_tsd.instance();
      assert(&f1 == &f2 && &f2 == &f3);
    }

    pthread_join(tid[1], NULL);
    pthread_join(tid[0], NULL);
  }
  std::puts("\n\n\n__________________\nhit <ENTER> to exit...");
  std::fflush(stdout);
  std::getchar();
  return 0;
}
_________________________________________________________________

As you can see it uses compiler specific extensions in order to ensure the
procedure `tsd<T>::tsd_dtor()' has C linkage. I am doing this in order to
get around having to dynamically create a base-class, helper object and a
free extern "C" function. I can't really see any way around having to go
through that mess without resorting to compiler extensions. Humm, if I were
to use a free function, I think I would have to do something ugly like:
_________________________________________________________________
/* Simple TSD Object
______________________________________________________________*/
#include <pthread.h>
#include <cstdio>

struct tsd_object_base {
  virtual ~tsd_object_base() = 0;
};

tsd_object_base::~tsd_object_base() {}

extern "C" void tsd_object_dtor(void* state) {
  delete reinterpret_cast<tsd_object_base*>(state);
}

template<typename T>
class tsd {
  struct tsd_object : public tsd_object_base {
    T m_object;
    tsd_object() : m_object() {}
  };

  pthread_key_t m_key;

public:
  struct main_guard {
    tsd& m_tsd;

    main_guard(tsd& tsd_) : m_tsd(tsd_) {

    }

    ~main_guard() {
      m_tsd.clear();
    }
  };

  tsd() {
    pthread_key_create(&m_key, tsd_object_dtor);
  }

  ~tsd() {
    pthread_key_delete(m_key);
    std::printf("(%p)->tsd<T>::~tsd()\nhit <ENTER> to continue...",
      (void*)this);
    std::fflush(stdout);
    std::getchar();
  }

  T& instance() const {
    tsd_object* obj =
      reinterpret_cast<tsd_object*>(pthread_getspecific(m_key));
    if (! obj) {
      obj = new tsd_object();
      pthread_setspecific(m_key, obj);
    }
    return obj->m_object;
  }

  void clear() {
    delete reinterpret_cast<tsd_object*>(pthread_getspecific(m_key));
    pthread_setspecific(m_key, NULL);
  }
};

// [...]
_________________________________________________________________

This works fine, but IMVHO, its kind of messy. However, it is standard wrt
POSIX rules, and a heck of a lot more portable. Is there any way to keep
maximum portability, yet remove the need for helper classes? I suppose I
could do two versions and #ifdef them if the compiler does not support the
extensions I am looking for... Humm... Need advise!

Thanks.