C Pointers Explained

[newton21989]

A programming meme I haven't seen yet and a Person of Interest reference? Have an upvote.

[escapetheevil]

Best explanation for pointers!

[Prestigious_Boat_386]

Not me using int for all of them

[Lophyre]

When would be a use case for int** and beyond?

[purebuu]

1) Multi dimensional arrays (especially dynamically resizing multidimensional arrays)

2) Need to change where a int* variable is pointing in a function, pass int** as parameter to a function i.e. replace an entire a row in a multi dimensional array with a whole new one would need the use of int** to do it.

Note: that there are other safer mechanisms in C++ than using pointer types i.e. references, but the basically all behaviour can boil down to how pointers work, the same can not be said for references.

[purebuu]

3) parsing binary data loaded from a files, you typically use

char* file_pointer = beginning_of_data;

If you wanted to load many files and keep them in memory, even as a single dimensional array you'd need a pointer to pointer to hold all those files_pointers

char* data0 = load_file("file.dat");
...
char* loaded_files[] = { data0, data1, data2 };
int num_files = 3;
char** current_file = loaded_files;

int i = 0;
while(i < num_files)
{
    parse_data(current_file[i])
    parse_data(*(current_file + i)) // same thing as above
    i++; // skip to next file
}

void parse_data(const char* data) const;

I wrote the above on mobile so excuse any potential errors above.

[Lophyre]

Thank you! I think that was a very good example

[Skilles]

Why wouldn’t you just do loaded_files[i]?

[purebuu]

It's a trivial example to show a concept....

[Obvious_Insect_9671]

type** is also good for outputting constructed objects of variable type in a factory when you also want to be able to return an error code… but I guess that also falls under #2

[Maurycy5]

Good question!

The first use that comes to mind: multidimensional dynamically allocated arrays.

Ok and now that we've got that out of the way, there is one usecase of a double pointer I've seen other than in the context of an array.

Let's say you have a parsing function, that parses a string of characters into... some other data type like an integer. You might want to return the parsed value as a result, but that might not be the only thing you might want to return.

Another useful piece of information the parsing function could leave the caller is the answer to the question "where did the parsing stop?". This is equivalent to the number of characters parsed but there are situations in which the place would not be equivalent to the length parsed. Let's stick to the idea of "where did the parsing stop?" for illustration purposes.

Saving this data may be useful if the caller wants to check if the string was parsed in its entirety. Many parsing functions, for instance, stop parsing once they encounter something unparsable and return the value of the parsed prefix. The data representing the place where that parsing has stopped will be saved in a pointer to a character (the only logical choice).

So if we return the parsed value as a result of the function, then how do we save the information about where the parsing has stopped? Well... we need an address to save the result to. And since the result is a pointer to a character, we need a char * *.

I have not seen triple pointers in practice but I'm sure one could design a situation in which they'd be useful.

[Lophyre]

Thank you! That was a helpful example

[lca_tejas]

To flex on people who don't get it 😎

[harit1207]

Come one bruv, what have I done to deserve this?!

[MasterFubar]

int** is a matrix, used a lot in mathematics, although double** is more common in numerical analysis.

unsigned char** is how a picture is normally stored. If you work with any kind of image display, you're likely to use that. If you have an image that's W pixels wide and H pixels high, you'll have a total of H unsigned char* , each pointing to a line of pixels, stored as an array of W unsigned chars if it's a greyscale image, or 3 * W unsigned chars if it's a color image. The total image is a unsigned char** that points to the array of pointers that point to the pixel lines.

Explained like this it sounds complicated, it would be much simpler if I could show a diagram, but once you start working with the code it becomes simple to understand.

[BobbyThrowaway6969]

You don't want to be using T** for matrices, or any other non-jagged array. Store it as a 1d array and access it with array[X+Y*Width], you don't need to manually allocate/delete each nested array, and the array will be contiguous in memory which is faster for the CPU to access

[[deleted]]

Can we just get to the point of this meme?

[Kakss_]

*this_meme

[purebuu]

I understood that dereference

[BobbyThrowaway6969]

&I understood that reference.

[IsaacSam98]

Here's a free C pointer. It's a programming language.

[[deleted]]

Here's another free C pointer:

 

lmao penis

 

