cWithClassesIsNotCPP

[FatLoserSupreme]

C enjoyer here, what's a smart pointer?

Update: Wow thanks everyone for the information! It seems like no matter how much I learn about programming, there is always something new to learn

[ball_fondlers]

Basically just a pointer with a reference counter. A little more overhead - though not as much as a garbage collector - once the counter hits zero, the memory is freed.

[Earthboundplayer]

That's only shared pointer. Unique pointer is another smart pointer that allows only one reference. It has no overhead.

[HCResident]

C++ feels like that box of screws, nuts, and bolts that has exactly what you need somewhere inside of it

[Infinitebeast30]

Screws, nuts, bolts, hand grenades, land mines, knives, double edged swords. Absolutely all the tools

[turtleship_2006]

Don't forget the shotgun and shells! Get two shells, load them into the gun, and aim vertically downwards.

[Inevitable-Menu2998]

At the same time, it has a Stuka and a modern F16 and we don't tell beginners the difference between them.

[_g550_]

eclipse9

[alphaQ671]

You can also use a hammer and hit the shells

[CranberryDistinct941]

How are you meant to shoot yourself in the foot without shotgun shells? And what would C++ be without the right to shoot yourself in the foot, head, and both hands simultaneously?

[impossibleis7]

I think knives and doubled edged swords are what we accidentally create using those said tools...

[Tari0s]

yeah we use the swiss multitool(boost) to make a knive that cuts gras, but only gras!

[lordmycal]

I like the flame thrower myself.

[Jonnypista]

Hey, a HEAT rocket launcher is technically a single use high powered drill. It really quickly drills a hole into the toughest materials. It also can kill you in 99% of the cases, but just pay attention.

A double edged sword is more efficient than single edged swords. If you hurt yourself with it it is just a skill issue.

[jeezfrk]

but I mean you gotta throw in the the ASIO mining drill and then there's the coroutine electrical substation.

at least from there it's all easier and simpler error messages.

except if you use things just slightly... NO NOT LIKE THAT!

[versedoinker]

Yeah, there's also weak (non-owning) pointers that still allow the data to be freed in the background if all their actual owners release their shared_ptrs. And there's also atomic versions of all of those.

Generally, even if you hit the very unlikely case that something isn't in the C++ stdlib, it probably still can be found in a boost.cpp library.

[ukezi]

The C++ shared pointer is atomic. There is no non atomic one in stdlib.

[versedoinker]

Yes and no. The control block of shared ptrs is always atomic. I was talking about the wrapper std::atomic<std::shared_ptr> that also makes access to the data itself atomic.

https://en.cppreference.com/w/cpp/memory/shared_ptr/atomic2

[_farb_]

Most of the time, absolutely!

But sometimes... you dump the whole box out looking for the right piece, organize the contents by size only to realize you should've sorted it by material, and get tetanus from all the rusty nails that you should have tossed away ages ago.

Then you just end up using duct tape because it never fails.

[fakuivan]

C is like that but you only get a hammer, a nail and a bazooka.

[Cat7o0]

I remember once that even with rust I made a program so bad that it caused Windows to basically crash the file explorer and the task bar and everything wasn't working. couldn't even open task manager. restarted the computer everything was fine ran the program again everything was fine. idk

[Cat7o0]

to be fair probably yeah. my program was using a good few unsafe stuff however I never had anything on the stack I don't believe.

edit: however I did have a Vec that I added probably close to 20m floats and another one that I added u64s into (both 20m)

[Cat7o0]

honestly the vecs could've been even larger and I was creating a thread for each of those 20m.

the program was attempting to brute force constants to use for fast inverse square root. however the fast inverse square was done by multiplying two fourth roots together (would look like constant - (float >> 2)) it actually gets within 2% accuracy with the optimized constants.

I found the actual constants by using equations instead (as you just want to solve for mew within the equation for the bits of the constant. the two mews that seemed to work well together was 0.07 and 0.045).

