When should i use weak ptr

Following illustration shows the relationships between Source , Listener , and their respective holders:. By having a weak reference to a Listener , we have separated the lifetimes of Source and Listener.

When a Listener is destroyed, its Source cannot forward the events, and that can be handled appropriately depending on the application. A reference type that guarantees the existence of the referred object is of paramount importance for writing a safer code.

Tutorial Apr 17, hkumar. Circular References One of the biggest concerns dealing with the raw pointers is that sometimes it is hard to ensure that a raw pointer is not dangling or valid. Following illustration shows the memory-leak when all other strong references to both Back and Forth are destroyed, and no part of the application can reach them: Dealing with Circular References There are several ways to avoid the memory-leak mentioned above, and depending on an application, the workarounds could be very involved and ugly.

Here is a compilation of my standard seminars. These seminars are only meant to give you a first orientation. Kubik-Rubik Joomla! Read more I was checking continuously this blog and I'm impressed!

Extremely helpful information particularly the last part : I care for such information a lot. I was seeking this particular info for a long time. Thank you and good luck.

This webpage presents useful data to us, keep it up. Will try it out. Let me try it out. Keep up thee great work! You recognize, a lot of individuals are looking round for this info, you can aid them greatly. The following code pattern checks to see if the Weak Pointer references a valid object, and if so, guarantees that it will continue to be valid at least until the Shared Pointer created by the Pin function goes out of scope or is explicitly cleared. This method ensures that the object remains valid while you are working with it.

A reference cycle exists whenever two or more objects use Smart Pointers to keep strong references to each other. In these situations, the objects protect each other from deletion, as each one is always being referenced by one other object, and so neither can be deleted while the other still exists.

If no outside object references either of the objects in the reference cycle, they will effectively leak. Weak Pointers can break these reference cycles, because Weak Pointers do not preserve the objects they reference. Use Weak Pointers when you want to reference objects without claiming ownership over them and potentially extending their lifespans.

Weak Pointers are useful in cases where you don't want to guarantee that the data object will continue to exist, but this very property can be dangerous.

Weak pointers can't access an object directly, but they can tell whether the object still exists or if it has expired. A weak pointer can be temporarily converted to a shared pointer to access the pointed-to object provided it still exists.

To illustrate, consider the following example:. In the example, you have a weak pointer to Meeting B. You are not an "owner" in Meeting B so it can end without you, and you do not know whether it ended or not unless you check. If it hasn't ended, you can join and participate, otherwise, you cannot. This is different than having a shared pointer to Meeting B because you would then be an "owner" in both Meeting A and Meeting B participating in both at the same time. The example illustrates how a weak pointer works and is useful when an object needs to be an outside observer , but does not want the responsibility of sharing ownership.

This is particularly useful in the scenario that two objects need to point to each other a. With shared pointers, neither object can be released because they are still 'strongly' pointed to by the other object.

When one of the pointers is a weak pointer, the object holding the weak pointer can still access the other object when needed, provided it still exists. Obviously the best way to do this is a control thread, which handles and manages the images, and multiple worker threads, which load the images. Now this is an easy task. Here's a very simplified implementation join etc is omitted, the threads would have to be handled differently in a real implementation etc.

But it becomes much more complicated, if you want to interrupt the loading of the images, e. Or even if you want to destroy the manager. Otherwise the loaders would carry on loading until all images are done - even if they are already obsolete. In the simplified example, that wouldn't be too hard, but in a real environment things can be much more complicated. The threads would probably be part of a thread pool used by multiple managers, of which some are being stopped, and some aren't etc.

The simple parameter imagesToLoad would be a locked queue, into which those managers push their image requests from different control threads with the readers popping the requests - in an arbitrary order - at the other end.

And so the communication becomes difficult, slow and error-prone. Since the expired images are skipped, and non-expired images are processed, the threads never would have to be stopped during normal operation. You could always safely change the path or destroy your managers, since the reader fn checks, if the owning pointer isn't expired. There are several scenarios when such point of view is useful:. Herb Sutter has an excellent talk that explains the best use of language features in this case smart pointers to ensure Leak Freedom by Default meaning: everything clicks in place by construction; you can hardly screw it up.

It is a must watch. Means if the parent class uses the object of child class using a shared pointer, in the same file if child class uses the object of the parent class. The shared pointer will be failed to destruct all objects, even shared pointer is not at all calling the destructor in cycle dependency scenario.

In the above class wPtr1 does not own the resource pointed by wPtr1. If the resource is got deleted then wPtr1 is expired. I see a lot of interesting answers that explain reference counting etc.

When the classes go out of scope they are NOT destroyed. Stack Overflow for Teams — Collaborate and share knowledge with a private group. Create a free Team What is Teams? Collectives on Stack Overflow. Learn more.