std :: unique_ptr для функций C, которые нуждаются в бесплатном

Question

Подумайте о функции C, которая возвращает что-то, что должно быть free d, например, strdup() POSIX. Я хочу использовать эту функцию в C++ 11 и избегать любых утечек, правильно ли это?

#include <memory> 
#include <iostream> 
#include <string.h> 

int main() { 
    char const* t { "Hi stackoverflow!" }; 
    std::unique_ptr<char, void(*)(void*)> 
     t_copy { strdup(t), std::free }; 

    std::cout << t_copy.get() << " <- this is the copy!" <<std::endl; 
} 

Предполагая, что это имеет смысл, можно использовать аналогичный шаблон с не указателями? Например, для функции POSIX open, которая возвращает int?

Answer 1

То, что у вас есть, с большой вероятностью будет работать на практике, но не совсем правильно. Тем не менее, правильная версия, возможно, даже более читаемым:

std::unique_ptr<char, decltype(std::free) *> 
    t_copy { strdup(t), std::free }; 

Причина заключается в том, что тип функции std::free не гарантируется void(void*). Гарантируется получение void* и возврат void, но есть два типа функций, которые соответствуют этой спецификации: одна с C-связью и одна с C++-связью. Большинство компиляторов не обращают на это внимания, но для правильности вам следует избегать предположений об этом.

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

Не с unique_ptr, что действительно специфично для указателей. Но вы можете создать свой собственный класс, похожий на unique_ptr, но без предположений об обертываемом объекте.

Answer 2

Предполагая, что это имеет смысл, можно использовать аналогичный шаблон с без указателей? Например, для функции POSIX open, которая возвращает int?

Конечно, с помощью Говарда Hinnant tutorial on unique_ptr, мы можем увидеть мотивирующий пример:

// For open 
#include <sys/stat.h> 
#include <fcntl.h> 

// For close 
#include <unistd.h> 

// For unique_ptr 
#include <memory> 

int main() 
{ 
    auto handle_deleter = [] (int* handle) { 
     close(*handle); 
    }; 

    int handle = open("main.cpp", O_RDONLY); 
    std::unique_ptr<int, decltype(handle_deleter)> uptr 
     { &handle, handle_deleter }; 
} 

В качестве альтернативы вы можете использовать функтор вместо лямбда:

struct close_handler 
{ 
    void operator()(int* handle) const 
    { 
     close(*handle); 
    } 
}; 

int main() 
{ 
    int handle = open("main.cpp", O_RDONLY); 
    std::unique_ptr<int, close_handler> uptr 
     { &handle }; 
} 

Пример может быть дополнительно уменьшено, если мы используем функцию typedef и «factory».

using handle = int; 
using handle_ptr = std::unique_ptr<handle, close_handler>; 

template <typename... T> 
handle_ptr get_file_handle(T&&... args) 
{ 
    return handle_ptr(new handle{open(std::forward<T>(args)...)}); 
} 

int main() 
{ 
    handle_ptr hp = get_file_handle("main.cpp", O_RDONLY); 
} 

Answer 3

Предполагая, что это имеет смысл, то можно использовать аналогичную картину с не-указателями? Например, для функции POSIX open, которая возвращает int?

Да, это можно сделать. Вам нужен тип «указатель», который удовлетворяет the NullablePointer requirements:

struct handle_wrapper { 

    handle_wrapper() noexcept : handle(-1) {} 
    explicit handle_wrapper(int h) noexcept : handle(h) {} 
    handle_wrapper(std::nullptr_t) noexcept : handle_wrapper() {} 

    int operator *() const noexcept { return handle; } 
    explicit operator bool() const noexcept { return *this != nullptr; } 

    friend bool operator!=(const handle_wrapper& a, const handle_wrapper& b) noexcept { 
     return a.handle != b.handle; 
    } 

    friend bool operator==(const handle_wrapper& a, const handle_wrapper& b) noexcept { 
     return a.handle == b.handle; 
    } 

    int handle; 
}; 

Обратите внимание, что мы используем -1, как нулевое значение ручки здесь, потому что это то, что open() возвращается на провал. Также очень легко templatize этот код, чтобы он принимал другие типы дескрипторов и/или недопустимые значения.

Тогда

struct posix_close 
{ 
    using pointer = handle_wrapper; 
    void operator()(pointer fd) const 
    { 
     close(*fd); 
    } 
}; 

int 
main() 
{ 
    std::unique_ptr<int, posix_close> p(handle_wrapper(open("testing", O_CREAT))); 
    int fd = *p.get(); 
} 

Demo.

Answer 4

Первоначальный вопрос (и hvd's answer) вводит служебные данные для каждого указателя, поэтому такой unique_ptr в два раза больше, чем один, полученный с std::make_unique. Кроме того, я бы сформулировал decltype непосредственно:

std::unique_ptr<char, decltype(&std::free)> 
    t_copy { strdup(t), &std::free }; 

Если один имеет многие из этих C-API полученных указателей, что дополнительное пространство может быть обузой задерживающего принятия безопасных C++ RAII для кода C++ оберточного существующих интерфейсов API POSIX стиля требующих быть free() d. Другая проблема, которая может возникнуть, заключается в том, когда вы используете char const в вышеуказанной ситуации, вы получаете ошибку компиляции, потому что вы не можете автоматически преобразовать char const * в тип параметра free(void *).

Я предлагаю использовать выделенный тип удаления, не один, построенный на лету, так что пространство над головой уходит, а требуемый const_cast также не является проблемой. Шаблон псевдоним затем может быть легко использован, чтобы обернуть C-API полученных указателей:

struct free_deleter{ 
    template <typename T> 
    void operator()(T *p) const { 
     std::free(const_cast<std::remove_const_t<T>*>(p)); 
    } 
}; 
template <typename T> 
using unique_C_ptr=std::unique_ptr<T,free_deleter>; 
static_assert(sizeof(char *)== 
       sizeof(unique_C_ptr<char>),""); // ensure no overhead 

Пример теперь становится

unique_C_ptr<char const> t_copy { strdup(t) }; 

я предположить, что этот механизм должен быть доступен в Руководстве по C++ Основного (возможно, с лучшим наименованием), поэтому он может быть доступен для баз кодов, переходящих на современный C++ (успех открыт).