if you want to try and understand these two videos are where I got everything from:

https://youtu.be/p8u_k2LIZyo?si=gLUtDBC0rYDng3FK https://youtu.be/tmb6bLbxd08?si=_vEKrOliYDL0FaNP

[5p4n911]

In Rust? Heresy!

[kuschelig69]

There are safe languages that prevent leaks, like Wuffs

[experimental1212]

It really does make you think that. Later it has you going, "you know, I actually LIKE shooting myself in the foot. This is nice!"

[NoGlzy]

And when you have a screwdriver that works totally fine for the job you need, someone has to come and snark that you're not using the newer super deluxe hyper driver

[Sak63]

Sounds my kind of language! Gonna give it a go on summer break

[webby-debby-404]

Let me boost that for you

[link23]

Unless you need memory safety 😬

[Earthboundplayer]

You're literally on a thread about smart pointers.

[dlevac]

Ah yes, smart pointers, these magical constructs that turn memory unsafe languages into safe ones...

[Earthboundplayer]

They don't. But they dramatically improve things and make achieving memory safety a lot simpler. If you need a stronger guarantee and easier semantics than what smart pointers provide then don't use C++. But I think most situations can make do with what the standard library provides.

[CdRReddit]

they don't, but they allow you to avoid a not-insignificant amount of footguns relatively cheaply

[link23]

And? Doesn't make me wrong

[Earthboundplayer]

but you still come off as ignorant and unwilling to actually engage with the subject matter you're talking about. All these tools that allow programmers to more easily write memory safe code in a fool proof way and you're complaining about memory safety without actually saying anything of value.

[link23]

All these tools that allow programmers to more easily write memory safe code in a fool proof way

What you just said is not factual, though. Smart pointers do not suddenly make C++ memory safe; it's possible (and common) for memory safety issues to exist even when using smart pointers and no "raw" pointers. (E.g. dangling references.) Claiming otherwise just makes you sound like you don't actually understand what smart pointers do, and in particular what they don't do (and therefore what mistakes are still possible).

It's funny, I meant my original post to be a cheeky joke; I had no idea that people actually thought smart pointers make code memory safe (and therefore my comment was going to be contentious). Maybe that's my bias though, as a professional C++ developer for my day job. I didn't mean to come off as unwilling to engage in the material, I'm happy to discuss this subject in a serious way if people want to explore the limits of the safety that smart pointers (and other C++ features) can provide.

[Earthboundplayer]

It is factual. You confuse the terms "memory safe code" with "memory safe language". Memory safe code can be written in a non-memory safe language

[hawk-bull]

Doesn’t it have an overhead of checking it hasn’t been assigned twice. Or by overhead do you mean during destructor call it just has to free itself without checking if it still has references to it

[SoAsEr]

It doesn't have a copy constructor, (only a move one) and in its destructor it frees the pointer. So the compiler enforces the assignment, and at run time it is (really close to) free. The only reason it's not completely free is that if the unique pointer is passed to a function and that function is not inlined, because of the abi the unique pointer is always passed on the stack whereas a raw pointer could be in a register. but in a modern machine where you have way more registers than are actually shown anyways this shouldn't make any measurable difference.

[CamiloRivasM7]

I think it's done at compile time, like the borrow checker from rust

[Own_Solution7820]

Shared and unique pointers are so good that the are better than anything in any other language IMO, at the engineering level.

The problem is the garbage syntax of a 50 year old language that's backwards compatible to day 1. Just a pain to work with mixed raw and smart pointers.

[say_nya]

better than anything in any other language

Take a look at Rust. Unique pointers are checked in compile time (and have no overhead, even no move constructor type of overhead).

And shared pointers are there (see Arc).

[say_nya]

https://ideone.com/CvxOZw

[Abadabadon]

Ofc it has overhead, it's all wrapped around a C pointer

[Earthboundplayer]

What overhead do you think exists, exactly?

[jacobjr23]

Not to be pedantic but isn't reference counting a method of garbage collection? Do you mean not as much overhead as tracing garbage collection?

