Stack Overflow
Stack Overflow

Questions tagged [weak-ptr]

std::weak_ptr is a smart pointer that holds a non-owning ("weak") reference to an object that is managed by std::shared_ptr

The std::weak_ptr is a smart pointer that holds a non-owning ("weak") reference to an object that is managed by std::shared_ptr.

The class template std::weak_ptr is designed for use with and represents a non-owning reference; useful in avoiding circular references, it can also be used as a "tracking reference" and converted to a std::shared_ptr when ownership is required.

261 questions
358
votes
15 answers

When is std::weak_ptr useful?

I started studying smart pointers of C++11 and I don't see any useful use of std::weak_ptr. Can someone tell me when std::weak_ptr is useful/necessary?
user1434698
88
votes
5 answers

shared_ptr and weak_ptr differences

I am reading Scott Meyers "Effective C++" book. It was mentioned that there are tr1::shared_ptr and tr1::weak_ptr act like built-in pointers, but they keep track of how many tr1::shared_ptrs point to an object. This is known as reference counting.…
venkysmarty
  • 11,099
  • 25
  • 101
  • 184
83
votes
10 answers

Why can't a weak_ptr be constructed from a unique_ptr?

If I understand correctly, a weak_ptr doesn't increment the reference count of the managed object, therefore it doesn't represent ownership. It simply lets you access an object, the lifetime of which is managed by someone else. So I don't really see…
notadam
  • 2,754
  • 2
  • 19
  • 35
77
votes
2 answers

How does weak_ptr work?

I understand how to use weak_ptr and shared_ptr. I understand how shared_ptr works, by counting the number of references in its object. How does weak_ptr work? I tried reading through the boost source code, and I'm not familiar enough with boost to…
Oliver Zheng
  • 7,831
  • 8
  • 53
  • 59
46
votes
4 answers

boost, shared ptr Vs weak ptr? Which to use when?

In my current project I am using boost::shared_ptr quite extensively. Recently my fellow team mates have also started using weak_ptr. I don't know which one to use and when. Apart from this, what should I do if I want to convert weak_ptr to…
RLT
  • 4,219
  • 4
  • 37
  • 91
44
votes
1 answer

Equality-compare std::weak_ptr

I want to compare two std::weak_ptr's or one std::weak_ptr and one std::shared_ptr for equality. What I want to know is whether the object each of the weak_ptr's/shared_ptr's point to is the same. The comparison should yield negative results not…
fat-lobyte
  • 1,129
  • 1
  • 10
  • 16
42
votes
2 answers

What's the difference between raw pointer and weak_ptr?

As in title. This question probably already has an answer but I failed to find one.
NPS
  • 6,003
  • 11
  • 53
  • 90
33
votes
3 answers

What's the performance penalty of weak_ptr?

I'm currently designing a object structure for a game, and the most natural organization in my case became a tree. Being a great fan of smart pointers I use shared_ptr's exclusively. However, in this case, the children in the tree will need access…
Kornel Kisielewicz
  • 55,802
  • 15
  • 111
  • 149
32
votes
2 answers

Trivial cases of shared_ptr and weak_ptr failing

I'm having trouble using shared_ptr and weak_ptr along with enable_shared_from_this. When I google the symptoms of what I'm seeing, everybody suggests "you cannot use shared_from_this() when there are no shared_ptr instances owning your object. But…
LubosD
  • 781
  • 6
  • 18
32
votes
2 answers

How to check if weak_ptr is empty (non-assigned)?

Is there a way to distinguish between an assigned (possibly expired) weak_ptr and a non-assigned one. weak_ptr w1; weak_ptr w2 = ...; I understand the following checks for either non-assignment or expiry, but is there a (cheaper?) check…
Zuza
  • 2,136
  • 4
  • 20
  • 22
32
votes
5 answers

What is diffrence between lock() and expired()? weak_ptr C++

Recently I started at C++11. I studied about weak_ptr. There exist two ways of getting raw pointer. lock() function shared_ptr spFoo = wpPtr.lock(); if(spFoo) { spFoo->DoSomething(); } expired() function if(!wpPtr.expired()) { …
zeno
  • 351
  • 1
  • 3
  • 7
30
votes
2 answers

why i can't cast nullptr to weak_ptr<>

class MyClass { public: MyClass(std::weak_ptr parent){} } i want to do this: auto newInstance = std::make_shared(nullptr); or default value of weak_ptr argument is null, such as : void function(int arg,std::weak_ptr…
uray
  • 11,254
  • 13
  • 54
  • 74
27
votes
1 answer

Is it correct to return null shared_ptr?

For example, there is a function that finds an object and returns shared_ptr if object is found, and must indicate somehow that no object was found. std::vector Storage::objects; std::shared_ptr Storage::findObject() { if…
John Lock
  • 623
  • 1
  • 7
  • 18
26
votes
1 answer

std::unique_ptr vs std::shared_ptr vs std::weak_ptr vs std::auto_ptr vs raw pointers

What are the equivalent uses of each smart pointer in comparison to similar (but not limited to) some advanced techniques using raw pointers? My understanding is minimal, but from what I can gather: Raw Pointers: Only use if you really, really,…
Casey
  • 10,297
  • 11
  • 59
  • 88
26
votes
1 answer

Why doesn't std::weak_ptr<> provide a bool conversion?

C++11's std::shared_ptr<> provides a kind of bool operator. operator unspecified-bool-type() const; (It's not a straight-up operator bool() const due to the dangers from implicit casting of type bool.) Why doesn't std::weak_ptr<> have a similar…
OldPeculier
  • 11,049
  • 13
  • 50
  • 76
1
2 3
…
17 18