Здравствуйте, MaximE, Вы писали:

ME>прочитай про boost::intrusive_ptr<>. Менее тяжеловесное решение для твоей задачи придумать сложно.

Меня не интересует автоматическое освобождение памяти (и даже наоборот, я хочу убивать объекты явно, даже при наличии ссылок на них) — самое главное — сделать так, чтобы у ВСЕХ этих ссылок автоматически появился однозначный признак невалидности.


Может, я чего-то недопонимаю?

Здравствуйте, Аноним, Вы писали:

А>Здравствуйте, _chipset, Вы писали:

_>>Здравствуйте, Аноним, Вы писали:

А>>>Добрый день,

А>>>Реализованы ли смарт поинтеры в STL'е?
_>>Что то типа этого.. auto_ptr

А>его же вроде не рекомендуется использовать
А>даже запрещено комитетом по стандартизации

Да, и за это предусмотрена уголовная ответственность.

Здравствуйте, isek, Вы писали:

I>Здравствуйте, MaximE, Вы писали:

ME>>прочитай про boost::intrusive_ptr<>. Менее тяжеловесное решение для твоей задачи придумать сложно.

I>Меня не интересует автоматическое освобождение памяти (и даже наоборот, я хочу убивать объекты явно, даже при наличии ссылок на них) — самое главное — сделать так, чтобы у ВСЕХ этих ссылок автоматически появился однозначный признак невалидности.

I>Может, я чего-то недопонимаю?

Используй intrusive_ptr и добавь объекту метод bool is_usable(). Изменять все ссылки на объект, когда объект был разрушен, будет более затратно по ресурсам.

Здравствуйте, MaximE, Вы писали:


ME>Используй intrusive_ptr и добавь объекту метод bool is_usable().
C этим я поразгребаюсь.


ME>Изменять все ссылки на объект, когда объект был разрушен, будет более затратно по ресурсам.
Ну так я ж изначально (http://www.rsdn.ru/Forum/Message.aspx?mid=1428709&amp;only=1

Автор: isek
Дата: 11.10.05

) предлагал изменять не ВСЕ ССЫЛКИ, а одну ячеку — промежуточную, хранящую указатель на объект!..

Здравствуйте, Sergey, Вы писали:

j>> похоже, мы наблюдаем исчезновение термина Smart pointer и употребление
j>> его в качестве разговорного названия boost::smart_ptr

S>А что за boost::smart_ptr? boost::shared_prt знаю, boost::scoped_ptr знаю, а
S>вот boost::smart_ptr встречать как-то не доводилось...

boost::shared_ptr, конечно же

You will always get what you always got
  If you always do  what you always did

Здравствуйте, isek, Вы писали:

I>Меня не интересует автоматическое освобождение памяти (и даже наоборот, я хочу убивать объекты явно, даже при наличии ссылок на них) — самое главное — сделать так, чтобы у ВСЕХ этих ссылок автоматически появился однозначный признак невалидности.

А кто будет следить за временем жизни признака валидности?
Если он совмещён с объектом, то после удаления память инвалидируется, в том числе и этот признак.

Налицо распределённое владение признаком валидности. Скорее всего, неинтрузивное.
Делаем просто: вводим структуру, хранящую указатель на объект — и используем shared_ptr на эту структуру.
Можно вообще обойтись shared_ptr<T*> — но это менее безопасно.

template<class T>
class wanted // dead or alive :))
{
  T* p_;
public:
  nondeleteable_ptr<T> ptr() const { return p_; } // запретим удалять объект по указателю
  bool alive() const { return p_!=0; }

  wanted() : p_(0) {}
  wanted(T* p) : p_(p) {}
  ~wanted() { assert(!alive()); } // раз мы можем удалять объект вручную, то обяжем это делать

  T* detach() { T* p=p_; p_=0; return p; }
  void release() { delete detach(); }

  void attach(T* p) { if(p!=p_) { release(); p_=p; } }
  wanted& operator=(T* p) { attach(p); }

  // ну и хватит, наверное
};

template<class T>
struct wanted_traits
{
  typedef wanted<T> wrapper;
  typedef shared_ptr<wrapper> pointer;

  pointer make(T* p) { return pointer(new wrapper(p)); }
};

...............
wanted_traits<int>::pointer p = wanted_traits<int>::make(new int(123));
wanted_traits<int>::pointer q = p;
assert(q->alive());
*p->ptr() = 456;
assert(*q->ptr() == 456);
q->release();
assert(!p->alive());
...............

Здравствуйте, Кодт, Вы писали:

