Hello everyone! I've been doing some mix and match with my content style lately. Just trying new things. Let me know what you think :) To try everything Brilliant has to offer-free-for a full 30 days, visit brilliant.org/Mults You’ll also get 20% off an annual premium subscription.

If a codebase has any of this stuff, you'll know it's been backdoored.

Aight I'm never listening to the word "pointer" again

"say pointer again" "fuck you"

Honestly, An array of functions sounds pretty dope. Nevermind, an array of pointers to functions sounds pretty dope.

You realize how complicated pointer syntax is when the best explanation of how to read complex statements is in a funny YT video

I honestly never had any issues understanding basic and more advanced pointer stuff, but THIS is some actual good stuff LMAO great video

Who the hell would write the last one, without questioning their lives decisions.

"For example, if I use this struct 'Fucker'" caught me completely off guard XD My main takeaway from this video though is that as a C# dev for Unity, I shouldn't touch C++ with a 5 foot pole or else risk entering pointer hell.

im actually glad i found this video, you explained this well and now i know how to interpret those long lines

to whoever reached a point in life where you ended up here or doing this, i really hope you find inner peace one day...

C's syntax makes things excessively hard to parse, in other languages like C3 or more Pascal style languages (like Go and Odin) it's much more clear how these declarations compose

I think, most of the confusion comes from the syntax. For example, int (*(*x)[])() in Rust, would be Box> "Box" is Rust's pointer i32 is Rust's int

It all can get stupidly complicated as we've seen, but the syntax follows simple rules: 1. start reading from the identifier out 2. favor [ ] and ( ) over * For example, int (*(*x)[ ]) ( ): - Following rule #1, we start at x - The identifier x is alone in parentheses with \*, so it is 1* a pointer - Outside of the parentheses, we follow rule #2, so it is 2* an array - We're left with a * inside the parentheses, so 3* pointers - Outside of the parentheses, rule #2, 4* functions - The functions return 5* int putting 1*, 2*, 3*, 4* and 5* together: x is (1*) a pointer to (2*) an array of (3*) pointers to (4*) functions that return (5*) an integer Once you got the hang of it, you can rewrite the example like as: * [ ] * ( ) int And stitch things together in a way that makes sense (e.g. writing "a function that takes ..." before saying what is inside a parentheses, "and returns..." after a function and using plural after mentioning an array) Take the example of 5:34: [ ] * * (* char, * (* char) * int) [ ] * (* * char, * ( ) * char) * int It looks insane, but it's not that difficult to wrap your head around if you're writing it following those two simple rules

I finally understood. The type signatures are provided not the obvious way around, but outside in. For example: int x() is a function named "x", returning an integer. But instead of "x", I can put something different and it will mean, put the whole function inside whatever is in that position. For example "int (*x)()" means to put the function inside the *x. So It's a pointer to a function. But it's not just functions, it's **everything** if we analyze the "int (*x)()" again we get: int , which means to put the integer inside something that something: () It's a function! which means, that we put our int iside the return paramater of that function what's something: * it's a pointer! which means, we put our whole function with integer return type into a pointer. that something: x It's a name "x" which means, we put our whole pointer to a function with a return type of integer into the name "x" Let's do another example: char *(*(*(**x[])())[])(); it's a char, which is in a pointer, which is in the return type of a function, which is in a pointer which is in an array which is in a pointer, which is in the return type of a function, which is in a pointer, which is in a pointer, which is in an array, which is in "x"

this is what I understood from 3:10 - arr[0] -> func1 => int1 - arr [1] -> func2 => int2 x ->arr - arr[2] -> func3 => int3 - arr[3] -> func4 => int4 - arr[4] -> func5 => int5

bro lost me before the ad break 💀

Man, It felt awesome and confusing at the same time, but thanks to you I come to know the different use of pointers.

This actually made me understand pointer expressions. Thank you.

In older computers, especially Lisp machines, pointers always came with a size. A pointer was a 2-D object to the hardware. It had a location, and a size. The weirdness of C/C++ pointer types is an attempt to recapture some of the elegance of earlier hardware in a later era where the hardware forgot about data safety.

