Calling shared_ptr object method

Question

This seems like a pretty dumb question, so please bear with me. I am using smart pointers in place of raw pointers in my programs. I am advised against using raw pointers or mixing the two as much as possible. I understand that as well. I am also aware that pointers should be used only went necessary.

class Foo{
  private: int val;
  public: 
    Foo(int v) :val(v){}
    int getvalue() const { return val; }
};

std::shared_ptr<Foo> foo = std::make_shared(Foo(10));

int v;

//Option I
v=foo->getvalue();

//Option II
v=foo.get()->getvalue();

I feel option I is more correct as option II utilizes raw pointer. But using raw pointer may not hurt here as I am not allocating or deallocating.

Often I get confused with these two options. Which one is preferable? Are they just same? Thanks.

"...as I am not allocating or deallocating..." what do you think this line does std::shared_ptr<Foo> foo = std::make_shared(Foo(10)); ? — Richard Critten
– Richard Critten, Commented Feb 16, 2020 at 13:42
They're the same. The first one is preferable because it's less typing. You use get() when you need the raw pointer, e.g. to send it to a legacy function that expects one. — user4815162342
– user4815162342, Commented Feb 16, 2020 at 13:42

StoryTeller - Unslander Monica · Accepted Answer · 2020-02-16 13:43:00Z

Raw pointers are not the enemy. We can't write any useful program in C++ without them in one shape or form. The problem is owning raw pointers. They don't have a clear ownership semantic associated with their type, and so it fall to the programmer to do the arduous task of managing the lifetime by hand. Don't fear passing a raw pointer around as a handle, if you need to.

Which brings us to the next point. Both methods you demonstrated rely on raw pointers. An overloaded operator-> must return a raw pointer (eventually) for us to apply member access on the object. In essence, the first version is equivalent to

v = foo.operator->() -> getvalue();

It operates exactly the same as the second form, just with syntactic sugar on top.

You should prefer the first form because it is shorter and readable. But it doesn't avoid raw pointers, that's impossible to avoid.

Jesper Juhl · Accepted Answer · 2020-02-16 13:42:28Z

4

There is no functional difference between

//Option I
v=foo->getvalue();

And

//Option II
v=foo.get()->getvalue();

But option II is more typing, so why?

Both constructs do exactly the same in this situation.

This has nothing to do with smart pointers vs raw pointers. The problem with raw pointers is purely with raw owning pointers. There's nothing wrong with raw non-ownining pointers.

answered Feb 16, 2020 at 13:42

Jesper Juhl

32.2k4 gold badges55 silver badges80 bronze badges

Comments

Arno Deceuninck · Accepted Answer · 2020-02-16 13:43:07Z

1

Both option will probably get the same result in the assembled code. The first option foo->getvalue() is the prefered option, because this gives a better readability.

answered Feb 16, 2020 at 13:43

Arno Deceuninck

3303 silver badges12 bronze badges

Collectives™ on Stack Overflow

Calling shared_ptr object method

3 Answers 3

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related