Comment pourrais-je surcharger le "nouvel" opérateur pour allouer de la mémoire à partir d'un périphérique de mémoire secondaire?

Question

Je cherche une syntaxe pour allouer de la mémoire à partir d'un périphérique de mémoire secondaire et non du tas par défaut.

Comment puis-je l'implémenter? Utiliser malloc() le prendrait par défaut de tas ... Sûrement il doit y avoir une autre façon!

Answer 1

#include <new> 

void* operator new(std::size_t size) throw(std::bad_alloc) { 
    while (true) { 
    void* result = allocate_from_some_other_source(size); 
    if (result) return result; 

    std::new_handler nh = std::set_new_handler(0); 
    std::set_new_handler(nh); // put it back 
    // this is clumsy, I know, but there's no portable way to query the current 
    // new handler without replacing it 
    // you don't have to use new handlers if you don't want to 

    if (!nh) throw std::bad_alloc(); 
    nh(); 
    } 
} 
void operator delete(void* ptr) throw() { 
    if (ptr) { // if your deallocation function must not receive null pointers 
    // then you must check first 
    // checking first regardless always works correctly, if you're unsure 
    deallocate_from_some_other_source(ptr); 
    } 
} 
void* operator new[](std::size_t size) throw(std::bad_alloc) { 
    return operator new(size); // defer to non-array version 
} 
void operator delete[](void* ptr) throw() { 
    operator delete(ptr); // defer to non-array version 
} 

Answer 2

Vous devrez construire ou adapter votre propre gestionnaire de tas, et surcharger new et delete, ainsi que new[] et delete[]. Initialisez le gestionnaire de segments avec la mémoire spéciale.