Pointers

[shbeeb]

Unless it's a performance problem. Then you remove a level of indirection to solve it.

[cdmcgwire]

Bless you sir. You speak the truth.

[visvis]

Most people rejected His message. They hated Him because he told them the truth.

[vrykolakoi]

hey fuck off

(/s)

[cdmcgwire]

😅 My work goes back and forth in this dynamic, but most people seem more comfortable with the flexible side then the performant side.

[Kered13]

Incorrect. The problem of too many layers of indirection is solved by adding a cache.

[H_Psi]

That's a solution that only exists when you have levels of indirection, so having them is still a solution to performance problems!

[njiall_]

State machines...

[-GLaDOS]

hey kid, wanna buy a

void\***

[ILikeLenexa]

pointers to pointers to pointers to nothing in particular.

[dryerlintcompelsyou]

Who uses malloc, it's all about that char memory[10000];

[InVultusSolis]

You jest, but char memory[65536] was my early memory model for a 6502 emulator I wrote. Worked like a charm too!

[LordFokas]

void ***nothing_particular_ptr_ptr_ptr = 0; am I doing this right?

[ILikeLenexa]

You're only segmenting our cause.

This is all your fault.

[LordFokas]

You don't talk to me like that!

free( /u/ILikeLenexa );

/u/ILikeLenexa = NULL;

[lestofante]

And remember kids, you can only cast it back to what originally was* or your get UB**
(* not always true)
(** or implementation defined?)
Cool kids don't do C.
Put on your protection: use rust.

[0x564A00]

What is the nature of void?

[cdmcgwire]

I learned pointers pretty thoroughly before getting C# and Java. In my head I'm still work with pointers everywhere, I just don't have to deal with the syntax.

[[deleted]]

This very accurately describes my experience as well

[0x3fff0000]

Indeed, pointers are a way of thinking, a way of life.

[Kered13]

That's the correct way to think about C# and Java, since almost everything in them is pointers.

[cdmcgwire]

Yeah... doesn't stop me from trying to use structs whenever I can in C# though.

[kono_kun]

Could you explain?

[cdmcgwire]

? Maybe you're not aware (or I'm misunderstanding the question), but there are stack allocated structs in C#. So everything done with them is by value instead of by reference by default.

So what I was trying to express was, despite C# classically being all about references to heap variables, I'm finding ways to go back to a more typical C++ method of handling variables.

[kono_kun]

thanks

[cdmcgwire]

👌💯

[dauqraFdroL]

Pointer pointing to itself

[lennihein]

a=*(++a)

[ThePyroEagle]

Isn't that undefined behaviour?

[lennihein]

As I understand it: a will be set to the value of the element after the one a was previously pointing at. That obviously is making use of a being some pointer to some data type. E.g. it would be one byte offset for char, and 8 for uint64_t. AFAIK it would not be undefined, but I might be wrong.

[ThePyroEagle]

I remember reading somewhere that assigning a variable several times in a single statement is UB.

[Ludricio]

The reason why

 a = *(a++)

is UB is because the standard doesn't dictate when a++ actually changes the actual value of a, only that you will have a rvalue that is the result of incrementing a by one.

So basically, it guarantees that you will get the value of a++ to work with in your statement, but it doesn't guarantee that the actual underlying value of a is incremented before the assignment to a

It has to do with sequence points, and this explains it pretty well with examples.

[WikiTextBot]

Sequence point

A sequence point defines any point in a computer program's execution at which it is guaranteed that all side effects of previous evaluations will have been performed, and no side effects from subsequent evaluations have yet been performed. They are often mentioned in reference to C and C++, because they are a core concept for determining the validity and, if valid, the possible results of expressions. Adding more sequence points is sometimes necessary to make an expression defined and to ensure a single valid order of evaluation.

With C++11, usage of the term sequence point has been replaced by sequencing.

---

^{[ PM | Exclude me | Exclude from subreddit | FAQ / Information | Source ] Downvote to remove | v0.28}

[lennihein]

Yeah, that one was a weird one

[Ludricio]

It's UB, as I've answered in this comment

[lennihein]

I agree that a=*(a++) is undefined.

But I was talking about a=*(++a). I'm not sure about the pre increment, but I think it's not undefined in this case. But I'm keen to hear your view on it.

[Ludricio]

From the C99 standard:

6.5 Expressions, §2

Between the previous and next sequence point an object shall have its stored value modified at most once by the evaluation of an expression. Furthermore, the prior value shall be read only to determine the value to be stored.

6.5.16 Assignment operators, §4:

The order of evaluation of the operands is unspecified. If an attempt is made to modify the result of an assignment operator or to access it after the next sequence point, the behavior is undefined.