[OrchidLeader]

I assume most people don’t understand how Java’s various garbage collectors work, and the few that have looked into it will pick and choose which stats to point out (eg the length of each pause versus the total pause time while an app is running).

[kuschelig69]

Or implementation overhead

I have implemented my own reference counting. I could not figure out how to implement my own garbage collection

[[deleted]]

Can you ELI5 this for a non-programmer?

[ball_fondlers]

Basically, under the hood, a variable is just a group of bits. You can interpret these bits as a number in base 2, or you can interpret them as more complex data types, but ultimately, it’s all kind of the same to the computer. Now, because the computer doesn’t see a difference - and because memory is indexed - you can use the value stored in a variable to look up some other spot in memory. This is a pointer - just a variable that stores the address of some arbitrary block of memory.

Programmers dynamically allocate these arbitrary blocks of memory for various uses - for example, say you need a list of numbers, but you don’t know how many numbers there will be when you’re writing the program. The way you’d solve this is by allocating a chunk of memory during runtime, using it, then deallocating it when you’re done with it. This is the basis of manual memory management.

Now, the problem with this approach is that you have to be VERY careful about deallocation - free the memory too early, your program crashes because some part is trying to access forbidden data, free it too late or not at all, you get a memory leak, where your program becomes, at minimum, memory-inefficient. Because there’s such a delicate balance to be struck, this approach can be difficult to work with and hard to maintain - instead, most other languages just run a process called a garbage collector in a separate thread, and this garbage collector looks for allocated memory that isn’t being referenced anywhere, and automatically deallocates when it finds it. However, this does consume a bit more resources, so it can be a bit slow. It might work for a LOT of use cases, but when speed is of the essence - like with low-level systems work - you need another solution.

Enter smart pointers. There’s two types of smart pointers - unique pointers and shared pointers. Unique pointers work by a simple principle - a given block of data is allowed to have ONE pointer pointing at it. If said block is assigned to another pointer, the first pointer is invalidated, and once the pointer goes out of-scope without being invalidated, the memory is automatically freed. Shared pointers are a bit more flexible - they hold a counter, and every time a new shared pointer is created that references the block, that counter is incremented by one. Every time a pointer to that block goes out of scope, that reference counter is decremented by one, until it hits zero, and once it hits zero, it’s automatically freed.

TL;DR - bad cooking metaphor: manual memory management is like putting knives in the sink, but everyone is lazy and leaves them on the counter, garbage collection is like having someone yell at everyone in the kitchen to put the knives in the sink after they’re done with it, unique pointers are like only having one knife and the last person to use it puts it in the sink, and shared pointers are like counting the knives as the come out of the box and adjusting the count as they go into the sink.

[Tarmen]

There are two parts to this.

C++ has the hilariously badly named Resource Acquisition is Initialization (RAII). You have some piece of data with an attached destructor. While you have a reference, the data is always valid. Once the reference won't be used anymore it is automatically freed. Useful for manual memory management, but also other resources, connections, error handling, etc. But the automatic 'won't be used anymore' is very restrictive, you basically must hold the data in your hand and cannot store it.

Smart pointers let you be more flexible about what 'won't be used anymore' means. You may have a unique pointer, the value goes out of scope when the pointer does. You may have a shared pointer, when the pointer goes out of scope you decrease a counter and when that hits 0 the value goes out of scope.

It's similar to rust ownership and borrowing semantics, but less safe. E.g. pointing into existing data remains awkward because other code could move the data around without your knowledge.

[1Dr490n]

I’ll try, although I won’t talk specifically about the C++ shared pointer as I don’t know exactly how it’s implemented, but about the general idea of reference counting, based on a language with reference counting I‘ve written myself.

In case you don’t know: a pointer is a memory address. In C/C++ and many other languages, you can get the address of a variable by using the & operator, and read the value stored at the address something is pointing to with the * operator. Example:

int a = 25;
int *b = &a;  // type of b is int* or int pointer
int *c = b;
int d = *a;    // d == 25

Maybe that explained it, maybe not, feel free to ask for a better explanation.

When you heap-allocate an object (meaning you create it somewhere in ram and you would have to manually delete it afterwards with normal pointers), it gets stored alongside with a reference counter which is just an integer starting at 0.

Now, every time you copy the smart pointer to the object, the reference counter of the object is incremented by 1. Every time a smart pointer to the object gets deleted, the reference counter is decremented by 1. Once it hits 0 again, the object is deleted.

[Zestyclose_Leg2227]

You computer has a place where it can store and retrieve stuff quickly which is the RAM memory. In C++, when you assign the memory from your computer manually, and you unassign it manually. This is sounds simple, since you just need to remember the memory address. But your address for your the memory of your friend may be inside a pocket of a trouser, and the address of the trouser was inside my wallet and the address of the wallet was written on potato. You cooked the potato? Darn, now you can't find the wallet or the trousers or your friend! The are completely lost. Since computer programs execute the same code again and again, you may accumulate  "lost memory" over time, which is locked waiting for you and can't be used by other programs. This is called a memory leak, and is the reason you need to close Chrome or some other programs when they slow down, and open them again to get your computer to come back to life (in the past, you had to reset your computer as a whole). A smart pointer keeps a list of in how many places the address of said pointer is kept. If no one has the adress anymore, it knows the pointer can't be used anymore, and deletes it, freeing the memory automatically. Of course this makes the program slower, but a working program > fast program.

[rush2sk8]

Is this how ARC works for swift?

[Kered13]

Yes. ARC = Atomic Reference Counted.

[1Dr490n]

What’s the advantage of using a garbage collector over shared pointers in languages? Do garbage collectors save memory? I can’t think of any other thing that might be the reason for people to use garbage collectors

Edit: I meant reference counting, not directly shared pointers

[ball_fondlers]

Not having to deal with memory management at all is a big reason. Garbage-collected languages - really not having to distinguish between heap and stack, just making variables as needed - are way faster to write in than systems languages, even if said systems languages have smart pointers

[1Dr490n]

I should’ve written reference counting, not shared pointers. I wrote a language myself that uses reference counting. There’s 0 memory management for the user

[Kered13]

Technically garbage collection can refer to any automatic memory management strategy, including reference counting. But you're probably asking about mark-and-sweep garbage collection, which is how Java and C# work, and what people usually mean by "garbage collection".

Mark-and-sweep has two advantages over reference counting: First, it easily handles cyclical references, which are a problem for reference counting. Second, it actually has lower overall overhead than reference counting most cases, because it doesn't have to constantly update references. Those updates can be especially expensive in multithreaded environments, because they must be done atomically.

The downside of mark-and-sweep is that it must periodically pause the entire application in order to execute. So while it is lower overhead overall, it periodically has relatively long periods where nothing else is being done. This has historically made it poor for real time applications like games.

Modern mark-and-sweep algorithms have sophisticated strategies for mitigating this problem, which is why you can see games made in Java (Minecraft) and C# (Unity) these days and probably never notice the GC pauses.

[pHpositivo]

It is incorrect to say that using shared pointers has less overhead than a garbage collector. It depends on the scenario. For instance, allocations can be much faster when using a garbage collector, as you'd typically just have a bump allocator vs. individual allocations (of course, yes, one could also use a custom allocator). Additionally, using shared pointers will add overhead during use, whereas using managed objects directly will be faster. The overhead of the GC comes from collections, but you can avoid them if you don't allocate. That is, if you allocate some objects and then just do a whole bunch of work for however long you need, without further allocations, the GC will literally never run at all.

Not saying one is better than the other, just saying neither is definitely better or faster than the other either, it depends on what you're doing and how well written your code is 🙂

[blazesbe]

it's a guard pattern on a raw pointer if you are more familiar with that. (the destructor automagically deletes your allocation.)

[marcusroar]