0:14 as soon as i read "france" i subscribed and liked the video

I FINALLY GOT POINTERS after more than 15 tutorials and another 15 "explanation" videos, you somehow made my brain click. Thank you so much!

That line of code in the thumbnail alone drove me insane and I haven't even watched the video yet.

Such an awesome teaching style!

Entertaining and very educational for me. Seeing different uses of pointers that you tried to demonstrate and describe them made my me intrigue, but at the same time dizzy. 😂

Understanding pointers, is like the Great Barrier between amateur devs and the pros! Because THIS is a concept in which knowing how computers actually works, helps tremendously!

The way i look at it is, the way you declare a pointer, is the way you access it. So if you got int *(*p[]), you'd access the innermost value (being the int) in the same way: *(*p[i]). And then you work your way backwards To make the point(er) clearer ill go through this. So you access the int by doing *(*p[]), so *p[] is an array of pointers to int, and *p points to an array of pointers to int, and p is a pointer to an array of pointers to int

I think this video actually made these easier to parse.

Ok how was this convoluted mess the thing that actually taught me how pointers work lol

6:00 Bro is holding the entire class inside his variable definition The God Variable.

A programmer goes to therapy. Therapist: Please tell me what you are scared of. Programmer: I am scared of pointers. Therapist: Okay, let me give you an array of pointers to handle them. Programmer: 😱😱😱

This video made me cry

The fact that C lets you write stuff like this makes me think that someone forgot to write it as an entry in the Geneva convention

Actually the best explanation of these bullshit functions I’ve seen, thanks!

what I get from this is that the song at the end rocks.

you shoud have mentioned operator precedence. and also thr syntax related to those concepts perfectly fit into english grammar. as a Türk, ı can say it in english (up to some point) but cannot think of its meaning because we build up the noun phrases other way around

My favorite programming channel

Absolute heater 🔥🔥🔥🔥

Why: If you're a postman in a small town and they ask you to "deliver this package to that weird yellow house", you'll figure out where to deliver what in a reasonable amount of time. But if you need to deliver a massive amount of packages, that are all stored in different places inside a big warehouse, to a couple of skyscrapers with multiple delivery points per floor, you'll have a much easier time if the exact address is provided.

On one hand, class/module structures and delegates are basically pointer stuff in pure C. In higher languages, these things 'look' much simpler, by simpler it means the context now spans several .cs files. :P On the other hand, your professor could give you a snippet of ASM code, and ask something like: provide an (or the most restrictive) equivalent C function signature of a CALL function in the code. Yes, you shall use "mov dh,word ptr [eax]" to figure out that eax is a pointer to the value dh now holds, and the only use case of the value being "test dh,dh" means eax can be a *byte, or *bool. :'D

I buried this nightmare 20 yrs ago. After watching I'm sure I'll get one tonight.

I seriously never could imagine insanity up to this level.

ohhh, i get it, thx :D. Finally understand pointer in my 3rd year in uni :)

"Go insane?" GO MENTIONED RAAAAAAAAAAAAAAAAAAAAAAAAA

I don't know how and I certainly don't know why, but I understood EVERYTHING this guy said, and now I somehow know how to use pointers, take this video to schools. This generation will know how the fuck pointer works, even if they don't know why they need to know that x is an array of pointers to pointers to functions that receive "a pointer to a character, and a pointer to a function that receives a pointer to a character and returns a pointer to an int" and returns a pointer to an array of pointers to functions that receive "a pointer to a pointer of characters, and a pointer to a function that returns a pointer to a character" as arguments and return a pointer to an integer

Your memory view and c debugger in vscode look very nice. Could you do a video on how you set this up or just gimme some info lol im jealous.

also all this pointer magic can be neatly swept under the rug if you use a lot of typedefs with proper names, makes the code much easier to understand for everyone

love the soundtrack

awesome. dude I need your fonr and vscode thee right now

"getting into programming is easy" the programming in question:

If I caught someone on my team writing things that way I'd fire them. A semi-quote from Ian Malcolm is most apt here, just because you can, doesn't mean you should. One of the rules I have for any project I work on is to typedef all function pointers because no one should have to parse that crap when reading the code. It obscures what the code is really doing.

