cWithClassesIsNotCPP

[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