Worse version of this
Null termination is no longer recommended, use fat pointers instead!
Wait. It’s been a long time but shouldn’t be int*** -> int** -> int* -> int ?
I think int*** is meant to be pointing at int**, but the image is just unclear about where everything is in perspective.
Pretty sure the image is clear:
int*** -> int* int** -> int Int* -> intClarity doesn’t mean correct. But that’s probably why it’s posted here. 🤷♂️
int** is inside a TV, and persumably int* must be inside another TV(even though uts not edited in). The image perespective is showing one thing inside the other, inside the other. So when when int*** points the TV it reference int**, which reference int* which reference int. Its just edited very bad
RT*** isn’t pointing at RT*, he’s pointing at the TV showing RT**. The fact you think otherwise is what makes the image unclear. I’m not sure why you insist on them being wrong.
Rumble Tumble Games in the wild
Didn’t expect to see the Drift King here
Drift King? You mean Dan the Villian
Now that explain the & part of the pointers that I never really understood.
The
&operator references the value.int i; int* p = &i;In C++, the
&at the function argument makes it a reference type (safe pointer).void someFunction(int& refVal) { [...] }As someone who likes working with higher level languages, I never understood the pass by reference or even referencing different pointers. It never stuck out to me as useful in what I want software to do. It’s too close to hardware.
Most of the time you pass by reference for more outputs, or by const ref to avoid copying a big-ass data structure (which is not always straightforward, with structures smaller than a pointer, which are pretty big in 64 bits architecture, you lose more to the ref overhead than to the copy IIRC)
Another reason I commonly see: to change the structure / “main pointer” to a data structure (esp during freeing and cleanup).
Reference values are quite useful, such as:
double valOut; if (parseDouble(valOut) == 0) { //Argument of parseDouble is ref type, no & needed for input, no exceptions needed for error handling [...] //No error, code executed normally } else { [...] //Erroreus input }
*x = dereference or “point to”. Treats the variable
xas containing a pointer value. Evaluates to a variable existing at the address inx.&x = reference or “get address of”. Evaluates to the address of
x.They’re complimentary operators, so
*(&x)cancels out and is equvalent to justx.
C# delegates enter the chat and nod.
that’s not LaurieWired
Uh I’m a charisma class (with unfortunate base stats) what’s int
So, confusing, nonetheless.
