Working with shared_ptr returned from another concrete class

Question

I need to have access to an object which is implemented in a different concrete class. So I decided to use std::shared_ptr. I would like to know whether usage of std::shared_ptr is appropriate here, if not please suggest whether I should go with std::weak_ptr. So far I have been using raw pointers but now I decided to use smart pointers in my project, But I'm unable to decide which one should I use here. The following code snippet is analogous to what I'm trying to do in my project.

#include <iostream>
#include <memory>

class data
{
    public:
    data()
    {
        std::cout<<"\n data constructor Called"<<std::endl;
    }
    ~data()
    {
       std::cout<<"\n data destructor Called"<<std::endl;
    }   
    int GetData()
    {
        return val;
    }
    void SetData(int & val)
    {
        this->val = val;
    }
    private:
    int val;
  };

  class sample
  {
     public:
     sample();
     ~sample();
     void GetShared(std::shared_ptr<data> & arg);
     std::shared_ptr<data> sPtr;
  };

  sample::sample()
  {
     sPtr = std::make_shared<data>();
  }

  sample::~sample()
  {
  }

  void sample::GetShared(std::shared_ptr<data> & arg)
  {
     arg = sPtr;
  }

  int main()
  {
      int val = 40;
      sample obj;
      {
          std::shared_ptr<data> temp1;
          obj.GetShared(temp1);
          temp1->SetData(val);
          std::cout<<"\n Data : "<<temp1->GetData()<<std::endl;
      } // Just to understand whether pointer gets deleted if temp1 goes out of scope.

      {
          std::shared_ptr<data> temp2;
          obj.GetShared(temp2);
          val = 20;
          temp2->SetData(val);
          std::cout<<"\n Data : "<<temp2->GetData()<<std::endl;     
      }

      return 0;
  }

Answer 1

The difference between shared_ptr and weak_ptr is that weak_ptr does not increase the ref count on the object and does prevent the object from being deleted.

This has its pros and cons, if you perform async operations after you obtain the pointer and are unsure whether the object that provided the data has been destroyed then you can use weak_ptr and check if you still have access to the object.

If not then keep it simple and use shared_ptr.