Explaining Pointers Until I Go Insane
Vložit
- čas přidán 19. 04. 2024
- 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.
Hello there! I've been wanting to talk about quirky pointers for a while. They make no sense sometimes.
Music used in the video:
- Sewer surfing: • TMNT 4 (SNES) Music: S...
- Flower garden: • Yoshi's Island OST - F...
- Vordt of the Boreal Valley: • Vordt of the Boreal Va...
- Pizza Parlor: • Club Penguin - Pizza P...
- Figure-8 Circuit: • Mario Kart DS Music - ...
- Mii Channel Theme: • Nintendo Wii - Mii Cha...
- The Cyber Sleuth: • The Cyber Sleuth - Dig...
- Bad Bully: • Kizumonogatari II ost ...
- Wii Sports - Title: • Wii Sports - Title (HQ)
- Spark Mandrill: • Mega Man X OST - Spark...
- Hope Ster: • Hope Ster - Digimon St...
- Flame Mammoth: • Megaman X - Flame Mamm...
- Alleycat Blues: • TMNT 4 (SNES) Music: A...
- Listen!!: • K-ON! - Listen!! Instr...
- Going Up: • TMNT 4 (SNES) Music: G...
- Still, Move Forward: • Still, Move Forward! (...
- Royal Knights: • Royal Knights - Digimo...
- A Dish is Best Served Cold: • Tee Lopes - A Dish Bes...
- ミカヅキBIGWAVE -Emotional Prism 感情的なプリズム: • ミカヅキBIGWAVE - Emotiona...
This video was sponsored by Brilliant.
#Mults - Zábava
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.
Not a regular viewer (yet), but -
This right here is literally a master piece for me. Educational, something interesting, memes (not to in you'r face / loud audio - still prominent to be entertaining), relatability, the ever growing crazieness, straight to the point, not to short nor to long, right volume for music and mic, the outro song - all just perfect. Keep it up!
I recognize that digimon cybersleuth ost
If a codebase has any of this stuff, you'll know it's been backdoored.
lol exactly. this is extreme obfuscation
@@atomgutan8064Some Jia Tan shit
@@tuhkiscgibin6627 lmao this is the new backdoor reference now ig
Once committed, always committed. No explanation is needed. It works.
Well, the person who backdoored it understood it, so jokes on you :P
Aight I'm never listening to the word "pointer" again
"pointer"
You can read it instead. You're welcome
I point on her... Wait
learn about references!
Let me give you a few pointers about how to get over this issue
I'd like your comment, but it's at 911 and I can't ruin that
"say pointer again"
"fuck you"
is that rick and morty
@@user-qr4jf4tv2x yes
damn how did i read it in rick and morty voice in my head 😆
@@user-qr4jf4tv2x indeed it is
Did you just... insult me with a **pointer**? Son of a..
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
12 years old me learning C++ : "Ok so, its a box containing... a box, ok?, containing a box... fuck it"
Honestly,
An array of functions sounds pretty dope.
Nevermind, an array of pointers to functions sounds pretty dope.
ain't that the same? or are we saying "an array of pointers to function pointers" (effectively double-indirection) in the second one?
Well, you can't have arrays of functions in the first place
Only pointers to functions
In C, you actually cannot store functions inside arrays anyway, the compiler will silently convert that code into a pointer to that function instead.
Is not every C++ member function referenced through an array of pointers to functions?
@@jrstf Per default, member functions are just statically compiled into the calling code. But it is true for virtual functions. They are referenced in the vtable, which exists for each type with virtual functions. Each of these objects then has an internal pointer to its respective vtable, which contains the pointers to the implementation defined procedures. This is how dynamic polymorphism is implemented.
Who the hell would write the last one, without questioning their lives decisions.
…people making youtube videos?
who the fuck would use *
@@Elias01056 i am
@@danilbutygin238 why?
@@Elias01056 long-term habit
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
bro i was with you util i expanded ur explanation... after expanding it i sad( i aint reading all this sheet lol) , but hey, great that u can explain this
@@nexushare8105 maybe there's a way to be more concise but then that's me who can't bother xD
My man, using asterisks here for anything but pointers is fucking evil, was there really no other way?
@@lightlezs7048 hahahaha good point, I'm gonna change that
@@lightlezs7048 better?
im actually glad i found this video, you explained this well and now i know how to interpret those long lines
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
Odin makes me realize that C's syntax is absolute mess. Odin's syntax makes writing function pointer really easy to understand 👍
It's a feature to sure you realize you're doing something bad : p
I think the trick to parsing C declarations is to go from the inside (the name) out. Although you still have to know parser priority. Like the animation at 2:40, except it messes up the priority by looking at "int" before [20]
The 4:40 example shows the inside out parsing even better. The 5:35 example seems more complicated because of the function signatures but those aren't as important to parse IME. You basically just copy that from the function in question. If you need to understand it better you just look at that function itself.
@@Jutastre yeah, the parsing itself is pretty straightforward once you know how things associate and the relevant operator precedence.
You start from the name and apply stuff to it from there - the result of doing this will generate something of the type on the left (the "return type" of the expression).
Making sense of complicated definitions without naming the steps in the way is just hard by nature - C lets you expose yourself to that, but doesn't make you: you can always typedef things into reasonable steps if you'd like.
to whoever reached a point in life where you ended up here or doing this, i really hope you find inner peace one day...
A Pointer in life
bro lost me before the ad break 💀
Bro really said bro 💀
@@kingpen5866 bro really said bro cause i said bro 💀
Bro realy saic bro to some bro who realy said bro to bro 's comment 💀@@GL0RYS
bro is a pointer to a bro that points to a bro
@@VictorMartinez-vi7jx bros making sense 🙏
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
If I understood it correctly, that's a pointer to a vector of pointers to functions that return an int, right?
yes, it's just a lot of angle brackets, in a way that actually makes sense
C works the other way around
Your outermost Box is unnecessary indirection as the Vec already places the memory on the heap.
@@shanesnover4048 that's true, but not relevant
Imagine programming in a language where you can actually specify the type of a value (i32) rather than some kind of a suggestion which varies in meaning in every implementation and even with platform specific switches on the command line.
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
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
"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.
no one actually uses crazy pointer stuff like this. Actually useful pointer stuff is simple and often feels quite elegant.
random swearing is peak reddit humour
@@vibaj16 tbf, I was being slightly hyperbolic. I do want to get round to learning C++ eventually but the combination of pointers, header files, garbage collection, and syntax is just a lot.
@@vibaj16 It's really simple.... The library will only use (void* buf, size_t n) for ALL types. C believes that smart users know that the void* returned by the function is a specific type among the 100+ custom types, it will be a linklist + table with a specific internal mix of pointers to stack and pointers to allocated heap, and then you have to be careful about pointer casts, linklist iteration, use void* to calculate offsets, of course you will remember which one is CHAR8* string and which is CHAR16* string, finally free the heap allocation and perfectly avoid the pointer to the stack.
The biggest advantage of C is that it is suitable for keeping your job.
It's really simple.... The library will only use (void* buf, size_t n) for ALL custom types. It is linklist + table with a specific internal mix of pointers to stack and pointers to allocated heap, CHAR8* string and which is CHAR16* string.
6:00 Bro is holding the entire class inside his variable definition
The God Variable.
A class that someone parameterised the hell out of, it's like "okay, let x point to containers upon containers of functions (class) that parse strings... but in a waythat is so parametrised and specific that you need to parse other string in your chosen function and based on result of parsing you get the answer of your call of x...
...the anser being a f***ing array ofpointers to functions! So basically the class that is x is not all - you now use this class to hold the answers of called(/callable) functions and use THEM as your ACTUAL functions that themselves take an array of strings and parse those strings collection based on (presumably, because it doesn't make much sense otherwise) the original character that is returned from chosen constexpr function (due to no parameters)...
...and all that returns an adress of where the value of it is stored, YOU KNOW, LIKE IT'S TOTALLY NORMAL.
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"
Nah
I mean if you understand it then great, but nah
Its name first, then sufix left-to-right, then prefix right-to-left, with () being the sufix function arguments operator. I best understand it same as the compiler, start from the inside and go out, sufix prefix exit-braket. Its doesnt matter here, yes, but this also reminds you how other operators work like array access and dereference operators. *x[8] means "take the 8th member of x and dereference", where as (*x)[8] means "dereference x and take the 8th member of that"
my honest reaction to this is: what the f$@% is that ?!?
Man, It felt awesome and confusing at the same time, but thanks to you I come to know the different use of pointers.
That line of code in the thumbnail alone drove me insane and I haven't even watched the video yet.
"Go insane?" GO MENTIONED RAAAAAAAAAAAAAAAAAAAAAAAAA
WE GOIN OUT OF THE HOOD WITH THIS ONE 🗣️🗣️🗣️🗣️🗣️
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.
This video made me cry
0:14 as soon as i read "france" i subscribed and liked the video
I love France
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: 😱😱😱
Ok how was this convoluted mess the thing that actually taught me how pointers work lol
I think this video actually made these easier to parse.
I wish this was a joke of some kind, then I wouldn't want to cry
what I get from this is that the song at the end rocks.
What i learned from this video is that function pointers are pretty cool! :)
Actually the best explanation of these bullshit functions I’ve seen, thanks!
I FINALLY GOT POINTERS after more than 15 tutorials and another 15 "explanation" videos, you somehow made my brain click. Thank you so much!
Such an awesome teaching style!
Omg I never understood pointers so well as I do right now thanks to this video
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. 😂
Came to learn about pointers, returned with all my braincells drained. 10/10
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!
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.
I buried this nightmare 20 yrs ago. After watching I'm sure I'll get one tonight.
"getting into programming is easy"
the programming in question:
My favorite programming channel
I understood 80% after 15 min totally
1. Love the suffering
2. Love the use of digimon story cyber sleuth ost, its suitable considering the BS that is the digivolution tree.
3. Great video
This makes me thankful for the C# syntax
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.
same
me too
Unirocanically very useful video.
Mad respect at the dinosaurs who invented C lol
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 :)
You had me at "Fucker". Subscribed.
Absolute heater 🔥🔥🔥🔥
Those complex function declarations make me think of complex relational database.
I have been working professionally with C for well over a decade. I know most of the ways it can bite. If I see any of these in production, I'm burning the codebase and walking away, and so should you.
How did you not go insane sooner?!!?!?!???
I REFUSE to understand this syntax.
I think that this is 100% the reason for the existence of the typedef keyword
"Great, you've explained these quite well. Now use them."
love the soundtrack
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
Small clarification: you're never pointing to an array, you're always pointing to the location where your array starts.
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
Now I'm seeing stars everywhere.
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
Interfaces are a fine abstraction from function pointer madness
Pro Tip: Just add another */& or put around parentheses until you get no compilation errors.
awesome. dude I need your fonr and vscode thee right now
As a veteran coder i can say that professionals store this kind of useless data because it becomes useful in a absolutely stupid situation. Just store this shit.
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.
There's probably already been someone saying this, but at 1:09, the allocation for the FUCKER variable was technically not correct, since alignment could see the struct end up larger than the raw data it contains. For instance, if we used an int after the char[6], most compilers would add a 2-byte padding before it to ensure that the address of the int is divisible by 4 (size of a 32 bit int which I assume is what int is)
In general, the safest option is to always use malloc(sizeof()); it'll give you the correct size the compiler will assign your structs
Idk what the fuck happened to me but i was laughing like a fucking psycho everytime i hear the fucking word POINTER.
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
anddd.... u just had to make this pun
I like your vids a lot!
This actually made me understand pointer expressions. Thank you.
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.
i like your funny words magic man
1:10 I'm pretty sure you can also use sizeof() directly instead of calculating manually
Ok i need revisit some pointer videos before understand this
somehow this made me understand pointers better than 4 years in uni
Ngl i actually understand now thanks 🥰😂
I am subscribing without further questions
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?
This video is amazing
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.
If I ever see a pointer to a pointer to a pointer or anything more nested than that, I'm deleting system32, quitting CS, and starting my career as a professional mind reader. Because taking a wild guess at whatever is going on inside someone's head would still be easier then desciphering some of this shit.
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
Ive personally written terrible code like this and iirc it looked like this:
#define FUNCORDER (int (* [])(struct data *)){func1, func2, func3}
It is a staticly defined, "anonymous" array of function pointers that accept a pointer to a struct I made & return ints. All of this to save 1 switch statement
explaining GO pointers till i GO insane
The biggest problem with pointers is batshit insane C syntax.
Even the parser gave up, and he's still going
interviewer: Great, add it to our interview question list!
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
bro got every meme in his vault
Please do a vid of how you got that view of memory!
To create a program that parses a C expression and translate it into a sentence would be quite fun to do
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 !!! ❤
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.
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.
“Explaining pointers until I go insane” yeah 6 minutes took u way longer than I expected
And this is just the declaration, imagine using those pointer
yo! nice video! could i ask what mic do u use?