Как обработать отказ выпустить ресурс, который содержится в интеллектуальном указателе?

Если при освобождении некоторого ресурса может произойти сбой , то деструктор, очевидно, является неправильной абстракцией для использования. Деструкторы предназначены для обязательной очистки, независимо от обстоятельств. Метод close () (или как вы хотите его назвать), вероятно, единственный выход.

Но подумайте об этом повнимательнее. Если освободить ресурс не удается , что вы можете сделать? Можно ли исправить такую ​​ошибку? Если да, то какая часть вашего кода должна с этим справиться? Способ восстановления, вероятно, сильно зависит от приложения и связан с другими частями приложения. Маловероятно, что вы действительно хотите, чтобы это происходило автоматически , в произвольном месте кода, в котором произошло освобождение ресурса и возникновение ошибки. Абстракция общего указателя на самом деле не моделирует то, чего вы пытаетесь достичь. Если да, то вам явно необходимо создать свою собственную абстракцию, которая моделирует запрошенное вами поведение. Злоупотреблять общими указателями, чтобы делать то, чего они не должны делать, - неправильный путь.

Также прочтите это .

РЕДАКТИРОВАТЬ:
Если все, что вы хотите сделать, это проинформировать пользователя о том, что произошло до сбоя, подумайте о том, чтобы поместить сокет в другой объект-оболочку , который будет вызывать удаление при его уничтожении перехватывайте любые возникшие исключения и обрабатывайте их, показывая пользователю окно сообщения или что-то еще. Затем поместите этот объект-оболочку в boost :: shared_ptr .

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

Ваше желание использовать объект RAII - хорошее, но умного указателя просто недостаточно для этой задачи. То, что вам нужно, должно быть еще умнее. Вам нужно что-то, что может восстановиться, если не рухнет полностью. Деструктора для такого интерфейса недостаточно.

Вы действительно представляете себе неправильное использование, когда кто-то может заставить ресурс иметь дескриптор, но быть недействительным. Тип ресурса, с которым вы здесь имеете дело, просто поддается решению этой проблемы. Есть много способов подойти к этому. Один из методов может заключаться в использовании идиомы дескриптора / тела вместе с шаблоном состояния. Реализация интерфейса может находиться в одном из двух состояний: подключенном или неподключенном. Дескриптор просто передает запросы во внутреннее тело / состояние. Connected работает как обычно, неподключенный выдает исключения / утверждения во всех применимых запросах.

Для уничтожения дескриптора этой вещи нужна другая функция, кроме ~. Вы можете рассмотреть функцию destroy (), которая может вызывать. Если вы поймаете ошибку при ее вызове, вы не удаляете дескриптор, а вместо этого решаете проблему любым способом, который вам нужен для конкретного приложения.Если вы не поймаете ошибку от destroy (), вы позволите дескриптору выйти из области видимости, сбросить его или что-то еще. Затем функция destroy () определяет счетчик ресурсов и пытается освободить внутренний ресурс, если этот счетчик равен 0. В случае успеха дескриптор переходит в неподключенное состояние, в случае сбоя он генерирует обнаруживаемую ошибку, которую клиент может попытаться обработать, но уходит. ручка в подключенном состоянии.

Это не совсем тривиальная вещь для написания, но то, что вы хотите сделать, внести исключения в уничтожение, просто не сработает.

Вообще говоря, если закрытие ресурса в стиле C не работает, то это скорее проблема с API, чем проблема в вашем коде. Однако, я бы хотел сделать следующее: если уничтожение не удалось, добавить его в список ресурсов, которые нужно уничтожить/очистить повторно позже, скажем, при выходе из приложения, периодически, или когда другие подобные ресурсы будут уничтожены, а затем попытаться уничтожить повторно. Если таковые останутся в произвольное время, выдать ошибку пользователю и выйти.

Цитата Херба Саттера, автора из "Exceptional C ++" (из здесь ):

Если деструктор генерирует исключение, Плохие вещи могут случиться. Конкретно, рассмотрите следующий код:

//  The problem
//
class X {
public:
  ~X() { throw 1; }
};

void f() {
  X x;
  throw 2;
} // calls X::~X (which throws), then calls terminate()

Если деструктор выдает исключение в то время как другое исключение уже активен (т.е. во время разматывания стопки), программа завершена. Это обычно не очень хорошо.

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

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

Как объявлено в вопросе, отредактируйте 3:

Вот еще одно решение, которое, насколько я могу судить, соответствует требования в вопросе. Это похоже на описанное решение в исходном вопросе, но использует boost :: shared_ptr вместо настраиваемый умный указатель.

Основная идея этого решения - предоставить release () операция на shared_ptr . Если мы сможем заставить shared_ptr отказаться от право собственности, мы можем вызвать функцию очистки, удалить объект, и генерировать исключение, если во время очистки произошла ошибка.

Boost имеет хорошо причина не предоставлять операцию release () для shared_ptr :

shared_ptr не может передавать право собственности, если оно не является unique (), потому что другая копия все равно уничтожит объект.

Примите во внимание:

 shared_ptr  a (новый int);
shared_ptr  b (а); // a.use_count () == b.use_count () == 2
int * p = a.release ();

// Кому сейчас принадлежит p? b по-прежнему будет вызывать удаление для него в своем деструкторе.

Кроме того, указатель, возвращаемый функцией release (), будет трудно надежно освободить, так как источник shared_ptr мог быть создан с настраиваемым удалением.

Первый аргумент против операции release () заключается в том, что природа shared_ptr , многие указатели совместно владеют объектом, так что ни один из них не может просто отказаться от этой собственности.Но что если функция release () вернула нулевой указатель, если был еще ссылки остались? shared_ptr может надежно определить это без условий гонки.

Второй аргумент против операции release () заключается в том, что если пользовательский удалитель был передан в shared_ptr , вы должны использовать его для освободить объект, а не просто удалить его. Но релиз () может вернуть объект функции в дополнение к необработанному указателю на разрешить вызывающей стороне надежно освободить указатель.

Однако в нашем конкретном сценарии пользовательские удалители не будут проблема, потому что нам не нужно иметь дело с произвольным обычаем удалители. Это станет яснее из приведенного ниже кода.

Обеспечение операции release () для shared_ptr без изменения его реализация, конечно, невозможна без взлома. В hack, который используется в приведенном ниже коде, полагается на локальную переменную потока чтобы предотвратить фактическое удаление объекта нашим пользовательским средством удаления.

Тем не менее, вот код, состоящий в основном из заголовка Resource.hpp плюс небольшой файл реализации Resource.cpp . Примечание что он должен быть связан с -lboost_thread-mt из-за локальная переменная потока.

// ---------------------------------------------------------------------
// Resource.hpp
// ---------------------------------------------------------------------

#include <boost/assert.hpp>
#include <boost/ref.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/thread/tss.hpp>


/// Factory for a resource.
template<typename T>
struct ResourceFactory
{
    /// Create a resource.
    static boost::shared_ptr<T>
    create()
    {
        return boost::shared_ptr<T>(new T, ResourceFactory());
    }

    template<typename A1>
    static boost::shared_ptr<T>
    create(const A1& a1)
    {
        return boost::shared_ptr<T>(new T(a1), ResourceFactory());
    }

    template<typename A1, typename A2>
    static boost::shared_ptr<T>
    create(const A1& a1, const A2& a2)
    {
        return boost::shared_ptr<T>(new T(a1, a2), ResourceFactory());
    }

    // ...

    /// Destroy a resource.
    static void destroy(boost::shared_ptr<T>& resource);

    /// Deleter for boost::shared_ptr<T>.
    void operator()(T* resource);
};


namespace impl
{

// ---------------------------------------------------------------------

/// Return the last reference to the resource, or zero. Resets the pointer.
template<typename T>
T* release(boost::shared_ptr<T>& resource);

/// Return true if the resource should be deleted (thread-local).
bool wantDelete();

// ---------------------------------------------------------------------

} // namespace impl


template<typename T>
inline
void ResourceFactory<T>::destroy(boost::shared_ptr<T>& ptr)
{
    T* resource = impl::release(ptr);

    if (resource != 0) // Is it the last reference?
    {
        try
        {
            resource->close();
        }
        catch (...)
        {
            delete resource;

            throw;
        }

        delete resource;
    }
}

// ---------------------------------------------------------------------

template<typename T>
inline
void ResourceFactory<T>::operator()(T* resource)
{
    if (impl::wantDelete())
    {
        try
        {
            resource->close();
        }
        catch (...)
        {
        }

        delete resource;
    }
}


namespace impl
{

// ---------------------------------------------------------------------

/// Flag in thread-local storage.
class Flag
{
public:
    ~Flag()
    {
        m_ptr.release();
    }