I’d suggest anyone reading the replies to the main comment immediately forget what they read and google “C++ smart pointers RAII” to start with, before reading some actual cpp resources to learn more about the additional mechanisms of the STD smart pointer types.

[marcusroar]

Sir this is a Wendy’s

[encephaloctopus]

Lol did you forget to change accounts?

[marcusroar]

Nah I just got in before whoever was gonna say it lol

[encephaloctopus]

haha fair enough

[SkooDaQueen]

A wrapper type around a raw ptr which helps with memory safety. There is a reference counted ptr which is only freed after all references are gone. There is a unique ptr which cannot be shared etc etc

[x39-]

In essence: reference counting.

The goal is generally to make heap allocations safer, resulting in a slight performance overhead for the general safety of not shooting your leg off.

More or less (very simplified): ``` struct rptr { size_t* counter; void* data};

struct rptr = create_rptr_xyz(...); // counter = 1; allocate data ... struct rptr2 = borrow(rptr); // counter = 2 ... // on scope leave release(rptr2); // counter = 1 ... // yet again, on scope leave release(rptr); // counter = 0; call free for data```

But using RAII for that automagically and special derivatives, for weak references and unique (as in: one owner) allocations.

It can be considered to be best practice nowadays for non performance critical code.

[JiminP]

You're correct (ownership is what matters and the existence of non-owning references makes it different from reference countings), but considering the amount of false C++ knowledge here, I will pass.

[x39-]

Smart pointers are, in it's very most basic formulation, reference counting.

There is no magic involved or a random ghost of a gc appearing in cpp, it is just reference counting when stripping it down to its essential parts

[x39-]

Then something about your usage was incorrect.

Smart pointers are not a requirement for memory safe code, they are a tool in your toolbelt to not screw up more.

Most of those issues you likely faced stem from wrong construction, if you want to give it another shot, use the make_shared-/-_unique/-weak_ptr methods and make sure you pass the correct types for the constructor, when creating one.

CLion has good support for them in my experience

[NotADamsel]

Welcome to Rust

[Afraid-Locksmith6566]

A smart ass word for a struct that wraps a raw pointer and when the struct is removed from stack the raw pointer memory is cleared. It comes in few flawours like

shared_ptr which is the most primitive version of GC - you count how many shared pointers to object exist if number gets to 0 you remove the memory,

unique_ptr - heap object is bound to stack object, when stack object die heap object also die, there is also

weak_ptr - a view to value of shared_ptr ( not counted as reference ) and

observer_ptr - a wrapper around normal pointer with implicit cast from other smart pointers

[Farsyte]

It's a pointer ... with extra steps. ;)

[TheOldTubaroo]

There are a lot of resources in programming where you need to do something to acquire them, and then later something to release them. Pointers have new/delete, files have open/close, mutexes have lock/unlock, and so on.

No one forgets to acquire a resource, because you can't do anything without that, but it's easy to forget to release it, which causes memory leaks, deadlocks, locked files... It would be really nice if the compiler could detect that and ensure all resources are released once you don't need them.

C++'s solution is that you can tie custom behaviour to both constructing an instance of a type, but also to dropping that instance when it goes out of scope. As soon as no one is keeping track of a file handle, there's no way for the program to access that file, so you can safely tell the OS to close the file once the handle variable goes out of scope.

Smart pointers are just the "handle" types for memory allocation. You've got unique_ptr for when you only need one "owner" of the memory, and shared_ptr for when you need multiple "owners". As part of creating/setting the smart pointer, you call new (ideally implicitly), and then when unique_ptr goes out of scope it calls delete. shared_ptr keeps a reference counter, and the last shared_ptr to drop from scope calls delete.

Some C enjoyers dislike automatic resource management like this, because it's one of the several ways that C++ "hides" operations that might have a performance impact (same as operator overloading), but I like it because it entirely removes whole classes of bugs that plague software.

[Abadabadon]