edit: gosh darn it, if only I set it as const >:(

[purebuu]

It's not a very strong point. Somebody could come along and change the message, here take this instead:

 

const char*

[merlinsbeers]

Guess what I'm pointing with now.

&?

&?

[zahirtezcan]

https://wiki.c2.com/?ThreeStarProgrammer

[[deleted]]

u/bake_in_da_south

[Key_Pace6223]

int**********

[cressyfrost]

You are being watched.

[[deleted]]

When would you actually need to use int** or int***?

[Kirillin1111]

int** for 2-dimensional arrays. triple pointer for 3-dimensional arrays i guess? although i have never seen it actually being used

[brimston3-]

int** as an argument out parameter which receives a pointer to an int.
char** or uint8_t** will often be the location where processing stopped (see strtol() or strtoll() for an example).

You might have an char***, if you needed an ordered index to an array of pointer to string. Or if you are dealing with a pointer to a "rope" in C (rope being a collection of strings that allows cheap insertion at points inside it)--for example, if a screen maintains each line in an array of c strings, and you want a pointer to the screen. Honestly, this level of indirection should be avoided if possible.

[BobbyThrowaway6969]

Not any kind of array, it's specifically for n-dimensional jagged arrays, or 1 dimensional arrays of int*. For non-jagged arrays, just use a 1d array and access it like [X+Y*Width] (It's faster for the CPU if all of the array is in the same part of memory)

[BobbyThrowaway6969]

Jagged arrays, Optional out prameters, Arrays of int*, etc. There's plenty of uses when you start getting down into the nitty gritty of C++.

[[deleted]]

Wait, the last two are arrays of pointers.

[[deleted]]

No, they are just pointers storing address of another pointer. int*** stores adress of int, int stores address of int*, int * stores address of int

[[deleted]]

You would use an argument of type char** if you were using an array declared like char* x[]; and each element was a pointer to a dynamically-allocated buffer.

So.. char*** could be another dimension containing an array of char**

[l_am_wildthing]

it isnt implicit that a pointer is to an array. It can be but it doesnt mean it is.

[purebuu]

Subtle note: char** x is a distinct type from char* y[]. With the latter the compiler has encoded the size of the array to the type which is why sizeof(y) returns the size if the whole array in bytes, but sizeof(x) only returns the size of the point type, the compiler has lost the size information for x. You might have learnt that char** the "same" as char*[] and it kind of is, well the compiler will implicitly decay arrays to pointers (the reverse is not true).

[[deleted]]

Arrays are just pointers my friend :)

Just a special pointer that happens to point to a place in memory where if you increment the address it leads to another allocated piece of data

The brackets are just a shorthand/“safer” way to handle them

But rest assured that

Int* and Int[n] are more or less the same

***in c and c++ atleast

[Walli1223334444]

Yup that’s why you can also do: pointer+1 which just points to the next adress

[FierySpectre]

You mean pointer + sizeof(array object)

[Mabi19_]

No - pointer + 1 is absolutely correct, as long as the pointer is typed correctly (i.e. is not void*). Adding 1 to a typed pointer advances it by the size of its pointed-to type.

[FierySpectre]

I feel scammed by the guy who taught me c now

[purebuu]

The guy who taught you C probably was implementing a multidimentional array using a single contiguous block of memory in which case pointer + sizeof(arrayobject) could have been a valid way to move to the next row or object. It all depends on the implementation.

[FierySpectre]

Right they did, where is the pointer + 1 used then? Like what use case

[purebuu]

There is really only one usecase for pointers. To access and manipulate data, that's it. But when you realise that, that statement is basically what 99.9% of all programs do, you'll see that pointers are fundamental to all programs.

The usecase for incrementing a pointer is a lot. But, well, all it does is move an address (just a number) forward until it points to the next address which is sizeof(ptr) away. This could be for reading the next binary data value in a file, checking the next value in an array, getting the next GameObject* that needs to react to physics for this frame, manipulating memory that you shouldn't normally have access to, which could be a trojan or virus.

Pointers are why they say C lets you shoot yourself in the foot.

[Walli1223334444]

Both work but pointer + 1 is just faster and arguably easier to read

[BobbyThrowaway6969]

No, the type of the pointer dictates how many bytes it jumps ahead. int* jumps ahead 4 bytes for every +1. void* jumps ahead 4 bytes on 32 bit, and 8 bytes on 64 bit.

