Understanding C++ Ownership System

https://blog.aiono.dev/posts/understanding-c++-ownership-system.html

by todsacerdoti • 6 months ago

52 83 6 months ago

blog.aiono.dev

Dwedit• 6 months ago

C++: Where you can accidentally deallocate an object that's still in the call stack. (true story)

einpoklum3• 6 months ago

Well, you can also write:

   int x = 123;
   delete &x;

and that would compile. But it's not a very good idea and you should be able to, well, not do that.

In modern C++, we avoid allocating and deallocating ourselves, as much as possible. But of course, if you jump to arbitrary code, or overwrite something that's due as input for deallocation with the wrong address, or similar shenanigans, then - it could happen.

kccqzy• 6 months ago

You can also do that intentionally and correctly. After all `delete this;` is a valid statement that can occasionally be useful. That said, I’ve only seen this in old pre-C++11 code that does not adhere to the RAII best practice.

HarHarVeryFunny12• 6 months ago

The trouble with C++ is that it maintains backwards compatibility with C, so every error-prone thing you could do in C, you can still do in C++, even though C++ may have a better way.

The modern, safest, way to use C++, is to use smart pointers rather than raw pointers, which guarantee that nothing gets deleted until there are no more references to it, and that at that point it will get deleted.

Of course raw pointers and new/delete, even malloc/free, all have their uses, and without these low level facilities you wouldn't be able to create better alternatives like smart pointers, but use these at your own peril, and don't blame the language if you mess up, when you could have just done it the safe way!

aw16211075• 6 months ago

which guarantee that nothing gets deleted until there are no more references to it, and that at that point it will get deleted.

