SubBuffer实现

Question

我必须使用底部的以下文件。 问题是我必须使用BufferSptr。 我可以通过执行以下操作来创建BufferSptr。

BufferSptr buff (new Buffer (pMediaData->Size())); 

我也可以访问它并将其传递给正在使用它的媒体播放器中的功能。 我想要做的是传递一个BufferSptr，但访问不是所有的，但 一些部分内容。我看到下面的文件定义了一些方法来做到这一点，但它不适合我

例如我试过这个，但不起作用。

BufferSptr subbuffer (&buff,0,100); 

所以我想要的是使用BufferSptr的部分内容。感谢

的Buffer.h类是

namespace ahs { 

/** A Buffer provides a partial view to a block of memory. For any 
* given Buffer, subbuffers can be created that provide a partial view 
* of the original Buffer contents. If all the Buffers to a block of 
* memory are deleted, the block itself is freed automatically. 
*/ 
class Buffer 
{ 
/* Data types */ 
public: 
typedef shared_ptr<Buffer> BufferSptr; 
typedef shared_ptr<const Buffer> ConstBufferSptr; 

/* Member functions */ 
public: 
/** Create a new buffer of the given size (in Bytes) using the default 
* backend */ 
Buffer(size_t size); 

/** Create a new buffer using a provided backend store */ 
Buffer(const BufferBackendSptr& pBackend); 

/** Create a subbuffer */ 
Buffer(Buffer* container, int offs, int sz); 

/** Create a subbuffer (equivalent to the constructor based method) */ 
Buffer* CreateSubbuffer(int offs, int sz); 
const Buffer* CreateConstSubbuffer(int offs, int sz) const; 

/** Get a pointer to the data */ 
void* GetData(); 
const void* GetData() const; 

/** Returns the size of the buffer data */ 
size_t Size() const; 

/* Member data */ 
protected: 
/** Pointer to the Backend 
* 
* We use this to keep a reference around, making sure the data does 
* not get thrown away. The other purpose is to create subbuffers. 
*/ 
shared_ptr<BufferBackend> mpBackend; 

/** Pointer to the data of this buffer 
* 
* In the general case, pData points somewhere to the interior of the 
* data block owned by pBackend. 
*/ 
char* mpData; 

/** The buffer size */ 
size_t muSize; 

}; 

typedef Buffer::BufferSptr BufferSptr; 
typedef Buffer::ConstBufferSptr ConstBufferSptr; 

inline const void* Buffer::GetData() const 
{ 
return mpData; 
} 

inline void* Buffer::GetData() 
{ 
return mpData; 
} 

inline size_t Buffer::Size() const 
{ 
return muSize; 
} 

} // end namespace ahs 

#endif 

Buffer.cpp是

using namespace ahs; 

Buffer::Buffer(size_t sz) : mpBackend(new BufferBackend(sz)), 
         mpData(mpBackend->mpBlock), 
         muSize(sz) 
{ 
} 

Buffer::Buffer(const BufferBackendSptr& pBackend) 
: mpBackend(pBackend) 
, mpData(mpBackend->mpBlock) 
, muSize(mpBackend->muSize) 
{ 
} 

Buffer::Buffer(Buffer *container, int offs, int sz) 
{ 
assert(offs + sz <= container->muSize); 

#if 0 // TODO: Premature optimization, either enable or take out. 
if(sz == 0) 
{ 
    /* Special case: Try to avoid holding an unnecessary reference 
     to the backend. */ 
    muSize = 0; 
    mpBackend = (BufferBackend *)0; 
    mpData = 0; 
} 
else 
#endif 
{ 
    mpBackend = container->mpBackend; 
    muSize = sz; 
    mpData = &mpData[offs]; 
} 
} 

Buffer* Buffer::CreateSubbuffer(int offs, int sz) 
{ 
return new Buffer(this, offs, sz); 
} 

const Buffer* Buffer::CreateConstSubbuffer(int offs, int sz) const 
{ 
return const_cast<Buffer *>(this)->CreateSubbuffer(offs, sz); 
} 

Bufferbackend.h是拥有其可以通过不同的访问的数据的一个块

类 *缓冲区。具有BufferBackend的要点是，每个缓冲区都可以包含一个共享指针，该指针指向由BufferBackend持有的相同数据块 *。这个后端将会自动消失 *一旦所有对它的引用消失。 * *应使用特定的 *内存分配/释放函数创建此类的子类。 / 类BufferBackend {
/朋友*/ 市民： 朋友Buffer类;

/* Data types */ 
public: 
typedef shared_ptr<BufferBackend> BufferBackendSptr; 

/* Member functions */ 
public: 
BufferBackend(size_t sz); 

virtual ~BufferBackend(); 

// BufferBackend（）;

protected: 
/** Virtual function to allocate memory */ 
void Allocate(); 

/** Virtual function to deallocate memory */ 
void Deallocate(); 

private: 
/* Disallow copying or assignment */ 
BufferBackend(const BufferBackend&); 
BufferBackend operator=(const BufferBackend&); 

/* Member data */ 
protected: 
char* mpBlock; 
size_t muSize; 

}; 

typedef BufferBackend::BufferBackendSptr BufferBackendSptr; 

inline BufferBackend::BufferBackend(size_t sz) 
: muSize(sz) 
{ 
Allocate(); 
} 

inline BufferBackend::~BufferBackend() 
{ 
Deallocate(); 
} 

} // end namespace ahs 

#endif /* BUFFER_BACKEND_H */ 

Bufferbackend.cpp

包括 “BufferBackend.h”

using namespace ahs; 

void BufferBackend::Allocate() 
{ 
mpBlock = new char[ muSize ]; 
} 

void BufferBackend::Deallocate() 
{ 
delete[] mpBlock; 
} 

Answer 1

BufferSptr只是共享指针：你必须分配一个缓冲区它（你必须创建缓冲区） 。 如果BUFF是另一个BufferSptr（另一个共享指针），那么我会尝试：

BufferSptr subbuffer (buff->CreateSubbuffer(0,100)); 

或

BufferSptr subbuffer (new Buffer(buff.get(), 0,100));