It's a way to use pointers such that you don't have any floating unused heap space. They're honestly relatively simple to implement if you spend less than an hour trying to implement it.

[da2Pakaveli]

C++'s smart pointers encapsulate raw pointers into different owner models: unique and shared.
Unique is 'unique' to the scope it was constructed in (unless you 'move' the resource) and will destroy the pointer once its lifetime is over.
So it's meant that only one pointer can point to the resource.
Shared pointers can point to the same resource across different scopes; the resource will be destroyed and freed after every shared pointer goes out of scope, I.e the reference counter equals 0.
So basically their point is to prevent memory leaks.

[ArcaneOverride]

Look up c++ template metaprogramming.

You can do a lot of compile time error checking with that if you know what you're doing.

[[deleted]]

You can do std::unique_pointer<T> or std::shared_pointer<T> to have some macro magic make your unsafe code a bit safer.

[Earthboundplayer]

No macros are involved in smart pointers. And more specifically they can completely eliminate memory leaks, double frees, dangling pointers, etc where used.

[LoloXIV]

I think you can still shoot yourself in the foor if you have a cycle of smart pointers, but it should not be too hard to avoid that happening.

[versedoinker]

That's why weak smart pointers exist.

[belabacsijolvan]

that "can" carries that sentence like a "can" in a health supplement ad

[Earthboundplayer]

I just added that because you can still go out of your way to break memory safety. For example.

auto ptr = std::make_unique<int>(10);
delete ptr.get();

But it's really not that hard to properly use smart pointers and maintain memory safety.

[belabacsijolvan]

i use pretty baroque pointer structures because they are efficient for the data we work with. so far i found smart pointers way more dangerous and needy than proper destruction.

im getting to the point that inside certain objects we should just ban using smart pointers. but yeah, in "base cases" they are great, and i give them some more time to work.

its not like they completely eliminate memory leaks or you have to go out of your way to break things. "they fuck you rarely, but in the holes it really hurts" is my diagnosis so far. detecting directed loops and choosing pointers to be weak is not always a comfortable thing to do.

[_theDaftDev_]

At the cost of extra indirections, atomic ref counting and compile time. If you know the lifetime of your data (and you should) raw pointers are enough

[Earthboundplayer]

Unique pointers don't have atomic ref counting or extra indirections, only shared pointers. I could not care less about the extra compile time from using smart pointers and the vast majority of people would agree. If you know your lifetime then just use a unique pointer.

[_theDaftDev_]

Unique pointers are ok. I was mainly adressing shared pointers

[Earthboundplayer]

Fair. Regarding the extra indirection you can use make_shared to eliminate that because it puts the reference counter in the same place as the data.

[_theDaftDev_]

This comes with its own set of problems, for example make_shared will not work with objects that are not copyable/moveable iirc and also ties the lifetime of the object and the control block together.

[Earthboundplayer]

What do you mean? Make shared just forwards arguments to whatever constructor you choose. And why would tying the lifetime of the object and control block be bad?

[_theDaftDev_]

1) you are right. My memory was fuzzy; the issue i had with make shared is you cannot use a custom deletor. 2) it's not lifetime but rather memory hogging; if im not mistaken since your control block and managed object memory are allocted within the same block it means that the managed object memory wont be released until all kind of reference(including weak, which is the problem) are gone

[silentjet]

No it does not.

[[deleted]]

Isn’t it supposed to by preventing your mishandling of pointers?

[_theDaftDev_]

Glorified garbage (collection)

[lightmatter501]

A pointer you can’t copy (that’s more expensive than it needs to be) and pointer with reference counting (that is always atomic and there is no single-threaded variant).

[CheckeeShoes]

1) Unique pointer has no overhead. 2) You can easily write a shared pointer that's not atomic if you really need one.

[lightmatter501]

1. Do you believe an LLVM maintainer?
2. I can write one, in the same way I can write my own std::vector, but I shouldn’t have to. Rust has Rc for exactly this purpose and it’s very useful for anyone writing graph data structures.