Обучающие курсы:

Обучение профессии "Разработчик C#" + стажировка в Mail.ru
Обучение профессии "Разработчик Python" + трудоустройство
Обучение профессии "Веб-разработчик" + стажировка в Mail.ru


Главная страница
Библиотека (скачать книги)
Скачать софт
Введение в программирование
Стандарты для C++
Уроки по C#
Уроки по Python
HTML
Веб-дизайн
Ассемблер в среде Windows
ActiveX
Javascript
Общее о Линукс
Линукс - подробно
Линукс - новое
Delphi
Паскаль для начинающих
Турбопаскаль
Новости
Партнеры
Наши предложения
Архив новостей







44. Предпочитайте функции, которые не являются ни членами, ни друзьями

Резюме

Там, где это возможно, предпочтительно делать функции не членами и не друзьями классов.

Обсуждение

Функции, не являющиеся членами или друзьями классов, повышают степень инкапсуляции путем снижения зависимостей: тело такой функции не может зависеть от закрытых и защищенных членов класса (см. рекомендацию 11). Они также разрушают монолитность классов, снижая связность (см. рекомендацию 33), и повышают степень обобщенности, так как сложно писать шаблоны, которые не знают, является ли интересующая нас операция членом данного типа или нет (см. рекомендацию 67).

Для определения того, должна ли функция быть реализована как член и/или друг класса, можно воспользоваться следующим алгоритмом:

// Если у вас нет выбора - делайте функцию членом.
Если функция представляет собой один из операторов =, ->,
    [] или (), которые должны быть членами,
то
    делайте данную функцию членом класса.
// Если функция может быть не членом и не другом либо
// имеются определенные преимущества от того, чтобы сделать
// ее не членом и другом
иначе если 1. функция требует левый аргумент иного типа
    (как, например, в случае операторов >> или <<)
    или 2. требует преобразования типов для левого аргумента,
    или 3. может быть реализована с использованием только
           открытого интерфейса класса
то
    сделайте ее не членом класса (и, при необходимости,
    в случаях 1 и 2 - другом)
    Если функция требует виртуального поведения,
    то
        добавьте виртуальную функцию-член для обеспечения
        виртуального поведения, и реализуйте функцию-не член
        с использованием этой виртуальной функции.
иначе
    сделайте ее функцией-членом.

Примеры

Пример. basic_string. Стандартный класс basic_string чересчур монолитен и имеет 103 функции-члена, из которых 71 без потери эффективности можно сделать функциями, не являющимися ни членами, ни друзьями класса. Многие из них дублируют функциональность, уже имеющуюся в качестве алгоритма стандартной библиотеки, либо представляют собой алгоритмы, которые могли бы использоваться более широко, если бы не были спрятаны в классе basic_string.

45. new и delete всегда должны разрабатываться вместе

Резюме

Каждая перегрузка void* operator new(parms) в классе должна сопровождаться соответствующей перегрузкой оператора void operator delete(void*, parms), где parms — список типов дополнительных параметров (первый из которых всегда std::size_t). To же относится и к операторам для массивов new[] и delete[].

Обсуждение

Обычно редко требуется обеспечить наличие пользовательских операторов new или delete, но если все же требуется один из них — то обычно требуются они оба. Если вы определяете специфичный для данного класса оператор Т::operator new, который выполняет некоторое специальное выделение памяти, то, вероятнее всего, вы должны определить и специфичный для данного класса оператор Т::operator delete, который выполняет соответствующее освобождение выделенной памяти.

Появление данной рекомендации связано с одной тонкой проблемой: дело в том, что компилятор может вызвать перегруженный оператор Т::operator delete даже если вы никогда явно его не вызываете. Вот почему вы всегда должны предоставлять операторы new и delete (атакже операторы new[] и delete[]) парами.

Пусть вы определили класс с пользовательским выделением памяти:

class T {
    // ...
    static void* operator new(std::size_t);
    static void* operator new(std::size_t, CustomAllocator&);

    static void operator delete(void*, std::size_t);
};

Вы вводите простой протокол для выделения и освобождения памяти.

  • Вызывающий код может выделять объекты типа T либо при помощи распределителя по умолчанию (используя вызов new T), либо при помощи пользовательского распределителя (вызов new(alloc) T, где alloc — объект типа CustomAllocator).

  • Единственный оператор delete, который может быть использован вызывающим кодом— оператор по умолчанию operator delete(size_t), так что, конечно, вы должны реализовать его так, чтобы он корректно освобождал память, выделенную любым способом.

Пока все в порядке.

Однако компилятор может скрыто вызвать другую перегрузку оператора delete, а именно Т::operator delete(size_t, CustomAllocator&). Это связано с тем, что инструкция

T* p = new(alloc) T;
на самом деле разворачивается в нечто наподобие

// Сгенерированный компилятором код для
// инструкции T* p = new(alloc) T;
//
void* __compilerTemp = T::operator new(sizeof(T), alloc);
T* р;
try {
    p = new (__compilerTemp) T; // Создание объекта Т по
                                // адресу __compilerTemp
}
catch(...) {                    // Сбой в конструкторе...
    T::operator delete(__compilerTemp, sizeof(T), alloc);
    throw;
}

Итак, компилятор автоматически вставляет код вызова соответствующего оператора Т::operator delete для перегруженного оператора T::operator new, что совершенно логично, если выделение памяти прошло успешно, но произошел сбой в конструкторе. "Соответствующая" сигнатура оператора delete имеет вид void operator delete(void*, параметры_оператора_new).

Теперь перейдем к самому интересному. Стандарт C++ гласит, что приведенный выше код будет генерироваться тогда и только тогда, когда реально существует соответствующая перегрузка оператора delete. В противном случае код вообще не будет вызывать никакого оператора delete при сбое в конструкторе. Другими словами, при сбоях в конструкторе мы получим утечку памяти. Из шести проверенных нами распространенных компиляторов только два выводили предупреждение в такой ситуации. Вот почему каждый перегруженный оператор void* operator new(parms) должен сопровождаться соответствующей перегрузкой void operator delete(void*, parms).

Исключения

Размещающий оператор new

void* T::operator new(size_t, void* p) { return p; }

не требует наличия соответствующего оператора delete, поскольку реального выделения памяти при этом не происходит. Все протестированные нами компиляторы не выдавали никаких предупреждений по поводу отсутствия оператора void T::operator delete(void*, size_t, void*).



 
 

Библиотека программиста. 2009.
Администратор: admin@programmer-lib.ru