Добрый день.

Была поставлена задача заменить такой класс:

template < class T, class ThreadingModel = ::Loki::ObjectLevelLockable<T> >
class RefCounted : public ThreadingModel {
public:
    RefCounted() : m_refCount(0) {}
protected:
    ~RefCounted() {}  // Note non-virtual
    
public:
    void ref() const;
    void unref() const;
    int getRefCount() const;

private:
    RefCounted(const ClassType&);
    void operator=(const ClassType&);
};

чем-нибудь из boost'а.

Сам класс используется так:

  class MyClass : public RefCounted<MyClass> {
  public:
     MyClass();
     ~MyClass();
  public:
     ...
  };

Насколько я понимаю, для этой цели более всего подходит shared_ptr<MyClass>.
Но, возможно, есть более простой в реализации вариант замены — при использовании shared_ptr нужно будет везде менять отношение наследования на отношение использования.

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

Тут зависит как используется MyClass.
Если вам нужно общее владение, то boost::shared_ptr подойдет, но нужно иметь ввиду, что требуется выделение памяти.
( Что впрочем не обязательно shared_ptr

Автор: _nn_
Дата: 30.08.06

, лучше ,конечно , не делать так )

Может вам подойдет boost::intrusive_ptr ?

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

__>Тут зависит как используется MyClass.
__>Если вам нужно общее владение, то boost::shared_ptr подойдет, но нужно иметь ввиду, что требуется выделение памяти.
Нет, общее владение вроде как не нужно.

__>( Что впрочем не обязательно shared_ptr

Автор: _nn_
Дата: 30.08.06

, лучше ,конечно , не делать так )
Это для данного случая слишком сильно .


__>Может вам подойдет boost::intrusive_ptr ?
Тоже вариант.
А насколько корректно использование здесь shared_count из boost/smart_ptr/detail/shared_count.hpp?

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

__>>Может вам подойдет boost::intrusive_ptr ?
__>Тоже вариант.
__>А насколько корректно использование здесь shared_count из boost/smart_ptr/detail/shared_count.hpp?

Все что есть в бусте можно использовать.
Классы которые лежат в директории details не дают гарантию интерфейса, т.е. могут измениться в следующей версии хоть полностью.

Почитайте туториалы и примеры boost smart ptr, может найдется то, что вам нужно.

В любом случае если вам он подходит и сокращает время, то надо юзать

Что за "отношение использования"? Агрегация, что ли? Чтобы использовать shared_ptr, тебе нужно будет просто убрать везде наследование от старого поинтера, и все.

Здравствуйте, Тролль зеленый и толстый, Вы писали:

ТЗИ>Что за "отношение использования"? Агрегация, что ли? Чтобы использовать shared_ptr, тебе нужно будет просто убрать везде наследование от старого поинтера, и все.

Да, правильно, затупил.

Нужно будет такого:

class MyClass : public RefCounted<MyClass> {
    ...
};
MyClass* SomeFunction();

заменить вот таким:

typedef boost::shared_ptr<MyClass> MyClassPtr;
MyClassPtr SomeFunction();

Но поскольку классы используются в местах, критичных по производительности, вместо shared_ptr буду использовать intrusive_ptr.

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

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

__>>>Может вам подойдет boost::intrusive_ptr ?
__>>Тоже вариант.
__>>А насколько корректно использование здесь shared_count из boost/smart_ptr/detail/shared_count.hpp?

__>Все что есть в бусте можно использовать.
__>Классы которые лежат в директории details не дают гарантию интерфейса, т.е. могут измениться в следующей версии хоть полностью.

__>Почитайте туториалы и примеры boost smart ptr, может найдется то, что вам нужно.

__>В любом случае если вам он подходит и сокращает время, то надо юзать

Ясно, спасибо

Решил таки использовать intrusive_ptr. Для упрощения работы с ним написал такой вот класс:

// initialCounterValue equal to zero if we use intrusive_ptr<MyClass> p(new MyClass); 
// initialCounterValue equal to one if we use intrusive_ptr<MyClass> p(new MyClass, false); 
template<typename T, long initialCounterValue = 0>
class RefCountable {
    friend void intrusive_ptr_add_ref(RefCountable<T> const* p) {
        // increase reference count
        ::InterlockedIncrement(&p->m_refCount);
    }

    friend void intrusive_ptr_release(RefCountable<T> const* p) {
        // decrease reference count and delete object if reference count became equal to zero
        if (0 == ::InterlockedDecrement(&p->m_refCount)) {
            delete p;
        }
    }

protected:
    // constructor
    RefCountable() : m_refCount(initialCounterValue) {}

    // copy constructor
    RefCountable(RefCountable const&) : m_refCount(initialCounterValue) {}

    // assign operator
    RefCountable& operator=(RefCountable const&) {
        return *this;
    }

    // virtual destructor
    virtual ~RefCountable() {}

private:
    long mutable m_refCount;
};

Мне только не нравится, что наследование от него должно быть обязательно public.

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

__>Мне только не нравится, что наследование от него должно быть обязательно public.
Но в вашем RefCountable нет открытых данных или методов — соответственно для вас это никакой роли не сыграет.
Даже если кто-то приведет ваш конечный класс к RefCountable ничего осмысленного с ним сделать все равно не сможет.