Your first example should fail to compile (if you use -Werror), because control reaches the end of non-void function; the curly braces shoulsn’t be there. Also, although it is useful to be able to read the types like this, the real way to handle them is to use `typedef`s to name the intermediate types. 3:20 You’re mixing up your types. This is probably C pre-23 so it works but not well. You should say as part of the type that the pointers in the array that two `int` arguments.

Pro Tip: Just add another */& or put around parentheses until you get no compilation errors.

3:29 --> See line 15 (3:21) for further clarification. In short, line 25 is saying that you want to first dereference the pointer, followed by selecting the function at index 0 for that pointer; then you have to de-reference that index (the array itself decays to a pointer containing the addresses of each function) in order to call the function you want from that double pointer. i.e., createFunctionPointerArray() returns "& -> {&add, &subtract}". You're making an embedded function library, I guess you could say, that the variable references, and you have to dereference all those pointers to access the function you want. Easy to understand?

Hi, you have been found in my recommendation :O I'm watching it only 0:32 and already subscribed you. You have a funny sense of Humor btw xD.

I understood 80% after 15 min totally

"Great, you've explained these quite well. Now use them."

Those complex function declarations make me think of complex relational database.

I like your vids a lot!

I can't believe I actually was able to solve the last two after fumbling on all the previous ones (mainly because of parenthesis which changed if x was a pointer to an array or an array of pointers). I think I'm cursed now.

Is that the all-too-common array of arrays length 8 of pointers to functions returning pointer to array of pointers to char? (The order is name, sufix, prefix, and operators on a name before sufix brackets (i.e. function argumrents) infer that the function is what is being stored in that way, after that is what is being returned; this necessitates that the type before the sufix brackets be a pointer as anything else C wouldnt know how to store) (Also the question would not parse, let alone make sense, you declare an array of arrays of undefined length, thats not allowed, if it was itd be an array of arrays of pointer pointers to functions returning a pointer to arrays len 8 with pointers to int) Or, in simple terms, its probably a number. Tldr just use c++, rust, java, python, ets. C is for pointer tricks and programming elevators, not for actual use. Unless you're making an OS, then it may come of use. C walked so that higher level languages could run.

Here's a little tidbit for variable management, while GCC has it's cleanup attribute for a more generic solution that works without it (and a lot more flexibly too), here's my solution (copy pasting an entire header here): ```C #pragma once #include typedef unsigned long ulong; typedef unsigned int uint; typedef char const *str; typedef struct { size_t len; str txt; } strvec; #define bitsof(T) (sizeof(T) * CHAR_BIT) #define lengof(LIT) ((sizeof(LIT) / sizeof(LIT[0])) - 1) typedef struct expiry_link expire; typedef void (*expiryCB)( void *data ); struct expiry_link { void *data; expire *next, *prev; void (*expireCB)( void *ptr ); }; inline void expire_linked( expire *head ) { for ( expire *link = head->prev; link != head; link = link->prev ) link->expireCB( link->data ); } inline void expire_nothing( void *data ) { (void)data; } inline void insert_expirable( expire *head, expire *link ) { head->prev->next = link; link->prev = head->prev; head->prev = link; link->next = head; } inline void remove_expirable( expire *head, expire *link ) { link->prev->next = link->next; link->next->prev = link->prev; link->prev = NULL; link->next = NULL; } #define DECL_EXPIRY_HEAD() \ expire expiry_head = { NULL, &expiry_head, &expiry_head, expire_nothing } #define DECL_EXPIRABLE( NAME, FUNC ) \ expire expirable_##NAME = { (void*)&NAME, NULL, NULL, (expiryCB)FUNC } /* For libraries that have termination functions */ #define DECL_EXPIRYLIB( NAME, FUNC ) \ expire expirable_##NAME = { NULL, NULL, NULL, (expiryCB)FUNC } #define INSERT_EXPIRABLE(NAME) insert_expirable( &expiry_head, &expirable_##NAME ) #define REMOVE_EXPIRABLE(NAME) remove_expirable( &expiry_head, &expirable_##NAME ) #define EXPIRE_LINKED() expire_linked( &expiry_head ) #define EXTERN_EXPIRABLE_H_INLINES() \ extern inline void expire_linked( expire *head ); \ extern inline void expire_nothing( void *data ); \ extern inline void insert_expirable( expire *head, expire *link ); \ extern inline void remove_expirable( expire *head, expire *link ) ```