К>А кто будет следить за временем жизни признака валидности?
К>Если он совмещён с объектом, то после удаления память инвалидируется, в том числе и этот признак.

К>Налицо распределённое владение признаком валидности.

Сто пудов. "Признак невалидности" лежит где-то отдельно от самого объекта (во всяком случае, не деструктируется вместе с ним).

К>Скорее всего, неинтрузивное.
А по-русски?


К>Делаем просто: вводим структуру, хранящую указатель на объект — и используем shared_ptr на эту структуру.
К>Можно вообще обойтись shared_ptr<T*> — но это менее безопасно.
В любом случае все "пользователи" объекта хранят в себе более, чем long — я правильно понимаю?
Я преследую цель хранить в качестве "ссылок на объект" по-прежнему 4 байта, но так, чтобы обнулить их одним махом, нигде не помня, сколько таких "пользователей", хранящих у себя указатель на дестуктируемый объект (http://www.rsdn.ru/Forum/Message.aspx?mid=1428709&amp;only=1

Автор: isek
Дата: 11.10.05

)

Господи, когда же на компах будет столько памяти, чтоб забыть о С++ как о страшном сне?!?

(нуу, хотя бы в прикладных задачах...)

Здравствуйте, isek, Вы писали:

К>>Налицо распределённое владение признаком валидности.

I>Сто пудов. "Признак невалидности" лежит где-то отдельно от самого объекта (во всяком случае, не деструктируется вместе с ним).

К>>Скорее всего, неинтрузивное.
I>А по-русски?

Интрузивное — когда сам указуемый обеспечивает некоторое свойство (в данном случае — подсчёт ссылок на себя).
Неинтрузивное — когда указуемуый может об этом свойстве не знать.

К>>Делаем просто: вводим структуру, хранящую указатель на объект — и используем shared_ptr на эту структуру.
К>>Можно вообще обойтись shared_ptr<T*> — но это менее безопасно.
I>В любом случае все "пользователи" объекта хранят в себе более, чем long — я правильно понимаю?

При чём здесь long? Они хранят указатель (умный указатель, естественно — чтобы вручную не возиться) на структуру-посредника.

I>Я преследую цель хранить в качестве "ссылок на объект" по-прежнему 4 байта, но так, чтобы обнулить их одним махом, нигде не помня, сколько таких "пользователей", хранящих у себя указатель на дестуктируемый объект (http://www.rsdn.ru/Forum/Message.aspx?mid=1428709&amp;only=1

Автор: isek
Дата: 11.10.05

)

В этом случае лучше сделать интрузивный подсчёт ссылок — т.е. структура-посредник сама считает, сколько у неё пользователей.
В качестве умного указателя — например, intrusive_ptr. (Его размер равен размеру голого указателя).

template<class T>
class wanted
{
  ..... всё что уже сказано ранее .....

private:
  int refcount; // инициализируется нулём!

  typedef wanted<T> self_type;
  friend void intrusive_ptr_add_ref<self_type>(self_type* p);
  friend void intrusive_ptr_release<self_type>(self_type* p);
};
// ответная часть к boost::intrusive_ptr
template<class T> void intrusive_ptr_add_ref< wanted<T> >(wanted<T>* p) { ++(p->refcount); }
template<class T> void intrusive_ptr_release< wanted<T> >(wanted<T>* p) { if(--(p->refcount) == 0) delete p; }

template<class T>
struct wanted_traits
{
  typedef wanted<T> wrapper;
  typedef boost::intrusive_ptr<wrapper> pointer;
  pointer make(T* p) { return pointer(new wrapper(p)); }
};

Здравствуйте, isek, Вы писали:

I>(нуу, хотя бы в прикладных задачах...)

Пиши на Лиспе. Там вообще нет такого понятия, как указатели или ссылки, а работать он может хоть на 64Кбайтах.

Здравствуйте, isek, Вы писали:

I>(нуу, хотя бы в прикладных задачах...)

В данный момент имею на домашнем ПК 1Гиг оперативы, которая купленна на деньги, заработанные программированием на С++.

Парадокс однака

srggal>В данный момент имею на домашнем ПК 1Гиг оперативы, которая купленна на деньги, заработанные программированием на С++.
Согласен. То я в порыве отчаяния ляпнул...

Здравствуйте, Кодт, Вы писали:


К>Пиши на Лиспе. Там вообще нет такого понятия, как указатели или ссылки, а работать он может хоть на 64Кбайтах.
К>

Ну чё так злостно?
На С# или Java!
Или на JScript (это уже шутка — разумеется, особо серьёзного не напишешь).

Ну да ладно, то я погорячился...