    Flag& operator=(bool value)
    {
        if (value != static_cast<bool>(*this))
        {
            if (value)
            {
                m_ptr.reset(s_true); // may throw boost::thread_resource_error!
            }
            else
            {
                m_ptr.release();
            }
        }

        return *this;
    }

    operator bool()
    {
        return m_ptr.get() == s_true;
    }

private:
    boost::thread_specific_ptr<char> m_ptr;

    static char* s_true;
};

// ---------------------------------------------------------------------

/// Flag to prevent deletion.
extern Flag t_nodelete;

// ---------------------------------------------------------------------

/// Return the last reference to the resource, or zero.
template<typename T>
T* release(boost::shared_ptr<T>& resource)
{
    try
    {
        BOOST_ASSERT(!t_nodelete);

        t_nodelete = true; // may throw boost::thread_resource_error!
    }
    catch (...)
    {
        t_nodelete = false;

        resource.reset();

        throw;
    }

    T* rv = resource.get();

    resource.reset();

    return wantDelete() ? rv : 0;
}

// ---------------------------------------------------------------------

} // namespace impl

И файл реализации:

// ---------------------------------------------------------------------
// Resource.cpp
// ---------------------------------------------------------------------

#include "Resource.hpp"


namespace impl
{

// ---------------------------------------------------------------------

bool wantDelete()
{
    bool rv = !t_nodelete;

    t_nodelete = false;

    return rv;
}

// ---------------------------------------------------------------------

Flag t_nodelete;

// ---------------------------------------------------------------------

char* Flag::s_true((char*)0x1);

// ---------------------------------------------------------------------

} // namespace impl

А вот пример класса ресурсов, реализованного с использованием этого решения:

// ---------------------------------------------------------------------
// example.cpp
// ---------------------------------------------------------------------
#include "Resource.hpp"

#include <cstdlib>
#include <string>
#include <stdexcept>
#include <iostream>


// uncomment to test failed resource allocation, usage, and deallocation

//#define TEST_CREAT_FAILURE
//#define TEST_USAGE_FAILURE
//#define TEST_CLOSE_FAILURE

// ---------------------------------------------------------------------

/// The low-level resource type.
struct foo { char c; };

// ---------------------------------------------------------------------

/// The low-level function to allocate the resource.
foo* foo_open()
{
#ifdef TEST_CREAT_FAILURE
    return 0;
#else
    return (foo*) std::malloc(sizeof(foo));
#endif
}

// ---------------------------------------------------------------------

/// Some low-level function using the resource.
int foo_use(foo*)
{
#ifdef TEST_USAGE_FAILURE
    return -1;
#else
    return 0;
#endif
}

// ---------------------------------------------------------------------

/// The low-level function to free the resource.
int foo_close(foo* foo)
{
    std::free(foo);
#ifdef TEST_CLOSE_FAILURE
    return -1;
#else
    return 0;
#endif
}

// ---------------------------------------------------------------------

/// The C++ wrapper around the low-level resource.
class Foo
{
public:
    void use()
    {
        if (foo_use(m_foo) < 0)
        {
            throw std::runtime_error("foo_use");
        }
    }

protected:
    Foo()
        : m_foo(foo_open())
    {
        if (m_foo == 0)
        {
            throw std::runtime_error("foo_open");
        }
    }

    void close()
    {
        if (foo_close(m_foo) < 0)
        {
            throw std::runtime_error("foo_close");
        }
    }

private:
    foo* m_foo;

    friend struct ResourceFactory<Foo>;
};

// ---------------------------------------------------------------------

typedef ResourceFactory<Foo> FooFactory;

// ---------------------------------------------------------------------

/// Main function.
int main()
{
    try
    {
        boost::shared_ptr<Foo> resource = FooFactory::create();

        resource->use();

        FooFactory::destroy(resource);
    }
    catch (const std::exception& e)
    {
        std::cerr << e.what() << std::endl;
    }

    return 0;
}

Наконец, вот небольшой Makefile для создания всего этого:

# Makefile

CXXFLAGS = -g -Wall

example: example.cpp Resource.hpp Resource.o
    $(CXX) $(CXXFLAGS) -o example example.cpp Resource.o -lboost_thread-mt

Resource.o: Resource.cpp Resource.hpp
    $(CXX) $(CXXFLAGS) -c Resource.cpp -o Resource.o

clean:
    rm -f Resource.o example