Set shared_ptr to point existing object

Question

For the code below, I would like to know how to set std::shared_ptr to point the given objects in the two member functions. The Vector3 object which is allocated in the main function is not going to be deleted until the end of the program.

#include <memory>
#include <vector>

using std::vector;
using std::shared_ptr;

class Vector3
{
    // ...
};

class Face
{
    vector < shared_ptr <Vector3> > vtx;

    public:

    void addVtx (const Vector3& vt)
    {
        // vtx.push_back (); <-- how to push_back ?
    }

    void setVtx (const int v, const Vector3& vt)
    {
        if ( vtx.size() > 0 && v < vtx.size() )
        {
            // vtx[v] = &vt; <-- how to assign ?
        }
    }

};

int main ()
{
    vector <Vector3> vec (3);
    Face face;

    face.addVtx (vec[0]);
    face.setVtx (0, vec[0])

    return 0;
}

Answer 1

There is not much point in using a shared_ptr for an automatically allocated object.

Technically you can do it, by giving the shared_ptr a deleter that doesn't do anything, and changing your vtx to be a vector of shared pointers to const vectors.

E.g. changing the declaration to

vector < shared_ptr <Vector3 const> > vtx;

and adding a pointer like this:

vtx.push_back( shared_ptr<Vector3 const>( &vt, [](Vector3 const*){} ) );

Disclaimer: untested code, not touched by a compiler.

However, unless you're going to also add pointers to vectors that need to be deleted, just use a vector of raw pointers. Or, just use a vector of vectors, and copy the in-data.

---

It's not a good idea to use raw pointers to hold ownership. For that use smart pointers.

But conversely, it's not a good idea to use ownership smart pointers to hold pure references to static or automatic objects. For that, use raw pointers or references.

In general.

Answer 2

Disregarding the argument about whether using shared_ptr is a good idea or not, as explained by the accepted answer, you can use the following if you continue to use shared_ptr:

void addVtx (const Vector3& vt)
{
    vtx.push_back(std::make_shared<Vector3>(vt));
}

void setVtx (size_t v, const Vector3& vt)
{
    if ( vtx.size() > 0 && v < vtx.size() )
    {
       vtx[v] = std::make_shared<Vector3>(vt);
    }
}