allocator

I'm writing a container and would like to permit the user to use custom allocators, but I can't tell if I should pass allocators around by reference or by value. Is it guaranteed (or at least, a reasonable assumption to make) that an allocator object will not contain its memory pool directly, and hence it would be OK to copy an allocator and expect the memory pools of the allocators to be cross-compatible? Or do I always need to pass allocators by reference? (I have found that passing by reference harms performance by a factor of > 2 because the compiler starts worrying about aliasing, so it

Is there an obvious reason why the following code segfaults ? #include <vector> #include <emmintrin.h> struct point { __m128i v; point() { v = _mm_setr_epi32(0, 0, 0, 0); } }; int main(int argc, char *argv[]) { std::vector<point> a(3); } Thanks Edit: I'm using g++ 4.5.0 on linux/i686, I might not know what I'm doing here, but since even the following segfaults int main(int argc, char *argv[]) { point *p = new point(); } I really think it must be and alignment issue. Ben Voigt The obvious thing that could have gone wrong would be if v wasn't aligned properly. But it's allocated dynamically by

To save some code lets say I have a custom allocator named MyAlloc which I have successfully used with a std::vector<int> as follows: std::vector<int,MyAlloc<int>> vec; now I want to save a lambda in a std::function using the custom allocator, how do I do it? My failed attempt: int i[100]; std::function<void(int)> f(MyAlloc<void/*what to put here?*/>{},[i](int in){ //... }); Update: allocators in std::function have been depricated According to the standard, you need to give a tag type as the first argument to indicate that you want to use a custom allocator: std::function<void(int)> f(std:

Here is the documentation on cppreference , here is the working draft. I must admit that I didn't understand what's the real purpose of polymorphic_allocator and when/why/how I should use it. As an example, the pmr::vector has the following signature: namespace pmr { template <class T> using vector = std::vector<T, polymorphic_allocator<T>>; } What does the polymorphic_allocator offer? What does the std::pmr::vector offer as well in regard of the old-fashioned std::vector ? What can I do now that I wasn't able to do till now? What's the real purpose of that allocator and when should I use it