ATL / WTL / STL

_bstr_t bstr(myBStr, false); // false says to "take ownewrship, don't copy"
char const * p = bstr;       // creates and caches the ASCII representation

// p is valid as long as the bstr is around

• The allocator does not check whether it's running out of space. It is up to you to dimension the pool appropriately
• No alignment issues are consided, though this is not a problem on Intel architectures.

#include <stddef.h>
 
template<typename T,size_t pool_size>
class brute_allocator
{
public:
  brute_allocator():
    pool(new char[pool_size]),next(pool)
  {}
 
  brute_allocator(const brute_allocator&):
    pool(new char[pool_size]),next(pool)
  {}
 
  brute_allocator& operator=(const brute_allocator&)
  {
    return *this;
  }
 
  ~brute_allocator()
  {
    delete[]pool;
  }
 
  typedef size_t     size_type;
  typedef ptrdiff_t  difference_type;
  typedef T         *pointer;
  typedef const T   *const_pointer;
  typedef T&         reference;
  typedef const T&   const_reference;
  typedef T          value_type;
 
  template<typename Other> struct rebind
  {
    typedef brute_allocator<Other,pool_size> other;
  };
 
  pointer address(reference x)const{return &x;}
  const_pointer address(const_reference x)const{return &x;}
 
  pointer allocate(size_type n,const void *hint=0)
  {
    return reinterpret_cast<pointer>(_Charalloc(sizeof(T)));
  }
 
  char* _Charalloc(size_type n)
  {
    char* res=next;
    next+=n;
    return res;
  }
 
  void deallocate(void *p,size_type n)
  {
  }
 
  void construct(pointer p,const T& val)
  {
    new ((void *)p) T(val);
  }
 
  void destroy(pointer p)
  {
    p->T::~T();
  }
 
  size_type max_size()const
  {
    size_type n=(size_type)(-1)/sizeof(T);
    return (0<n?n:1);
  }
 
  /* Every two instances are treated as different */
 
  bool operator ==(const brute_allocator& x) const
  {
    return this==&x;
  }
 
  bool operator !=(const brute_allocator& x) const
  {
    return this!=&x;
  }
 
  /* This two member functions never get called, but VC complains if no
   * declaration for them is provided. See documentation for this
   * VC++ confirmed bug in the Microsoft Knowledge Base, article Q166721.
   * I think this has been fixed in VC++ 6.0.
   */
 
  bool operator <(const brute_allocator&) const;
  bool operator >(const brute_allocator&) const;
 
private:
  char* pool;
  char* next;
};
 
#include <map>
#include <iostream>
 
typedef brute_allocator<int,20000> b_allocator;
typedef std::map<int,int,std::less<int>,b_allocator> fast_map;
 
int main()
{
  fast_map fm;
 
  for(int i=0;i<500;++i)fm[i]=2*i;
 
  for(fast_map::iterator it=fm.begin(),it_end=fm.end();it!=it_end;++it){
    std::cout<<it->first<<" "<<it->second<<std::endl;
  }
 
  return 0;
}

struct greaterThan_CSort
{
bool operator()(const CSort &pfi1, const CSort &pfi2) const
{
return pfi1.m_i > pfi2.m_i; // note the "greater"!!
}

namespace std // this is not nice, but the only way it works
{
template<>
struct greater<CSort> : public binary_function<CSort, CSort, bool> {
    bool operator()(const CSort& x, const CSort& y) const
    { ... }
    };  
}