Object Mentor Blog: Single Ownership in C++ (intro to auto_ptr)

Single Ownership in C++ (intro to auto_ptr)

tottinger — Fri, 30 Mar 2007 10:48:00 -0500

I find a lot of C++ programmers experience memory management differently than I do. I used to have the same kinds of problems that they have, but I learned an important rule: every heap object has exactly one owner, and n borrowers.

The way that I realize this is using reference types. Of course, all good C++ programmers write their functions to use the canonical “const T&” parameters whenever possible. Using a reference means that we have an actual object and not a null reference (side effect: no null checks) and we have simple dot notation (side effect: less typing), but I also use this to mean that we are borrowing the object, not owning it. Likewise, if we have to drop the ‘const’, we are still borrowing.

What about passing by pointer? I only do that if I absolutely must accept 0 (null) as a possible value. I always hate to do that. I would rather have an object outright than a pointer that I dereference. If the function is being called by a framework, I don’t get a choice. I might do something like this:

     void functionName(const Snorkle* snorkleWithNull) {
             if (0 == snorkleWithNull) { 
                  throw SomeIdiotPassedMeANull();
            const Snorkle& snorkle = snorkleWithNull;

           // ... work with snorkle, ignore snorkleWithNull ... 

     }

However sick that seems (and it does) it reverts back to the const reference case quickly and I’m left with a reference to a real object. It keeps me from forgetting to dereference when I’m in a hurry, and keeps me from casting. I have to work extra-hard to do bad things, and that’s a good thing. On the other hand, in modern TDD style, with refactoring, it can double the length of a function (hence feeling sick).

Either way, if you are a borrower, you have no right to delete the object. You can reference it for the duration of your function, or (if the intent is that you will have a short-lived object) for the duration of the object lifetime, but no ownership is given by pointer or reference. Remember that we still have a risk of the pointer being dangled, so holding a reference/pointer for longer than a method call should be considered fairly dangerous and must be done rather intentionally.

But what about transfer of ownership? That’s what the auto_ptr in <memory> is for. Yes, it’s a template. If I can’t use templates, I’ll make up something new that acts roughly the same. The auto_ptr is the one structure in C++ that undeniably says “owner”. When I receive an object via auto_ptr, I am now the owner. When I return an auto_ptr from a function, I’ve clearly given up ownership.

The recipient of the auto_ptr has to do something with the referenced object, or else it will be deleted when the auto_ptr passes out of scope. If the recipient decided to release the auto_ptr, they can keep a normal pointer or reference in whatever structure pleases them. They can make a copy and delete the original (remember the warning about dangling).

The trick is to remember that 99% of the time, you want to be a borrower, and that any class that is going to hold a borrower’s reference to an object needs an algorithmic guarantee that the referenced object will outlive the reference.

The scary part is for an object to have a large number of long-term borrowers, because there is the constant fear that one might outlive the owner. In that case, you need to hang the auto_ptr on the shelf and go get some bigger magic. You might actually need the smart pointer. I have created reference-counting pointer templates in several projects, which will cause C++ to act more like a garbage-collecting language. I know that there are 3rd-party libraries for garbage-collecting. If I find myself in a situation where there are a number of long-term borrowers, I will definitely move in one of these directions again. It is too important to leave object ownership up to chance or naming convention.

"Single Ownership in C++ (intro to auto_ptr)" by ysbearing

Wed, 19 Oct 2011 04:31:19 -0500

Slewing ring is also called slewing bearing, some people called: rotary support, swing support. English Name: slewing bearing or slewing ring bearing or turn table bearing, slewing ring in the real industrial applications is very wide.

"Single Ownership in C++ (intro to auto_ptr)" by balmain dresses

Wed, 14 Sep 2011 21:23:54 -0500

thanks for share with us

"Single Ownership in C++ (intro to auto_ptr)" by bagsupplyer

Sat, 10 Sep 2011 22:49:47 -0500

Thank you very much.Waiting for update. Fashion designer Men G-star sweaters from China for wholesale at on line store

"Single Ownership in C++ (intro to auto_ptr)" by beats by dre store

Tue, 23 Aug 2011 02:49:59 -0500

to vote to thWealthy people: “You suck one, do not look for friends!” 1, Pol.ice: drink?beats by dre sale cheap beats by dre

"Single Ownership in C++ (intro to auto_ptr)" by beats by dr dre headphones

Fri, 03 Jun 2011 23:43:23 -0500

These beats by dr dre solo are just the same as selling in the franchise store.Or even better.

"Single Ownership in C++ (intro to auto_ptr)" by christian louboutin shoes on sale

Fri, 03 Jun 2011 07:45:35 -0500

Have the christian louboutin patent leather pumps is a happy thing. Here have the most complete kinds of christian louboutin leather platform pumps.

"Single Ownership in C++ (intro to auto_ptr)" by okey oyunu oyna

Mon, 25 Apr 2011 10:37:35 -0500

Thanks so much it is nice article.

Okey oynamak hiç bu kadar zevkli olmadi. Online ve 3 boyutlu okey oyunu oyna ve turnuvalara sende katil.

"Single Ownership in C++ (intro to auto_ptr)" by christian louboutin sales

Mon, 18 Apr 2011 02:21:09 -0500

Awesome idea for a tutorial list. Am definitely adding to mems to browse as and when.

"Single Ownership in C++ (intro to auto_ptr)" by chanel handbags for sale

Mon, 18 Apr 2011 02:20:00 -0500

Very comprehensive, and definitely helpful. is awed

"Single Ownership in C++ (intro to auto_ptr)" by mac cosmetics

Mon, 18 Apr 2011 02:18:51 -0500

thanks for taking the time in making it and sharing it now everytime someone asks a question related to B&W coloring I will refer them to this list

"Single Ownership in C++ (intro to auto_ptr)" by ipad bag

Fri, 18 Mar 2011 03:28:34 -0500

TopCombine Follow ipad bag the detail tips below, you can increase the laptop battery life of a year or more. Game Controllers first thing you should care about the USB Gadgets END!444444444444444444444

"Single Ownership in C++ (intro to auto_ptr)" by Tenant Screening

Tue, 22 Feb 2011 11:13:29 -0600

I have created reference-counting pointer templates in several projects, which will cause C++ to act more like a garbage-collecting language. I know that there are 3rd-party libraries for garbage-collecting.

"Single Ownership in C++ (intro to auto_ptr)" by laptop accessories

Mon, 21 Feb 2011 00:33:52 -0600

JAY Follow laptop accessories the detail tips below, you can increase the laptop battery life of a year or more. 1. The laptop battery first thing you should care about the

"Single Ownership in C++ (intro to auto_ptr)" by Criminal Records

Fri, 18 Feb 2011 12:01:50 -0600

"Single Ownership in C++ (intro to auto_ptr)" by Pandora

Thu, 02 Dec 2010 05:07:42 -0600

has just told him that hand-washing is too expensive, and he should stop doing it.”

"Single Ownership in C++ (intro to auto_ptr)" by 23@gmail.com

Thu, 08 Jul 2010 21:21:53 -0500

For those defective to thomas sabo blog after today’s announcement, the links of london blog will still not a bargain. Now the band says that ” buy Pandora blog ” day duty are being booked for the fourth billet and 2005. The reports is so

"Single Ownership in C++ (intro to auto_ptr)" by Mark Taylor - Crytek

Mon, 30 Nov 2009 03:56:13 -0600

The one problem with all such smart pointers is that they commit you to write code in which objects know how to freem themselves. An object that is not responsible for its own memory management is more easily put on the stack, or into arrays, or into some other aggregate.

I prefer a C style API.

A* CreateInstanceofA(); void Free(A* ptr);

"Single Ownership in C++ (intro to auto_ptr)" by suryamargha19@yahoo.com

Sun, 05 Apr 2009 09:12:17 -0500

Hi, That was cooooool…The article ws really written well. I was having trouble to undertstand the owning and aliasing semantics and it cleared my doubt.. Thanks a lot…

Regs, Surya

"Single Ownership in C++ (intro to auto_ptr)" by Fred

Fri, 27 Apr 2007 07:14:02 -0500

Plug for Boost smart pointers. When I’m on a project where I can use Boost, I never allow naked pointers.