Various dynamic memory problems

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::PolygonSet3D(ID3D10Device & device,
                              const std::vector<Buffer> &
buffers, /// <--PROBLEM!
                              Effect & effect,
                              const std::string & techniqueName,
                              const Material & material);