the :================D operator
I’m not sure if this is serious or not and that scares me.
Rest of the world: We’re deprecating C++ due to lack of memory safety. Please consider doing something for safety.
C++ commite: Here’s a new convenient operator to make it easier to do a potentially unsafe, multi-level pointer dereference.
I honestly don’t know why they even have -> instead of just a dot like everyone else. The compiler knows whether it’s a record, object, pointer, or any level of pointer to pointers.
Why make the programmer do the donkey work?
It’s important for objects that can be dereferenced. Smart pointers have methods that can be accessed with dot syntax like
swap(). You can still dereference through a smart pointer using arrow syntax to access methods on the referenced type since they overload theoperator->()method.Operator overloading allows you to redefine what each operator does. It’s essential to achieve a truly fucked up code base
C++26: remove C++
Why do you even have pointers to pointers?
many reasons, for example
- multidimensional arrays
- arrays of function pointers
- pass by reference of a pointer
Because stuff can own other stuff and be owned at the same time. Also, arcane jackarsery.
Edit: if you want to give a function a pointer that it may change this may occur in a constructive way. I.e. replace an owned object.
Mostly because at the lowest level of computing (machine code and CPU instructions), pointers are the only method (that I know of) of any kind of indirection.
At the lowest level, there are 2 types of references:
- CPU registers
- memory addresses (pointers)
Every higher level language feature for memory management (references, objects, safe pointers, garbage collection, etc) is just an abstraction over raw pointers
Pointers themselves are really just abstractions over raw integers, whose sole purpose is to index into RAM
With that in mind, pointers to pointers are a natural consequence of any kind of nested object hierarchy (linked lists, trees, objects with references to other objects, etc)
The only other kind of indirection would be self-modifying machine code (like a Wheeler Jump). But the computing world at large has nixed that idea for a multitude of reasons
linked lists, trees, objects with references to other objects
That’s not a pointer to another pointer, but a pointer to a data structure that happens to contain another pointer.
The distinction is meaningless in the land of Opcode’s and memory addresses
For example, a struct is just an imaginary “overlay” on top of a contiguous section of memory
Say you have a struct
struct Thing { int a; int b; Thing* child; } Thing foo {}You could easily get a reference to
foo->child->bby doing pointer arithmetic*((*((*foo) + size(int)*2)) +size(int))(I’ve not used C much so I’ve probably got the syntax wrong)
Yes, you can do crazy shit if you try hard enough, but every reasonable programmer would access
foo->child->balsfoo->child->band not via that crazy LISPy expression.By question was: Why would you have a pointer to a memory address that itself only holds a pointer somewhere else?
So far the only reasonable explanation is from @Victoria@lemmy.blahaj.zone:
- arrays of function pointers
- pass by reference of a pointer
I’m more talking about theory than practical.
I’ve not developed anything in C/C++, so I don’t know practical uses for a double pointer, aside from multidimensional arrays, or arrays of pointers
My point was that, conceptually, pointers to pointers is how most complex data structures work. Even if the C representation of said code doesn’t have a
int**somewhere
Magic.
Blasphemy.
Because int main(int argc, char** argv)
I pray for this to be real because it’s the perfect syntactic sugar for C++. The kind that you’d think makes sense if you didn’t have to write C++ for anything more complex than a high school project.
TIHI
Please don’t give them ideas
C++ is a joke.
New feature with terrible syntax. There are features of every language I choose not to use. As a C++ developer, I would choose not to use this syntax, so that my team can write better designed code. However, I am an oddball on my team for loving trailing return types. In peer review, the schlong operator i.e.
--->would only be used where it makes sense which should be nowhere.Peer reviewing this seriously would require knowing more context. Instinct tells me
MyClass****is probably allocated from the heap. A possible reason for so many levels of indirection are jagged arrays. Maybe the function only gets the first element of each level of the arrays. The function name doesn’t make that clear. This is poorly designed. Please re-design/re-write. I will happily review those changes. I expect unit tests to show example use cases.I would suggest using a stack allocated array with sentinels for missing values to improve cache coherency. Without context, I assume looping over the jagged structure will be common. Loading more into cache should improve efficiency in loops, but benchmarks are required.
Wait… I should join the crowd. So I say, “down with C++” and up with some safe alternative. Maybe rust: https://github.com/Speykious/cve-rs.
Best i can imagine, this is what happens if you are terrified of smart pointers, but also want to make all object pointers scope specific. So at every layer of hierarchy, you have a unique reference to some partial implementation above and below it.
Honestly I struggle to imagine any real scenario where this would make sense… except maybe like some kind of insane recursive factory.
Violates the Law of Demeter