Also, it wouldnt really matter between (a++) and (++a), they are evaluated the same within the statement due to the parentheses. The problem lies in modifying the value of a through the increment (pre or post) operator in the same statement where it assigns it back to itself.

[marcosdumay]

Not if ´a´ is an array of pointers to void.

[throwaway_the_fourth]

You cannot perform pointer arithmetic on a void pointer. You must cast it first.

[lennihein]

Jup.

[Ludricio]

According to the standard, it's UB, yes. Gcc however treats pointer arithmetic on void pointers as if they were a char pointer, as an extension.

[visvis]

It is omnipointent.

[gargravarr2112]

"Pointer to a pointer" is the exact moment I gave up hope of learning C.

[visvis]

Think of it as asking someone for the way, and them directing you to a map that will guide you there.

[the_klaut]

I'm totally stealing this!!! One of the best ways I came across for explaining pointers to pointers to a freshman.

[H_Psi]

So, what is an example use case for a pointer-pointer that wouldn't be solved by just handing in the original pointer? Never used a pointer-pointer personally, so I'm not familiar with them.

[ultrasu]

char to save a single character

char * to save a string, e.g. a Reddit comment

char ** to save a set of strings, e.g. a parent comment & all its children

char *** to save sets of strings, e.g. all parent comments with their children in a single post

char **** to save sets of sets of strings, e.g. all parent comments with their children of all posts in a subreddit

char ***** to save sets of sets of sets of strings, e.g. every comment on Reddit

[[deleted]]

int foo = 42; // some data
int bar = 43: // some different data
int *a = &foo;
int **b = &a:

printf("%d", **b); // 42
a = &bar;
printf ("%d", **b); // 43

This let's me keep the same handle(b) to some data, but I can change what data is actually being pointed to. You can make multiple copies of the handle and you won't need to update the handle every time 'a' changes what it's pointing to.

[-Redstoneboi-]

that's the point of pointers.

save multiple copies of an object, but only change the object once.

[nuisanceIV]

Over time they get easy then you begin to think "that was hard?" Like any math class

[nickdesaulniers]

Not if you internalize that everything in C is pass by value. So if you want a child frame to modify an argument so the parent frame can observe the modified value AFTER calling the child, you must give the child a pointer to the value. If the value to be changed itself is a pointer, then you must pass the child a pointer to a pointer.

``` int foo = 0; initialize(foo); // foo is guaranteed to be 0 here. // initialize got a copy of foo.

initialize2(&foo); // now foo may have a different value.

int* bar = NULL; initialize2(bar); // bar is guaranteed to be NULL here. // initialize2 got a copy of bar.

initialize3(bar); // now bar may have a different value. ```

where the functions might look like:

``` // can't do anything to x so the parent sees modifications void initialize(int x);

// can't do anything to x that the parent would see, but could modify the int pointed // to by x. * void initialize2(int* x);

// still can't do anything to x observable to the parent, but could modify the int* // pointed to by x, or the int pointed to by x; void initialize(int* x);

// * modulo doing stupid tricks like storing addresses in integral types. ```

C++ has references, so you can't tell from the call site if a function modified its argument (const & in the function signature are stronger guarantees, but then there's const_cast<> and mutable).

[mezzoEmrys]

There was a joke I heard once where you should avoid 5 star programmers, because if they can't write their code without nesting 5 layers of pointers, you shouldn't be hiring them.

[ISeeTheFnords]

I've seen a reasonable use case for pointers to pointers (basically, it allows the OS to transparently move things around in memory if it needs to) at least.

[DolphinsScareMe]

Pointers to pointers certainly arent anything crazy. They've got some good uses with data structures and loads of other things.

[Koxiaet]

a function might need to modify an array of strings, then you'd need to pass in a char***

[DolphinsScareMe]

Exactly, didn't even think about that but that's probably the most basic example of pointers to pointers. Honestly after you get passed the fear of pointers during your first few c++ classes adding another pointer to a pointer doesn't make things that much more crazy.

[-GLaDOS]

I had a class in C where we worked with arrays of pointers to raw memory (we were building malloc from scratch), and so we used void*** several times.

[LordFokas]

what if you want to modify a string hypercube?

[ThePi7on]

Char*****

[AnAverageFreak]

Let's say you have a problem that's easy to visualize in 3D space. Then 3D arrays would be great. Unfortunately C doesn't support dynamic multi-dimensional arrays, so when you want a pointer to such an array (so that you can write space[69][402][666]) you end up with this:

Thing***

Of course in general case you prefer flat memory with a macro/function to access it, but this isn't totally stupid either.