To be more precise, C++'s smart pointers will ensure something is live while specific kinds of references the smart pointer knows about are around, but they won't (and can't) catch all references. For example, std::unique_ptr ensures that no other std::unique_ptr will own its object and std::shared_ptr will not delete its object while there are other std::shared_ptrs around that point to the same object, but neither can track things like `std::span`/`std::string_view`/other kinds of references into their object.

simonask2• 6 months ago

The trouble with C++ is that it maintains backward compatibility with C++.

Conscat• 6 months ago

The modern safest way to use C++ involves lifetime annotations and ownership annotations run under multiple built-in Clang constraint solvers, but this isn't what most users do.

jesse__8• 6 months ago

Does anyone reading this have links to people who have written specifically about a C++ ownership model that rejects the smart_ptr/RAII/friends model in favor of an ownership model that embraces bulk allocations, arenas, freelists, etc? I know there are groups of highly productive programmers that feel the traditional C++ ownership model is hot garbage, and I'd love a resource that puts down specific arguments against it, but I've never come across one myself.

Edit: clarity

rubymamis• 6 months ago

I'm interested in the same! There are plenty of resources for C[1][2]. I just looked into my old notes and found a post for C++[3].

[1] https://btmc.substack.com/p/memory-unsafety-is-an-attitude-p...

[2] https://www.gingerbill.org/series/memory-allocation-strategi...

[3] https://dmitrysoshnikov.com/compilers/writing-a-pool-allocat...

jesse__8• 6 months ago

Nice, thanks. I haven't read those gingerbill ones, I'll take a look :D

otherjason• 6 months ago

What makes you think that RAII- and arena-based strategies are in tension with one another? RAII and smart pointers are more related to the ownership and resource management model. Allocating items in bulk or from arenas is more about where the underlying resources and/or memory come from. These concepts can certainly be used in tandem. What is the substance of the argument that RAII, etc. are "hot garbage?"

einpoklum3• 6 months ago

In my library [1], wrapping the CUDA APIs in modern C++, I do allocations which are not exactly from an arena, but something in that neighborhood - memory spaces on context on GPU devices.

Unlike the GP suggests, and like you suggest, I have indeed embraced RAII in the library - generally, not just w.r.t. memory allocation. I have not, however, replicated that idioms of the standard library. So, for example:

* My allocations are never typed.

* The allocation 'primitives' return a memory_region type - essentially a pointer and a size; I discourage the user from manipulating raw pointers.

* Instead of unique_ptr's, I encourage the use of unique_span's: owning, typed, lightweight-ish containers - like a fusion of std::span<T> and std::unique_ptr<T[]> .

I wonder if that might seem less annoying to GP.

---

[1] https://github.com/eyalroz/cuda-api-wrappers/

jesse__8• 6 months ago

In reverse order they were asked ..

The best argument I've ever come across against using RAII is that you end up with these nests of objects pointing to one another, and if something fails, the cleanup code can really only do one thing, which is unwind and deallocate (or whatever the cleanup path is). This structure, generally, precludes the possibility of context dependent resource re-usage on initialization failure, or on deallocation, because you kind of have to have only one deallocation path. Obviously, you could imagine supporting in an RAII context, but, the point is that you probably have to put a fair bit of conscious effort into doing that, whereas if you have a less .. rigid.. ownership model, it becomes completely trivial.

I agree that the allocation model and ownership model are independent concepts. I mentioned arena allocation because the people I know that reject the traditional C++ ownership model generally tend to favor arenas, scratch space, freelists, etc. I'm specifically interested in an ownership model that works with arenas, and tracks ownership of the group of allocations, as opposed to the typical case we think about with RAII where we track ownership of individual allocations.

aw16211075• 6 months ago

explicitly rejects the smart_ptr/RAII/friends model in favor of bulk allocations, arenas, freelists, etc?

These aren't mutually exclusive; you can use the former to manage the latter, after all.

I know there are groups of highly productive programmers that feel the traditional C++ ownership model is hot garbage

I'm not aware of links off the top of my head, but I can try to summarize the argument.

From my understanding, the argument against RAII/etc. has more to do with the mindset it supposedly encourages more than the concept itself - that RAII and friends makes it easy to think more in terms of individual objects/elements/etc. instead of batches/groups, and as a result programmers tend to follow the easy path which results in less performant/more complex code. By not providing such a feature, so the argument goes, programmers no longer have access to a feature which makes less-efficient programming patterns easy and so batched/grouped management of resources becomes more visible as an alternative.

jesse__8• 6 months ago

Agreed. I guess I'm interested in anyone that's specifically written about ownership strategies that lean into the group allocation thing.

nwlieb• 6 months ago

Yes: https://m.youtube.com/watch?v=xt1KNDmOYqA

Title: “ Casey Muratori | Smart-Pointers, RAII, ZII? Becoming an N+2 programmer”

jesse__8• 6 months ago

Good one. I was blessed to have the opportunity to watch that one live, on stream. It's always stuck with me and, now that I think about it, is the best resource I know of that puts those ideas into words/writing.

verall• 6 months ago

If you have requirements for high performance then the traditional C++ "ownership model" (I would say a better description is "ownership strategy") is definitely "slow". It's pretty "safe" in that you usually aren't going to leak a bunch with it but bull allocations, arenas, and freelists are all potentially faster. And you wouldn't use them if they were slower since they're (usually) more to deal with.

But even in software using these strategies, they probably will be using different ownership strategies in different parts of the code. Once you're writing high performance code, you will use specific strategies that give you the best results. But it's completey domain specific.

GrowingSideways• 6 months ago

Such a model likely would not be referred to as "ownership". This is a relatively recent metaphor for memory management that came well after the concepts you mentioned. The fact that such a metaphor is core to rust's memory model is no coincidence.

HarHarVeryFunny12• 6 months ago

Those types of allocation technique were common back in the day for efficiency reasons, maybe still relevant for things like embedded programming where you need to be more careful about memory usage and timing, but I would say that nowadays for normal application usage you are better off using smart pointers.

It's not a matter of one being strictly better than the other, but rather about using the right tool for the job.

jesse__8• 6 months ago

Many soft-realtime systems make use of these techniques, specifically 3D graphics and game engines.

dundarious2• 6 months ago

I disagree, as group lifetimes are conceptually and architecturally often easier and simpler than having lots of individual lifetimes managed by smart pointers. And sure, you can often slap shared_ptr around the place, or hopefully a less lazy smart ptr choice, but it makes the code harder to understand by obscuring ownership rather than eliminating it as a concern.

edflsafoiewq2• 6 months ago

May be interested in https://floooh.github.io/2018/06/17/handles-vs-pointers.html

jesse__8• 6 months ago

This is exactly the kind of thing I was after, thank you!

einpoklum3• 6 months ago

The title reminds of this:

https://youtu.be/TGfQu0bQTKc?si=7TiDRic6LaWI1Xpc&t=70

"In Rust you need to worry about borrowing. In C++ you don't have to worry about borrowing; in C++ you have to worry about ownership, which is an old concept..." :-P

jurschreuder3• 6 months ago

I don't know why people use 'new' and 'delete' in all the examples how memory in C++ works because you never normally use them during coding only if you want to make your own container which you might do once to learn about the internals.

C++ by default creates objects by value (opposed to any other language) and when the variable goes out of scope the variable is cleaned up.

'new' you use when you want to make a global raw pointer outside of the normal memory system is how I would see it. You really never use it normally at least I don't.

A good rule of thumb is not to use 'new'.

vlovich1233• 6 months ago

And yet, I interviewed 10 people easily where I was using new and delete in the example code and only one person asked "hey - can we use unique_ptr?".

oxag3n• 6 months ago

Ownership problems with pointer/references don't end with allocation.

A codebase can use only std::make_unique() to allocate heap, and still pass around raw pointers to that memory (std::unique_ptr::get()).

The real problem is data model relying on manual lifetime synchronization, e.g. pass raw pointer to my unique_ptr to another thread, because this thread joins that thread before existing and killing the unique_ptr.

mackeye• 6 months ago

many schools (like mine) don't teach unique pointers in the pure "programming" class sequence, but offer a primer in advanced classes where c++ happens to be used, with the intent to teach manual memory management for a clearer transition to e.g. upper-levels which use c.

johannes1234321• 6 months ago

Well in interviews this is tricky. Sometimes the interviewer wants to see I can new/delete properly, sometimes this tells me "well, if that's the style they are using I better go elsewhere"

If it's done as part of a "here is legacy code, suggest ways to improve it" question one should point it out, though.

mikepurvis• 6 months ago

Yup, just emplace the object directly into the container, or at worst create it by value and then add it to the container with std::move.

unclad5968• 6 months ago

It just makes for an easily understandable example. I don't think the post is advocating for the use of new/delete over smart pointers.

duped• 6 months ago

People use `new` and `delete` when explaining memory in C++ because those are the language primitives for allocating and releasing memory in C++.

That rule of thumb is only a useful rule if you don't care about how memory works and are comfortable with abstractions like RAII. That's fine for lots of real code but dismissing `new` and `delete` on principle is not interesting or productive for any discussion.

tialaramex8• 6 months ago

Also they're operators.

I understand C++ has a lot of operators which are variously reserved but not standardized ("asm") largely obsolete but still needed because of perverse C programmers ("goto") still reserved long after their usefulness subsided ("register") or for ideas that are now abandoned ("synchronized") not to mention all its primitive types ("double", "signed", "long", "short", "char8_t") and redundant non-textual operators given ASCII names like ("and_eq", "bitand", "xor")

But it also has dozens, like new and delete which look like features you'd want. So kinda makes sense to at least mention them in this context.

jurschreuder3• 6 months ago

No the primitives are:

{

  // allocate

  auto my_obj = MyObj{}

} // released

johnnyanmac• 6 months ago

Yes, and no?

In production, odds are you are relying on allocators or containers others already wrote. You coming in in 2026 may not ever use the keywords directly, but you'll either be using abstractions that handle that for you (be it STL or something internal) or using some custom allocation call referring to memory already allocated.

But yes, I'd say a more general rule is "allocate with caution".

mgaunard3• 6 months ago

even when you write your own container, you do not use new and delete.

tialaramex8• 6 months ago

Are you sure? It seems as though ultimately Microsoft's STL for example ends up calling std::allocator's allocate function which uses the new operator.

edflsafoiewq2• 6 months ago

You might use placement new though.

ranit• 6 months ago

I don't know why people use 'new' and 'delete' in all the examples ...

Why? Because the blog post is titled "Understanding C++ Ownership System".

jurschreuder3• 6 months ago

He's making it massively more complex than it actually is

{ // this scope is owner

  // allocate

  auto my_obj = MyObj{};

  // this function scope does not have ownership of my_obj, should take (const MyObj& obj) const reference as parameter

  do_something(my_obj);

} // memory is released

bulbar• 6 months ago

Such article can end up with a 'false balance' bias by introducing and showing a method one should avoid to motivate the solution. What some people learn is "there are two options".

Maybe it works be better to start with "that's how we do it" and only afterwards following up with "and that's why".

pjmlp4• 6 months ago

Unfortunately they are all over the place on corporate code.

eddd-ddde2• 6 months ago

You need to if you want to create a smart pointer from some class with a private constructor.

dpsych• 6 months ago

I think in the `Move` section the delete[] should be delete[] old_buffer; rather than new_buffer;

cocoto• 6 months ago

Why are some examples full of errors? The `set_vec` method for instance does not bind the reference, you can't change the reference itself... so the code would simply copy the vector and there would be no dangling reference... And `B` is missing a constructor since the default constructor would be ill-formed (you can't default initialize a reference).