somehow this made me understand pointers better than 4 years in uni

Unirocanically very useful video. Mad respect at the dinosaurs who invented C lol

Interfaces are a fine abstraction from function pointer madness

I came into this, expecting to learn how to read that stuff. Sadly I don't think I learned anything (except maybe reading the decl from the inside outwards?). This video was entertaining though. Just to give you feedback

A simple hack to read c types is to start from parenthesis and then read from right to left. So if you see something like int (*x)[4] its: *x - x is a pointer -------------------------^ [4] - to an array with length 4 -----------^ int - to an int ---------------------------^ Another example: int (*x)(char (*t)[4]) we start with parenthesis so x is a pointer then to the right we see another parenthesis so x it is a pointer to a function then we parse the arguments so the function takes a pointer t to an array of length 4 of chars an the original function x points to returns an int

How did you not go insane sooner?!!?!?!???

You had me at "Fucker". Subscribed.

This is cool but I like doing practical stuff with pointers. Like serializing objects as if they were binary arrays or creating smart pointers which delete themselves when nobody references them.

I wish this was a joke of some kind, then I wouldn't want to cry

bro got every meme in his vault

Even the parser gave up, and he's still going

Please do a vid of how you got that view of memory!

How to open that memory view in vs

This video is amazing

9 am in the morning..have homeoffice and a Coffee.. why i hurt myself with this video.😂❤

i like your funny words magic man

Everytime I paused and I am shocked how i get it before you start telling how to understand it. Maybe because i have been doing reverse engineering and malware stuff for long time now. Those codes actually have hell of typecasting with different data types and sizes. But greater video !!! ❤

Hey man great video, but what is ypur extensions for memory looking and your theme

To create a program that parses a C expression and translate it into a sentence would be quite fun to do

3:00 Yeah, this is 100% the syntax's fault. This could be so much better. Even with TS, the language I currently work in, I could write it easier. And I _hate_ the syntax of typescript. I'm pretty sure it would just be this: x: Pointer[]> or with similar syntactic sugar, something like: x: **(() => int)[] instead of: int (*(*x)[])() The useless parentheses and the weird logical bubbling of the type definition is really fucking me up. Not even sure if I understand it right tbh

interviewer: Great, add it to our interview question list!

instruction unclear, rewrite in zig

The biggest problem with pointers is batshit insane C syntax.

Small clarification: you're never pointing to an array, you're always pointing to the location where your array starts.

At some POINT I've stopped perceive word "pointer" as some meaningful entity and instead started to interpret it as some weird IKEA furniture name

That last example... something like this? using CharPtr = char*; using FunctionReturningIntPtr = int*(*)(CharPtr); using FunctionPointer = int*(*)(CharPtr*, FunctionReturningIntPtr); using ArrayOfFunctionPointers = FunctionPointer*; using xType = ArrayOfFunctionPointers*;

explaining GO pointers till i GO insane

I am subscribing without further questions

First fix I would do to C is eliminate prototypes. Rather than writing a function prototype, just write the name of the [virtual] function the pointer references.

Here is my trick: When you see "int * x" Don't think "x is an int*" Think "when you dereference x you get an int" Example for 2:49: int (*x())[20] x is something that when you call it then you dereference the result of that and then you subscript (look at an index), you get an int

And this is just the declaration, imagine using those pointer

1:47 isnt that a bug? You should take &strings ?

What font do you use ? that font is so cool !

I knew that I found pointers confusing... I just didnt know quite how deep that went.

Bro what's your vs code theme it looks nice

and this shit is probably why we now have arrow syntax and first class functions instead

I'm having PTSD from university every time you say pointers more than 2 times in a row

I am glad that I use languages without pointers xD