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.

"say pointer again" "fuck you"

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

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

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

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

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

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

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

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 * int (*(*x)[ ]) ( ): - Following rule #1, we start at x x - The identifier x is alone in parentheses with an asterisk, so it is [§1] a pointer *x - Outside of the parentheses, we follow rule #2, so it is [§2] an array (*x)[ ] - We're left with an asterisk inside the parentheses, so [§3] pointers *(*x)[ ] - Outside of the parentheses, rule #2, [§4] functions (*(*x)[ ])( ) - 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: * [ ] * ( ) -> int And stitch things together in a way that makes sense. "->" means "returns" and it's optional/redundant (anything immediately after parentheses in this notation is a return anyway) Take the example of 5:34: [ ] * * (* char, * (* char) -> * int) -> [ ] * (* * char, * ( ) -> * char) -> * int Array of pointers to a pointer to a function that takes (a pointer to a character and a pointer to a function that takes (a pointer to a character) and returns a pointer to an integer) and returns an array of pointers to a function that takes (a pointer to a pointer to a character and a pointer to a function that returns a pointer to a character) and returns a pointer to an integer It looks insane, but it's not that difficult to wrap your head around if you're writing it following those two simple rules

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

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: 😱😱😱

3:24 funnily enough this is how dynamic dispatch works in c++, each class (implicitly) creates a pointer to a global array of function pointers. This is also known as a virtual table or vtable/vftable as it contains the list of "virtual" functions for that class.

Small tip for 1:20, you can order malloc like you did just by manually asking for each memory "sizeof(char) * 6..." but if you make a tipedef of your struct, you can just ask for a "sizeof(FUCKER)" and it will do the same, but far easier to read, and simpler

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

5:31 and at this point I soundly fell asleep and had a very restful night in dreamland, not worrying about pointers to pointers or functions calling pointers or anything returning an int again...

0:08 x is a pointer to an array of pointers to functions that returns an integer. Not that complicated to us Programmars : )

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

bro lost me before the ad break 💀

I've forgotten my name after learning about pointers from him. This person went insane before completing pointer😄

"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.

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. 😂

"Did you explain them?" "Yes" "What did it cost you?" "Everything"

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.

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

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

"Go insane?" GO MENTIONED RAAAAAAAAAAAAAAAAAAAAAAAAA

00:07 "So what is this?" "Obviously A NIGHTMARE."

Such an awesome teaching style!

I REFUSE to understand this syntax.

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 video made me cry

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

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

Thanks for the pointers!

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

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

I think this video actually made these easier to parse.

Bro I sat here with a notebook trying to understand, which I did pretty easily. Excellent explanation for such a troll video!

You know what's funny, I've been programming in C for 15 years and I was confused at he first one. But after you broke it down I understood it perfectly. I could even see situations where it would be quite useful to know. Great video, hope you're enjoying learning computer science. I still am

As hairy and convoluted as the examples got, you did a fantastic job of breaking them down. I’ve spent most of my time coding in python and Java, so have thankfully never had to use pointers in practice. I do, however, remember the outright confusion experienced during a college C++ class…

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.

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

Im watching this at 3:00am and yeah my brain is pretty much fried at this point

I think that this is 100% the reason for the existence of the typedef keyword

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

I gave this video a thumbs up even before watching it. Anyone who tries to explain pointers to us 'dumbdumbs' is definitely a modern-day Prometheus.

im new to the concept of pointers and memory allocation, since i just started learning c++ a few days ago. decided to spend an hour or so looking at this after learning the basics of pointers until i feel like i understood enough about how it all ties together, i guess i learned more about it but now i have a painful headache...

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

Omg I never understood pointers so well as I do right now thanks to this video

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

Came to learn about pointers, returned with all my braincells drained. 10/10

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

An array of function pointers sounds like something that could be extremely useful, but I can't imagine any situation where it would be useful

Im not even going to lie. This video did more for me than any amount of researching and googling. Believe it or not, i actually learned how to read pointer syntax from this cluster fuck of a video.

Absolute heater 🔥🔥🔥🔥

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

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.

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.

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

bro got every meme in his vault

I like your vids a lot!

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

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

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

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

this is the first time i seen a sponsor segment use k-on for backround music 😂

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

I seriously never could imagine insanity up to this level.

THANKS To YOU now my BRAIN is working *totally* properly

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?

Can anyone tell me what theme is he using?

love the soundtrack

I understood 80% after 15 min totally

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

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.

Pro tip: if you have to use raw function pointers in C++, use the new style of typedefs: using Func = void(int, int); Func* x; - much more readable IMO. In general, avoid declarations that sandwich the identifier in the middle like the plague.

I'm assuming the brackets that aren't used or don't have anything in them are just placeholders for new nested variables and code to be added in the future?... Either that or code that already exists with those brackets in mind and are connected to similar code.

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!

I'm getting a new computer soon and I'm absolutely going to make stupid and dangerous C programs with this knowledge now. Last time, I managed to make a program that randomly crashes x11

Ok i need revisit some pointer videos before understand this

You had me at "Fucker". Subscribed.

A pointer consists of: 7, 9, 9, 9, 9, 9, 12. I.e. 7 bits unused, 12 bits for the physical offset in memory and the 9's are offsets into a page "tree" if you will . Most CPU's today only use four-level pages, so the top 16 bits (instead of 7) are unused - but Intel is starting to use five-level pages too. It's also why pages are 2^12 (4096) in size, and why large pages can be 2MB (2^(12+9)) and 1GB (2^(12+9+9)) respectively. You can cast a pointer to a number, and shift the bits into different values to clearly see how there's a clear pattern when you allocate memory etc.

This makes me thankful for the C# syntax

The biggest problem with pointers is batshit insane C syntax.

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 I just wondering how you have memory debugger in vscode? Reading those memory bars would greatly help me on pointers! Thanks

Allright, we get it. This guy pointers.

Bro what's your vs code theme it looks nice

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

Idk what the fuck happened to me but i was laughing like a fucking psycho everytime i hear the fucking word POINTER.

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

this actually makes sense

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

Going over the needlessly idiotically complex examples legitimately helped me understand pointers more lol

Ngl i actually understand now thanks 🥰😂

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

i like your funny words magic man