Использование интеллектуальных указателей для управления буферами ⇐ C++

[Anonymous]

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

По сути, этот класс владеет вектором буферов, состоящим из пар void*/length. Управление буфером реализовано с помощью вспомогательного метода (UtlMemBuffer::append, реализация которого также показана ниже).

Я хотел бы, чтобы этот класс использовал новые интеллектуальные указатели C++11, чтобы можно было четко определить владение и свести к минимуму перераспределение. Чтобы использовать этот класс, клиентский код обычно передает конструктору собственный буфер/длину необработанного указателя или может вызвать метод добавления. В конце концов, когда вызывается деструктор UtlMemBuffer, он освобождает свою собственную копию, гарантируя отсутствие утечек памяти, пока вызывающая сторона несет ответственность за ее копию. Я думаю, что вместо передачи необработанных указателей использование std::shared_ptr устранит необходимость в этом типе владения двойным буфером (т. е. вызывающая сторона будет нести ответственность за обновление std: :shared_ptr и передать его в UtlMembuffer

Самая большая проблема, на мой взгляд, — это поддержка метода чтения (интерфейса). аналогично тому, как работает файл), где мне нужно вернуть сглаженную память через необработанный указатель. Возможно, лучшим подходом к проектированию было бы передать обратно std::unique_ptr, который я создаю путем сглаживания внутренней коллекцииshared_ptrs. Я не совсем уверен, какой подход будет лучшим, хотя мне придется немного изменить текущий код, использующий этот класс, чтобы использовать этот подход.

Если вызывающие объекты. все передают указатели std::shared_ptr. Например, мне интересно, каким будет лучший подход к такому преобразованию.

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

/**
* Smart Buffer class
*/
class UtlMemBuffer
{
public:
// default constructor
UtlMemBuffer(
const UtlPath& rBufferPath = UtlPath::ssNull,
const void* pBytes = NULL,
const size_t& rBufLength = 0);

// copy constructor
UtlMemBuffer(const UtlMemBuffer& rhs);

// move constructor
UtlMemBuffer(UtlMemBuffer&& rhs);

inline void swap(UtlMemBuffer& rhs) throw() {
// enable ADL (not necessary in our case, but good practice)
using std::swap;
// no need to swap base members - as we are topmost class
swap(mBufferPath, rhs.mBufferPath);
swap(mBufferLength, rhs.mBufferLength);
swap(mBufferBlocks, rhs.mBufferBlocks);
}

// unified assignment operator
UtlMemBuffer& operator=(UtlMemBuffer rhs);

// destructor - pure virtual
virtual ~UtlMemBuffer();

// add buffer to this one
virtual OsStatus append(
const void* pBytes,
const size_t& rBufLength,
size_t& rBufLengthWritten);

// comparator
bool operator==(const UtlMemBuffer& rhs) const;

// comparator
bool operator MemBufInfo;

// the name of the buffer (sort of file name)
UtlPath mBufferPath;

// this is updated whenever we append data
size_t mBufferLength;

// here we have a collection of received appends (effectively blocks)
MemBufInfo mBufferBlocks;
};


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

OsStatus
UtlMemBuffer::append(const void* pBytes,
const size_t& rBufLength,
size_t& rBytesWritten)
{
rBytesWritten = 0;
if (pBytes != NULL) {
void* block = new char [rBufLength];
memcpy(block, pBytes, rBufLength);
mBufferBlocks.push_back(std::make_pair(block, rBufLength));
rBytesWritten = rBufLength;
mBufferLength += rBufLength;
}
return OS_SUCCESS;
}


Подробнее здесь: https://stackoverflow.com/questions/104 ... ge-buffers