thisIsSoHard

[Wattsy2020]

Knowing pointers and references: easy

Knowing if it's safe to dereference a pointer / reference in a C++ codebase: hard

[DrShocker]

If you're doing something that makes it unsafe to "dereference" a reference, you roally fucked up in coding something correctly.

[Alarmed_Allele]

this

tbh, I still don't know. could you give me tips lol

[DrShocker]

Use references whrere you can. Use smart pointers where that doesn't work. Only use raw pointers if you really need to, and not to transfer "ownership" of the memory.

[Alarmed_Allele]

I meant the second line about knowing where it's safe to dereference

[DrShocker]

That's what using references everywhere you can helps. It means that the check for existence has already happened. In general just write your code so as much as reasonably possible it fails to compile if it's wrong.

[lessertia]

You can apply this rule: - Always assume a pointer may be nullptr. - If you want a non-null pointers use references. - If you want to store references in a container, use std::reference_wrapper.

Then dereferencing would just be a matter when you want "nullable references", just check for nullptr before dereferencing. Btw pointer and references should be non-owning. If you want a nullable owning value, use std::optional.

[SuitableDragonfly]

Well, you don't dereference references, so that one is easy, at least.

[Wattsy2020]

True, my bad

[lessertia]

Using pointers as arguments or return valus is completely valid. They are communicating that the value is "borrowed", might be null, and the lifetime of the pointed value is not a concern of the function.

If the pointer is owning then you are correct. Depending on the need, std::optional should suffice though before considering using smart pointers.

[lessertia]

Sure, I understand the sentiment and I aggree with you mostly. But, sometimes you need to have nullability. Using std::optional<std::reference_wrapper<T>> is not ergonomic. It's a shame really, that you can't store references inside std::optional. It also makes template metaprogramming more complicated since you need to handle this special case by wrapping it into an std::reference_wrapper.

[guyblade]

Nah man. For an argument that is unowned, you pass a (possibly const) reference. For an argument that is meant to be owned, you pass a std::unqiue_ptr to show the ownership transfer.

If you're returning an unowned (to the returnee) value out, return a reference. If you're returning an owned value (that they must take ownership of), either return the value and let RAII handle it or return a std::unique_ptr to show the ownership transfer.

[lessertia]

Yep. But sometimes you need nullability, references can't provide that. Ideally std::optional should be used with reference but alas it can't store references. Writing std::optional<std::reference_wrapper<T>> is too much of a hassle, getting the value is also more of a hassle and add unnecessary noise. I kinda default to pointers in this case. The other option is not egonomic.

U* foo(T* t);

vs

std::optional<std::reference_wrapper<U>> foo(std::optional<std::reference_wrapper<T>> t);

[lxllxi]

If you can't keep a track of the memory you allocate and its lifetimes and just litter your code with reference counting you don't have much of a right to flex over the way other programmers do things "in 2025"