Часть II

.. . продолжение

Учитывая поведение operator new из примера, хорошо спроектированный new_handler должен выполнять одно из следующих действий:

Выделите больше памяти: это может привести к успешной следующей попытке выделения памяти внутри цикла оператора new. Один из способов реализовать это — выделить большой блок памяти при запуске программы, а затем освободить его для использования в программе при первом вызове обработчика new.

Установить другой новый обработчик: если текущий новый обработчик не может сделать больше доступной памяти и есть другой новый обработчик, который может, то текущий новый обработчик может установить другой new-handler на своем месте (вызвав set_new_handler). В следующий раз, когда оператор new вызовет функцию new-handler, она получит последнюю установленную.

(Разновидность этой темы заключается в том, что новый обработчик изменяет свое собственное поведение, поэтому при следующем вызове он делает что-то другое. Один из способов добиться этого — заставить новый обработчик изменить статические, специфичные для пространства имен или глобальные данные, влияющие на поведение нового обработчика.)

Удалить новый обработчик: это делается путем передачи нулевого указателя на set_new_handler. Если новый обработчик не установлен, operator new вызовет исключение ((преобразуется в) std::bad_alloc), если выделение памяти не удалось.

Вызвать исключение, конвертируемое в std::bad_alloc. Такие исключения не перехватываются operator new, но передаются на сайт, инициирующий запрос на память.

Не возвращать: по телефону abort или exit.

Чтобы реализовать специфичный для класса new_handler, мы должны предоставить классу свои собственные версии set_new_handler и operator new. set_new_handler класса позволяет клиентам указывать новый обработчик для класса (точно так же, как стандартный set_new_handlerпозволяет клиентам указывать глобальный новый обработчик). operator new класса гарантирует, что специфичный для класса новый обработчик используется вместо глобального нового обработчика при выделении памяти для объектов класса.

Теперь, когда мы лучше понимаем new_handler и set_new_handler, мы можем соответствующим образом изменить Требование №4 следующим образом:

Требование № 4 (расширенное).
Наш operator new должен попытаться выделить память более одного раза, вызывая функцию обработки новых после каждой ошибки. Здесь предполагается, что функция обработки новых данных может что-то сделать, чтобы освободить часть памяти. Только когда указатель на новую функцию обработки равен null, operator new выдает исключение.

Как и было обещано, цитата из Стандарта:
Раздел 3.7.4.1.3:

Функция распределения, которая не может выделить хранилище, может вызвать установленный в данный момент new_handler(18.4.2.2), если он есть. [Примечание: функция выделения, предоставляемая программой, может получить адрес текущего установленного new_handler с помощью функции set_new_handler (18.4.2.3).] Если функция выделения, объявленная с пустой спецификацией исключения (15.4), throw(), не может выделить память, она должен вернуть нулевой указатель. Любая другая функция распределения, которая не может выделить хранилище, должна указывать на сбой только путем создания исключения класса std::bad_alloc (18.4.2.1) или класса, производного от std::bad_alloc.

Вооружившись требованиями #4, давайте попробуем написать псевдокод для нашего new operator:

void * operator new(std::size_t size) throw(std::bad_alloc)
{  
   // custom operator new might take additional params(3.7.3.1.1)

    using namespace std;                 
    if (size == 0)                     // handle 0-byte requests
    {                     
        size = 1;                      // by treating them as
    }                                  // 1-byte requests

    while (true) 
    {
        //attempt to allocate size bytes;

        //if (the allocation was successful)

        //return (a pointer to the memory);

        //allocation was unsuccessful; find out what the current new-handling function is (see below)
        new_handler globalHandler = set_new_handler(0);

        set_new_handler(globalHandler);


        if (globalHandler)             //If new_hander is registered call it
             (*globalHandler)();
        else 
             throw std::bad_alloc();   //No handler is registered throw an exception

    }

}

Продолжение 2

Часть 3

... продолжение

Обратите внимание, что мы не можем получить новый указатель функции-обработчика напрямую, мы должны вызвать set_new_handler, чтобы узнать, что это такое. Это грубо, но эффективно, по крайней мере, для однопоточного кода. В многопоточной среде, вероятно, потребуется какая-то блокировка для безопасного манипулирования (глобальными) структурами данных, стоящими за функцией обработки новых. (Дополнительные цитаты/подробности приветствуются.)

Кроме того, у нас есть бесконечный цикл, и единственный выход из него — это успешное выделение памяти или выполнение новой функцией обработки одной из вещей, которые мы вывели ранее. Если new_handler не сделает одну из этих вещей, этот цикл внутри оператора new никогда не завершится.

Предупреждение: обратите внимание, что в стандарте (§3.7.4.1.3, процитированном выше) прямо не говорится, что перегруженный оператор new должен реализовывать бесконечный цикл, а просто говорится, что таково поведение по умолчанию. Таким образом, эта деталь открыта для интерпретации, но большинство компиляторов (GCC и Microsoft Visual C++) реализуют эту функцию цикла (вы можете скомпилировать приведенные ранее примеры кода). Также , поскольку автор C++, такой как Скотт Мейерс, предлагает этот подход, он достаточно разумен.

Специальные сценарии

Рассмотрим следующий сценарий.

class Base
{
    public:
        static void * operator new(std::size_t size) throw(std::bad_alloc);
};

class Derived: public Base
{
   //Derived doesn't declare operator new
};

int main()
{
    // This calls Base::operator new!
    Derived *p = new Derived;

    return 0;
}

Как объясняется в этом FAQ , распространенной причиной написания пользовательского диспетчера памяти является оптимизация выделения для объектов определенного класса, а не для класса или любого из его производных классов, что в основном означает, что наш новый оператор для базового класса обычно настраивается для объектов размера sizeof(Base) -ни больше, ни меньше.

В приведенном выше примере из-за наследования производный класс Derived наследует новый оператор базового класса. Это делает возможным вызов оператора new в базовом классе для выделения памяти для объекта производного класса. Лучший способ для нашего operator new справиться с этой ситуацией — перенаправить такие вызовы, запрашивающие неправильный объем памяти, на стандартный оператор new, например:

void * Base::operator new(std::size_t size) throw(std::bad_alloc)
{
    if (size != sizeof(Base))          // If size is "wrong,", that is, != sizeof Base class
    {
         return ::operator new(size);  // Let std::new handle this request
    }
    else
    {
         //Our implementation
    }
}

Обратите внимание, что проверка размера также включает наше требование №3. Это связано с тем, что все автономные объекты имеют ненулевой размер в C++, поэтому sizeof(Base) никогда не может быть нулевым, поэтому, если размер равен нулю, запрос будет переадресован на ::operator new, и гарантируется, что он обработает его стандартным образом.

Цитирование: от самого создателя C++, доктора Бьярна Страуструпа.