Анимация
JavaScript
|
Главная Библионтека Недостаток такой методики очевиден - она слишком полагается на соблюдение всех правил программистом. Можно сделать получше. Укзатели с подсчетом ссылок Давайте усовершенствуем базовый класс RefCount и создадим модифицированный шаблон умного указателя для любых классов, производных от RefCount. template <c1ass Type> class CP { "Указатель с подсчетом ссылок" private: Type* pointee; public: CP(Type* p) : pointee(p) { pointee->Grab(); } CP(const CP<Type>& cp) : pointee(cp.pointee) { pointee->Grab(); } ~CP() { ponintee->Re1ease(); } CP<Type>& operator=(const CP<Type>& cp) if (this == &cp) return *this; pointee->Re1ease(); pointee = cp.pointee; pointee->Grab(); return *this; Type* operator->() { return pointee; } Если весь клиентский код будет обращаться к классам с подсчетом ссылок через этот или аналогичный шаблон, подсчет ссылок осуществляется автоматически. При каждом создании новой копии указателя происходит автоматический вызов Grab(). При каждом уничтожении указателя его деструктор уменьшает значение счетчика. Единственная опасность заключается в том, что клиент обойдет умный указатель. С этой проблемой можно справиться с помощью производящих функций целевого класса. class Foo : public RefCount { private: Foo(); Вместе с другими конструкторами public: static CP<Foo> make(); Создаем экземпляр Далее следует интерфейс Foo Тем самым мы гарантируем, что доступ к Foo будет осуществляться только через указатель с подсчетом ссылок. Обратите внимание: это не ведущий, а самый обычный умный указатель. Ведущие указатели с подсчетом ссылок Даже если вы не хотите модифицировать конкретный класс, чтобы сделать его производным от RefCount (например, если он имеет критические требования по быстродействию и объему или входит в коммерческую библиотеку классов), не отчаивайтесь. Подсчет ссылок можно переместить в ведущий указатель. template <c1ass Type> class CMP { "Ведущий указатель с подсчетом ссылок" private: Type* pointee; unsigned long count; public: CMP() : pointee(new Type), count(0) {} CMP(const CMP<Type>& cmp) : pointee(new Type(*(cmp.pointee))), count(0) {} ~CMP() { delete pointee; } Независимо от счетчика CMP<Type>& operator=(const CMP<Type>& cmp) if (this == &cmp) return *this; delete pointee; pointee = new Type(*(cmp.pointee)); return *this; Type* operator->() const { return pointee; } void Grab() { count++; } void Re1ease() if (count > 0) count-- ; if (count <= 0) delete pointee; delete this; В сущности, это равносильно объединению старого шаблона ведущего указателя с базовым классом RefCount. Подсчет ссылок уже не выделяется в отдельный класс, но зато нам снова приходится полагаться на правильное поведение программистов - существ, к сожалению, несовершенных. Дескрипторы с подсчетом ссылок На сцену выходит нечто новое: дескриптор (handle) с подсчетом ссылок. По отношению к шаблону CMP он станет тем же, чем CP был для RefCount, - то есть он автоматически вызывает функции Grab() и Re1ease() в своих конструкторах, деструкторе и операторе =. template <c1ass Type> class CH { "Дескриптор с подсчетом ссылок" private: CMP<Type>* pointee; public: CH(CMP<Type>* p) : pointee(p) { pointee->Grab(); } CH(const CH<Type>& ch) : pointee(ch.pointee) { pointee->Grab(); } ~CH() { pointee->Re1ease(); } CH<Type>& operator=(const CH<Type>& ch) if (this == &ch) return *this; if (pointee == ch.pointee) return *this; pointee->Re1ease(); pointee = ch.pointee; pointee->Grab(); return *this; CMP<Type> operator->() { return *pointee; } Если использовать дескрипторы в сочетании с ведущими указателями, можно выбрать, для каких экземпляров класса следует подсчитывать ссылки, а какие экземпляры должны управляться другим способом. Трудности подсчета ссылок Все выглядит так просто; однако без ложки дегтя дело все же не обходится. Подсчет ссылок обладает одним очень распространенным недостатком - зацикливанием. Представьте себе ситуацию: объект А захватил объект В (то есть вызвал для него функцию Grab()), а объект В сделал то же самое для объекта А. Ни на А, ни на В другие объекты не ссылаются. Здравый смысл подсказывает, что А следует удалить вместе с В, но они продолжают существовать, поскольку их счетчики ссылок так и не обнуляются. Обидно, да? Подобное зацикливание возникает сплошь и рядом. Оно может относиться не только к парам объектов, но и целым подграфам. A -> B -> C -> D -> A, но никто за пределами этой группы не ссылается ни на один из этих объектов. Группа словно плывет на «Летучем Голландце», построенном в эпоху высоких технологий и обреченном на вечные скитания в памяти. Существует несколько стратегий борьбы с зацикливаниями. Все они не обладают особой универсальностью, и в вашей конкретной ситуации это может привести к отказу от подсчета ссылок. Как правило, встречаясь с проблемой циклических ссылок, стоит рассмотреть более хитроумные приемы, описанные в двух последних главах. Как видите, мысль об отказе от подсчета ссылок приходит довольно быстро. Декомпозиция Предположим, А захватывает В, а затем В захватывает некоторый компонент А: class A { private: Foo* foo; B* b; Если сделать так, чтобы В выполнял захват в функции foo, проблем не возникает. Когда последняя ссылка на A ликвидируется, его счетчик становится равным 0, поскольку В его не увеличивает. Для этого придется проявить некоторую изрядную изобретательность при кодировании, к тому же дизайн сильно зависит от особенностей конкретных объектов, но на удивление часто он решает проблему зацикливания. Сильные и слабые дескрипторы Предположим, ссылка А на В создавалась через Grab(), а ссылка В на А - нет. В тот момент, когда исчезнет последняя ссылка на А из внешнего мира, подсчет ссылок для обоих объектов пары прекратит их существование. На этой идее основано различие между силънгми (strong) и слабыми (weak) дескрипторами или указателями с подсчетом ссылок. Описанный выше шаблон CH будет относиться к сильным дескрипторам, поскольку поддерживает счетчик ссылок. Обычный шаблон дескриптора (без вызова Grab и Release) будет относиться к слабым. Если спроектировать архитектуру объектов так, чтобы не существовало циклических подграфов, содержащих исключительно сильные дескрипторы, то вся схема подсчета ссылок снова возвращается в игру. Самая распространенная ситуация с таким решением - иерархия целое/часть, в которой пары удаляются при удалении целого. Целые поддерживают сильные ссылки, части - слабые. Подсчет ссылок и ведущие указатели Одно из самых распространенных и полезных применений подсчета ссылок заключается в управлении ведущими указателями. В предыдущих главах эта тема упоминалась неоднократно. Дескрипторы живут в стеке и потому автоматически уничтожаются при сборке мусора, выполняемой компилятором. Однако ведущие указатели (по тем же причинам, что и объекты) обычно приходится создавать в куче. Как узнать, когда следует удалять ведущий указатель? Подсчет ссылок упрощает эту задачу. 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 [ 66 ] 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 |