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

M>Нужно корретно выйти из функции, осободив все ранее созданные обьекты.
Это велосипед но как иначе обяснить как это все работает.

template<class P_Type>
class T_Smart
{
    P_Type* m_ptr;
    //блокируем копирование
    T_Smart(const T_Smart& obj);
    T_Smart& operator=(const T_Smart& obj);
public:
    //захватываем готовый указатель
    //для вазова конструктора с параметрвми
    //T_Smart<Foo> foo=new Foo(p1, p2, p3);
    T_Smart(P_Type* ptr)
        :m_ptr(ptr)
    {}
    //создает новай обьект
    //конструктор по умолчанию
    T_Smart()
        :m_ptr(new P_Type)
    {}
    //разрушает обьект при выходе из области видимости
    ~T_Smart()
    {
        delete m_ptr;
    }
    //приведение к указателю на тип обьекта
    operator P_Type*()
    {
        return m_ptr;
    }
    //обращение к мемберам обьекта
    //foo->SomeFunc();
    P_Type* operator->()
    {
        return m_ptr;
    }
    //Отцепляет обьект например для возвращения из функции
    P_Type* Detach()
    {
        P_Type* t=m_ptr;
        m_ptr=0;
        return t;
    }
};

Для других ресурсов аналогично.
Будут вопросы спрашивай.

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

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

M>
ssm>>истина лежит в использовании, к примеру, std::auto_ptr
M>Я плохо знаю C++, что такое std::auto_ptr?
M>Как это будет выглядеть, хотя бы примерно?

это класс, который всасывает указателдь на что-нибудь (созданный при помощи new), а в деструкторе он его удаляет при помощи delete:

struct A
{
   int i;
   double j;
};
void f()
{
   std::auto_ptr<A> ap(new A); // создали
   ap->i = 7;                  // работаем, как с обычным указателем
   ap->j = 3.14;
}                              // а здесь объект ap выходит из области видимости и удаляется,
                               // что приводит к вызову деструктора, а в нем вызовется delete.
                               // то же самое произойдет при return или возбуждении исключения.

а то, что delete не делает ничего, если ему подсунуть нулевой указатель, то вообще можно быть спокойным и не бояться, что при такой автоматической очистке произойдет что-то не то.

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

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

ssm>>>истина лежит в использовании, к примеру, std::auto_ptr
Я гдето слышал что изи этого оператора его в STL ные контейнеры совать нельзя

    _Ty& operator*() const _THROW0()
        {    // return designated value
        return (*get());
        }

В смысле будет падать

    std::vector<std::auto_ptr<Foo> > vec;

Можно так но у ATL::CAdapt такой дурацкий интерфейс что проще написать свой врапер и не мучаться.

    std::vector<ATL::CAdapt<std::auto_ptr<Foo> > > vec;

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

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

ssm>>>>истина лежит в использовании, к примеру, std::auto_ptr
WH>Я гдето слышал что изи этого оператора его в STL ные контейнеры совать нельзя

так и есть, на самом деле комитет старается сделать все возможное, чтобы предотвратить использование auto_ptr в стандартных контейнерах, и именно для этого оператор присваивания и конструктор копирования принимают неконстантный объект

WH>Можно так но у ATL::CAdapt такой дурацкий интерфейс что проще написать свой врапер и не мучаться.
WH>

WH>    std::vector<ATL::CAdapt<std::auto_ptr<Foo> > > vec;
WH>

проще,наверное, будет использование интелектуальных указателей с подсчетом ссылок, например boost::smart_ptr, а не изобретение велосипеда. но суть дела в том, что у auto_ptr свои задачи, с которыми он отлично справляется

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

ssm>так и есть, на самом деле комитет старается сделать все возможное, чтобы предотвратить использование auto_ptr в стандартных контейнерах, и именно для этого оператор присваивания и конструктор копирования принимают неконстантный объект

прошу прощения, конечно же неконстантную ссылку на неконстантный объект:

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

auto_ptr нельзя использовать в контейнерах из-за того что при копировании\присваивании меняется ownership!

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

ssm>>>>истина лежит в использовании, к примеру, std::auto_ptr
WH>Я гдето слышал что изи этого оператора его в STL ные контейнеры совать нельзя
WH>

WH>    _Ty& operator*() const _THROW0()
WH>        {    // return designated value
WH>        return (*get());
WH>        }
WH>

WH>В смысле будет падать
WH>

WH>    std::vector<std::auto_ptr<Foo> > vec;
WH>

WH>Можно так но у ATL::CAdapt такой дурацкий интерфейс что проще написать свой врапер и не мучаться.
WH>

WH>    std::vector<ATL::CAdapt<std::auto_ptr<Foo> > > vec;
WH>

WH>