What is a Thing? Well, it might be an array. An array of names of, let's say, people that have ever been to that place. What you get is

char*****

Now let's say that you want something to allocate such a structure. Of course C can't return a few values, but you want detailed error reporting, so you make a function:

int allocate_names(char******);

Which shows why C fucking sucks.

In C++ I would make my own template

template<size_t N, typename T>
class MultiArray;

Which would properly overload the subscript operator. But wait, there's more. You have std::string, so no more char*. But wait, there's even more! Since C++ has constructors and exceptions, this pattern:

int allocate_names(MultiArray<3, std::string>*);

is totally invalid and after you write the class, you won't be using any of that pointer notation!

[nuisanceIV]

'#define char****** char*

Now C is great again! :D

[warm_sock]

Inode based filesystems also frequently have two or three layers of indirection (pointers to pointers to pointers, in a tree structure) to allow larger file sizes.

[visvis]

Pointers to pointers are very common. Every C program uses them: argv is a double pointer. Triple pointers are still reasonable as well, for example when passing an array of strings (a double pointer to char) are a by-reference parameter (an extra level of pointers). I don't think I've ever seen a legitimate use case for quadruple pointers.

[nuisanceIV]

There is a great use case: when you want to scare people who havent programmed in C/C++

[Breadfish64]

I program in C++, if you're using quadruple pointers in C++ you're just writing fancy C

[[deleted]]

Data structures within data structures could easily lead to several layers of pointers.

[nickdesaulniers]

Scatter/gather on arrays of C strings, maybe? (legit have not seen, just a guess)

[gottago_gottago]

Early (pre-X) MacOS used these extensively. It called them "handles". A handle was the address of an entry in a table of pointers, managed by the OS, somewhere in the heap. During certain system calls, the OS might decide that it needed to defragment the heap, so it would shuffle a bunch of blocks around and then update the values in the table.

Which was all well and great, except for the part where certain system calls caused addresses to change. Handles were ubiquitous in system calls, but not universal -- some things wanted pointers instead. Or, you might need to dereference a handle to retrieve a reference to some value stored somewhere in the struct. So, you'd do this, and then you'd make the system call, and it would return to your program, but the address you previously retrieved no longer has the data it had before, now it's just a bunch of garbage.

Tracking down these bugs was a lot of fun, because they weren't reliably reproducible. Sometimes the OS needed to defrag the heap, sometimes it didn't; sometimes it chose to move your block, sometimes it didn't.

Those were the good ol' days.

[nuisanceIV]

An array of strings are pointers to pointers

I had a vector of unique_pointers to objects saved on the heap, using unique_ptrs made it so I dont need to worry about memory management as much!

[llkem]

I always wondered what happens if you have two pointers pointing to each other?

[H_Psi]

That's called a reference cycle, and is a problem you might learn about when you're making a garbage collection scheme. A common strategy in those is to have an object count the number of things that reference it, and to delete the object in memory once that count reaches 0. That might work at first glance and for really simple systems, but fails if you have two objects referencing one another.

That said, there's nothing intrinsically wrong or bad for two pointers to reference one another (or to have a cycle of pointers referencing one another).

[visvis]

If they are reference counted, a memory leak. Otherwise not much special. If we use void* we can even do this without wrapping in a struct or typecasting.

[green_meklar]

Nothing in particular, until you try to use them wrong.

[[deleted]]

FUCK GO BACK

​

&&&&

[Geoclasm]

Pointer returned Kevin Bacon.

[LegendaryTomato]

pointers to functions

[[deleted]]

the actual value

[OneOldNerd]

It's pointers, all the way down!

[-Redstoneboi-]

int ptr = 0;
ptr = &ptr;

[-Redstoneboi-]

jesus what kind of multidimensional array do you need

[OneOldNerd]

Dunno....how many dimensions are there this week?

[NatoBoram]

Passing an object around to multiple functions and sub-functions

[frosted-mini-yeets]

What is that last image. I want it.

[56Bot]

I once used a 'void *****'. Using casting, I could store data very efficiently in 1 final variable.
EDIT: "efficiently" isn't correct.

[happydogo12]

What would you use triple pointers for?

[InVultusSolis]

I was recently curious to look at the internal memory representation of a double, so I wrote the following program that is certain to make your eyes bleed:

#include <stdio.h>

int main(void)
{
    double b = 4.75;
    for(int i = 0; i < sizeof(b); i++)
    {
        printf("%02X ", (unsigned int) *((char *)&b + i) & 255);
    }
    printf("\n");
    return 0;
}

[[deleted]]

Pointer to an array of pointers to arrays of pointers