Various dynamic memory problems

[Christopher]

I am wandering into a vast deep that I have only waded in before:

I'll list the problems first for those that don't lile reading the
code.

1) I have a large amount of constructors that all basically do the
same thing. I am going to also have Get methods to retrieve the data
that will all do the same thing. However, I don't see a way to use
templates to solve this problem as the implementation does specific
things for each type. I read on template specialization (which sadly
I've never used) and it seems I'd just be switching problems from
multiple constructors and methods to multiple specializations.

2) I need to control when the pointer member gets released. In some
cases I want to create and pass this class around and not have the
pointer deleted and in some cases I do want it to get deleted. The
parameter to the constructor of a PoygonSet is a prime example: If the
application creates one of these buffers, and passes it to create a
PolygonSet, the pointer member is going to deleted when the instace on
the stack of the application goes out of scope making the copy in the
PolygonSet invalid. I do not want to define a deep copy, because there
should always only be one of those objects that is getting pointed to.

boost::shared_ptr seems like it may solve this problem.
Is this a canidate for boost::shared_ptr?

If I understand correctly I can use a shared ptr to create on of
these. pass it as a parameter to the constructor of my polygonset, let
the original go out of scope, and it will not get deleted.

I think I can use a boost::weak_ptr for objects which need to peek at
and use this but should not control the lifetime.

Does that seem correct? I've never used either one yet.




consider this code:

//------------------------------------------------------------------------------------------
/**
* Wrapper for a D3D buffer
**/
class Buffer
{
public:

/**
* Creates a buffer for the following types:
* BlendIndex
* Index
**/
Buffer(ID3D10Device & device,
const BufferContentType contentType,
const std::vector<unsigned int> & data,
const bool dynamic = false,
const bool perIndex = false);

/**
* Creates a buffer for the following types:
* BlendWeight
* PointSize
* TexCoord1D
**/
Buffer(ID3D10Device & device,
const BufferContentType contentType,
const std::vector<float> & data,
const bool dynamic = false,
const bool perIndex = false);

/**
* Creates a buffer for the following types:
* TexCoord2D
**/
Buffer(ID3D10Device & device,
const BufferContentType contentType,
const std::vector<D3DXVECTOR2> & data,
const bool dynamic = false,
const bool perIndex = false);

/**
* Creates a buffer for the following types:
* Binormal
* Normal
* Position
* Tangent
* TexCoord3D
**/
Buffer(ID3D10Device & device,
const BufferContentType contentType,
const std::vector<D3DXVECTOR3> & data,
const bool dynamic = false,
const bool perIndex = false);

/**
* Creates a buffer for the following types:
* PositionT
**/
Buffer(ID3D10Device & device,
const BufferContentType contentType,
const std::vector<D3DXVECTOR4> & data,
const bool dynamic = false,
const bool perIndex = false);

/**
* Creates a buffer for the following types:
* Color
**/
Buffer(ID3D10Device & device,
const BufferContentType contentType,
const std::vector<D3DXCOLOR> & data,
const bool dynamic = false,
const bool perIndex = false);

/**
* Destructor
**/
~Buffer();

private:

ID3D10Device & m_device; // D3D device used to
create the buffer
ID3D10Buffer * m_buffer; // D3D buffer interface

const BufferContentType m_contentType; // Identifies the type of
data the buffer contains
const bool m_dynamic; // Whether or not writing
to the buffer after creation is permitted
const bool m_perIndex; // Whether or not this
buffer contains per index data or per vertex data

unsigned m_numElements; // Number of elements the
buffer contains
};

//------------------------------------------------------------------------------------------
/**
* A set of polygons that are typically rendered as one group of
triangles sharing the
* same transform, material, and shader.
*/
class PolygonSet3D : public Transformable
{
public:

/**
* Constructor
*/
PolygonSet3D:olygonSet3D(ID3D10Device & device,
const std::vector<Buffer> &
buffers, /// <--PROBLEM!
Effect & effect,
const std::string & techniqueName,
const Material & material);