Using a Custom Allocator with std::unordered_set

std::unordered_set allows you to specify a custom allocator type as the fourth template parameter. This can be useful for specialized memory management or for integration with custom memory allocation libraries.

Here's an example of using a custom allocator with std::unordered_set:

1#include <iostream>
2#include <unordered_set>
3
4template <typename T>
5struct CustomAllocator {
6  using value_type = T;
7
8  CustomAllocator() = default;
9
10  template <typename U>
11  CustomAllocator(const CustomAllocator<U>&) {}
12
13  T* allocate(std::size_t n) {
14    std::cout << "Allocating " << n
15      << " elements\n";
16    return static_cast<T*>(
17      ::operator new(n * sizeof(T)));
18  }
19
20  void deallocate(T* p, std::size_t n) {
21    std::cout << "Deallocating " << n 
22      << " elements\n";
23    ::operator delete(p); 
24  }
25};
26
27int main() {
28  std::unordered_set<
29    int, std::hash<int>,
30    std::equal_to<int>,
31    CustomAllocator<int>>
32      Set{1, 2, 3};
33}

1Allocating 16 elements
2Allocating 1 elements
3Allocating 1 elements
4Allocating 1 elements
5Deallocating 16 elements
6Deallocating 1 elements
7Deallocating 1 elements
8Deallocating 1 elements

In this example:

• We define a CustomAllocator struct that implements the necessary functions for an allocator: allocate() and deallocate()
• Inside allocate(), we print a message and then allocate memory using the global ::operator new
• Inside deallocate(), we print a message and then free the memory using ::operator delete
• We specify CustomAllocator<int> as the fourth template argument when creating the std::unordered_set

When we insert or erase elements from the set, our custom allocator's allocate() and deallocate() functions are called, as evident from the output.

Using a custom allocator allows you to have fine-grained control over how memory is allocated and freed for the elements stored in the std::unordered_set.