mi_ prefixed implementations of various allocation functions that use C++ semantics on out-of-memory, generally calling std::get_new_handler and raising a std::bad_alloc exception on failure.
More...
|  | 
| void * | mi_new (std::size_t n) noexcept(false) | 
|  | like mi_malloc(), but when out of memory, use std::get_new_handlerand raisestd::bad_allocexception on failure.  More...
 | 
|  | 
| void * | mi_new_n (size_t count, size_t size) noexcept(false) | 
|  | like mi_mallocn(), but when out of memory, use std::get_new_handlerand raisestd::bad_allocexception on failure.  More...
 | 
|  | 
| void * | mi_new_aligned (std::size_t n, std::align_val_t alignment) noexcept(false) | 
|  | like mi_malloc_aligned(), but when out of memory, use std::get_new_handlerand raisestd::bad_allocexception on failure.  More...
 | 
|  | 
| void * | mi_new_nothrow (size_t n) | 
|  | like mi_malloc, but when out of memory, usestd::get_new_handlerbut return NULL on failure.  More...
 | 
|  | 
| void * | mi_new_aligned_nothrow (size_t n, size_t alignment) | 
|  | like mi_malloc_aligned, but when out of memory, usestd::get_new_handlerbut return NULL on failure.  More...
 | 
|  | 
| void * | mi_new_realloc (void *p, size_t newsize) | 
|  | like mi_realloc(), but when out of memory, use std::get_new_handlerand raisestd::bad_allocexception on failure.  More...
 | 
|  | 
| void * | mi_new_reallocn (void *p, size_t newcount, size_t size) | 
|  | like mi_reallocn(), but when out of memory, use std::get_new_handlerand raisestd::bad_allocexception on failure.  More...
 | 
|  | 
mi_ prefixed implementations of various allocation functions that use C++ semantics on out-of-memory, generally calling std::get_new_handler and raising a std::bad_alloc exception on failure. 
Note: use the mimalloc-new-delete.h header to override the new and delete operators globally. The wrappers here are mostly for convience for library writers that need to interface with mimalloc from C++. 
◆ mi_stl_allocator
template<class T>
struct mi_stl_allocator< T >
std::allocator implementation for mimalloc for use in STL containers. 
For example: 
std::vector<int, mi_stl_allocator<int> > vec;
vec.push_back(1);
vec.pop_back();
 
 
◆ mi_new()
  
  | 
        
          | void* mi_new | ( | std::size_t | n | ) |  |  | noexcept | 
 
like mi_malloc(), but when out of memory, use std::get_new_handler and raise std::bad_alloc exception on failure. 
 
 
◆ mi_new_aligned()
  
  | 
        
          | void* mi_new_aligned | ( | std::size_t | n, |  
          |  |  | std::align_val_t | alignment |  
          |  | ) |  |  |  | noexcept | 
 
like mi_malloc_aligned(), but when out of memory, use std::get_new_handler and raise std::bad_alloc exception on failure. 
 
 
◆ mi_new_aligned_nothrow()
      
        
          | void* mi_new_aligned_nothrow | ( | size_t | n, | 
        
          |  |  | size_t | alignment | 
        
          |  | ) |  |  | 
      
 
like mi_malloc_aligned, but when out of memory, use std::get_new_handler but return NULL on failure. 
 
 
◆ mi_new_n()
  
  | 
        
          | void* mi_new_n | ( | size_t | count, |  
          |  |  | size_t | size |  
          |  | ) |  |  |  | noexcept | 
 
like mi_mallocn(), but when out of memory, use std::get_new_handler and raise std::bad_alloc exception on failure. 
 
 
◆ mi_new_nothrow()
      
        
          | void* mi_new_nothrow | ( | size_t | n | ) |  | 
      
 
like mi_malloc, but when out of memory, use std::get_new_handler but return NULL on failure. 
 
 
◆ mi_new_realloc()
      
        
          | void* mi_new_realloc | ( | void * | p, | 
        
          |  |  | size_t | newsize | 
        
          |  | ) |  |  | 
      
 
like mi_realloc(), but when out of memory, use std::get_new_handler and raise std::bad_alloc exception on failure. 
 
 
◆ mi_new_reallocn()
      
        
          | void* mi_new_reallocn | ( | void * | p, | 
        
          |  |  | size_t | newcount, | 
        
          |  |  | size_t | size | 
        
          |  | ) |  |  | 
      
 
like mi_reallocn(), but when out of memory, use std::get_new_handler and raise std::bad_alloc exception on failure.