SharedString::HashTable * gTable;

MAKE_MANAGER_WRAPPER(HashTableWrapper, &gTable)
typedef SharedString::SharedString< HashTableWrapper > shared_str;

#define MAKE_MANAGER_WRAPPER(name, managerPtr) \
	struct name \
	{ \
		static const std::string * AddString(const std::string & str) \
		{ return (*Manager_)->addString(str); } \
		static void DeleteString(const std::string & str) \
		{ (*Manager_)->deleteString(str); } \
		static SharedString::StringManager ** Manager_; \
	}; \
	SharedString::StringManager ** name::Manager_ = (SharedString::StringManager**) managerPtr;

class StringAllocator {
private:
 static InternalAllocator {
   private:
      hash_type hash;
      size_t bytes_allocated;
      //...
   public:
      InternalAllocator();
      const char *Share( const char *sz );
      void Decrease( const char *sz );
      size_t GetBytes( void );
      //...
  };
public:
  StringAllocator();
  //... functions using the internal allocator.
};

template< typename T >
class SharedString {
private:
   T allocator;
   //...
public:
  //operators
};

//There would be no bulk in carrying around an allocator
//Each SharedString class would have its own instance
//of the StringAllocator class, but each instance would
//always reference the internal static allocator
//so you would have a real string sharing mechanism.

//If the user wanted to use the allocator directly,
//he or she could:
void func( void )
{
  StringAllocator sa;
  std::cout << sa.GetBytes() << std::endl;
}

#include <stddef.h>

namespace std
{ 
  using ::ptrdiff_t;
  using ::size_t;
}