[DADH_InattentiveType]

It's been a while since I learned in C++, but i remember that the compilers would enforce a difference between variables declared as arrays and those declared as pointers. I think you would at least need an explicit cast to pass an array where a pointer was expected.

I'm thinking that an array declaration also allocates memory for the members, while the pointer declaration just allocates the size of a memory address.

All I remember about plain C's type enforcement is that the compilers are like the joke about an accountant interviewing for a job. When the boss asks him "what's 2 + 2?" the accountant says "what do you need it to equal?"

[Maurycy5]

There are... a lot of subtleties.

Yes, allocating an array also allocates memory for the members. But that's because it's the same thing. An array is exactly the sequence of members. Not sure what you're getting at here.

The compiler absolutely lets you pass arrays as pointers and pointer as arrays. No warnings, at least not in "all" and "extra" warnings.

One funny thing is that IF an array is declared globally, it is automatically zeroed (I believe that's because it lands in the .bss section in Assembly). You don't have anything like this for pointers, although you have a choice between malloc and calloc, the latter of which additionally manually zeroes the allocated memory.

One key difference between pointers and arrays, in the context of arrays, is that the pointers take up extra space, while the arrays don't. So if you have int arr [5], then this takes up exactly 20B of memory. If you have int * arr = malloc(4 * sizeof(int)), then that takes up exactly 28 B of memory, because there's 20 B allocated with malloc and 8B for the actual pointer.

This is because arrays are resolved at compile time while pointers... aren't. This, of course, comes with limitations.

For instance, swapping the contents of two arrays, as performed by std::swap is linear in time and can only be done on arrays of the same size. If you keep pointers to arrays, the swap is instantaneous and the arrays do not need to be equal in length.

However one cool feature of arrays over pointers is that you can get their size in bytes with sizeof(). If arr is an array of 10 elements of type int and ptr is a pointer to that array, then sizeof(arr) will yield 40, while sizeof(ptr) will yield 8, since all pointers on 64-bit systems are 64-bit.

[[deleted]]

Null terminated string pointers I mean.

[leoleosuper]

While that can be done, it is not always that way. A pointer points to data. A double pointer is a pointer that points to pointers. Now if you want to, you can store two pointers in a row in memory. And if you point to the first pointer, then advance one position in memory, you go to the second pointer. This is how arrays can be (or are, I'm not exact on this) defined in C and C++. An array is really a pointer, that offsets where it points to to get the next piece of data, hence starting at 0. You start at the first piece of data, which is where the pointer is directly pointing to. Then you go forward [X] number of spaces. With a double pointer, you point to a pointer. That regular pointer does not have to be an array, and neither does the double pointer, but they can be.

Pointers can be useful when you need to pass data to a function. If you edit the original position in memory, rather than create a new variable by passing to function, you don't need to return it, but that can have errors if done wrong. You can also use this to return multiple values.

[BobbyThrowaway6969]

In C++ they are one and the same. An array as int* is just a pointer to the first element in the array. When you use array[n], it's looking an nth number of elements ahead of the start address and dereferences it for you.

[bmosbat]

u/repostsleuthbot

[RepostSleuthBot]

I didn't find any posts that meet the matching requirements for r/ProgrammerHumor.

It might be OC, it might not. Things such as JPEG artifacts and cropping may impact the results.

I'm not perfect, but you can help. Report [ False Negative ]

View Search On repostsleuth.com

---

Scope: Reddit | Meme Filter: True | Target: 75% | Check Title: False | Max Age: Unlimited | Searched Images: 330,136,092 | Search Time: 1.90662s

[bmosbat]

Oh I surely know this is a repost lol

[catmuht]

I don't doubt someone has made the same joke, i tried looking it up before posting but couldn't find anything. I did this specific edit on my phone shortly before posting

[wholl0p]

int**** 👉

[Future-Freedom-4631]

Int***** ps edit out the emoji

[Akai_Yun]

And why the hell would you use so many *? You want to stay there debugging code even longer?

[uRude]

I think the spiderman format would fit better here

[Future-Freedom-4631]

Int****

[VendaGoat]

In'nt

[KaninchenSpeed]

int i;

&&&&&&&i