Anyway the article is quite approachable, do not take my criticism to shy away from writing!

pixelesque• 6 months ago

Yeah, that example's totally wrong, as you say, the std::vector<int> would get copied by value, so there'd be no issue at all.

tialaramex8• 6 months ago

I strongly encourage people writing textual examples in 2026 to use Compiler Explorer.

https://cpp.godbolt.org/

Matt Godbolt's tool lets your reader play with your examples and learn more about what's going on. As a bonus, if it doesn't compile and work in Compiler Explorer now you know early before you hit "publish". It's the same reason you should run a spellchecker, raweht thun jstu hope forr th bess

vqsubu16• 6 months ago

Why there is the calling of "read(buffer.get());" in the first example (inside of the 'while' loop)?

It is a 'char *buffer' type, unless I'm mistaken raw pointers don't have methods/member functions?

dundarious2• 6 months ago

copy-paste error given the next example uses a smart ptr type that has a .get() to get the actual pointer.

fleshmonad• 6 months ago

Author currently unemployed type post to state in zoomerspeech

Surac• 6 months ago

this article showes very nice what i do not like in modern c++. Packing easy concepts like lifetime and ownership of data behind complex generic named classes. don't get me wrong; i still like OOP, i even use OOP in c (wel OOP like code) but i do not like the concept of packing easy things in complex ones. perhaps im a litte old :)

foldr• 6 months ago

C++ doesn’t really have an ownership system. You can use certain language features to implement certain kinds of ownership discipline, but the language itself doesn’t really have an opinion on who should own what. For example, the article talks about cases where a returned value “must” be deallocated by the calling code, but there is no “must” about it as far as the language is concerned. You’re perfectly at liberty to allocate something without ever freeing it (and this isn’t even a memory leak if the value is needed throughout the lifetime of the program).

Understanding C++ Ownership System

Related Stories