为什么 std::string 的自定义分配器不起作用

Question

I define a new allocator like this:

template <class T>
class CodecAlloc: public std::allocator<T> {
public:
  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;

  CodecAlloc() {}
  CodecAlloc(const CodecAlloc&) {}

  pointer allocate(size_type n, const void * = 0) {
              T* t = (T*) malloc(n * sizeof(T));
              std::cout
              << "  used CodecAlloc to allocate   at address "
              << t << " (+)" << std::endl;
              return t;
            }

  void deallocate(void* p, size_type) {
              if (p) {
                free(p);
                std::cout
                << "  used CodecAlloc to deallocate at address "
                << p << " (-)" << 
                std::endl;
              } 
            }

  template <class U>
  struct rebind { typedef CodecAlloc<U> other; };
};

if I typedef a new type:

typedef std::basic_string<char, std::char_traits<char>, CodecAlloc<char>> String;

it work well，CodecAlloc::allocate has been called. but now there is a interface like this:

void SetBinary(const std::string&)

it's parameter is a std::string, the type String does not match. So I use this way to construct std::string

std::string str = std::string("Hello !!", CodecAlloc<char>);
SetBinary(str)

but the CodecAlloc allocator does not been called?. why. and how should i solve this problem. the SetBinary interface can not be changed. thks

Answer 1

So, the line

std::string str = std::string("Hello !!", CodecAlloc<char>);

is just wrong and has several errors:

1. You can't use CodecAlloc<char> since that is a type. You need to pass an allocator instance, so at least CodecAlloc<char>() is needed.
2. If 1. is fixed, it will still not work since the passed allocator differs from the one used by std::string . You could fix it to use your type String : std::string str = String("Hello,;", CodecAlloc<char>); , but that won't work, since std::string does not have an assigment operator from a type with a different allocator - see this

So with the detailed explanation above the answer is - no you cannot achieve what you want and pass a custom typedef'ed std::basic_string in a std::string and preserve your custom allocator.

Answer 2

std::string str = std::string("Hello !!", CodecAlloc<char>);

Assuming that you actually created a temporary like CodecAlloc<char>() (because otherwise it wouldn't compile) what happens is that you call the constructor taking a const std::allocator<char>& (because that's what std::string::allocator_type is) and your object has that as a base class. So the reference binds to the base subobject of your CodecAlloc<char> temporary, and then that base subobject gets copied into the string's internal allocator object.

You can't make std::string use a different allocator type just by passing it to the constructor, the allocator type is a static property of the string.

Answer 3

I have bad news for you.

The other answers already covered this nicely, but I wanted to be more explicit about this: you will not be able to use this interface with a string that uses a custom allocator . Or with any other kind of string, for that matter.

To understand why, you need to know what std::string is. If you look for "string" on cppreference, you'll be directed to the page for std::basic_string . This is intentional, std::basic_string is a template that defines a collection of string classes, and std::string is one of them.

If you look at the definition of std::string , you'll see that it is defined as std::basic_string<char> , which is a shortcut for std::basic_string<char, std::char_traits<char>, std::allocator<char>> . This means that std::string already comes embedded with its own allocator , which is not extensible: the member functions std::allocator<T>::allocate and std::allocator<T>::deallocate are not virtual. Assuming you wanted to use this constructor from std::basic_string :

basic_string( const CharT* s, const Allocator& alloc = Allocator() );

... that means that even if the constructor is using a reference to the allocator, these functions ( allocate and deallocate ) will not be overridden: the constructor doesn't even know about your version of them. Instead, it will use the versions from the base class.