That caught my attention as well 😄😅😅

He is codeChef.

He went to the park in thet other tutorial

😂😂😂

Let him cook

I agree, they talk about houses with addresses - yeah easy. But what we want is practical examples of real code using pointers and leave out the simple examples because they really are too easy.

Cause poiters make your code faster

is he using visual studio?

@@Soccercrazyigboman yes

@@BR-hi6yt Imagine having to move an entire house from one address to another... vs just telling some process/function to refer to a different house (address) instead. What do you think is going to be easier for the computer to do?

In what language was the yelling? I wish I could hear it. It must be so fun.

@@jeffz7310 He was probably yelling in C or C++ if I had to take a guess.

@@chasewatts4822 Like this ? std::cout

They teach you pointers at school? they were teaching us how to open mspaint from the start menu

A shortcut is a launcher, like executing another pseudo executable to launch an executable (with params allowed).

Get ouuuttt! Get ouuuutttt!

was that a pun?

Oh take my like and go f yourself

@@itay1232 😂😂

are you that ship that Gil Amelio was responsible of pointing?

And thats how arr[i] work for successive values of i.

Lol never even thought about that for some reason 💀

Of course it's incremented by the size of the type. After all that's what the types are for, to determine how many bytes are occupied by an object and that's one of the reasons why statically typed languages are faster :)

who knows a guy, who knows a guy :)

I have seen you somewhere

@@chiragsingla. :)

Prob another programming video and thanks for all these timestamps very helpful

@@chiragsingla. You are welcome!

I know this comment thread is kinda old but if anyone saw this please elaborate myself a little bit. After I finished the clip, I went on to try using a pointer that points to the address of a variable of string data type. But when I declare my pointer data type as integer, the compiler gave out warning that it cannot convert from string to int. I then change the pointer data type to string then it works. So I reckon either Cherno talking about int data type just in this context, but generally pointer data type should be the same with it's address variable's data type

Your professor ? How long has he been programming for in C++ ? :O

@@Gaelrenaultdu06 Yeah... that doesn't add up. Probably meant "instructor". Students often use the term professor when they mean instructor at a college. Really, a "professor" would have at least a doctorate, and a doctor of computer science would not have been introduced to C++ within the last 4 years.

@@bradleyfallon6847 Who knows... there are hundreds of programming languages, and someone with a doctorate isn't necessarily going to focus on learning a big part of them.

implement double pow(double val, double degree)

No i don't no if i should stay or shold i go

Is only complicated when those teaching don't know shit about them.

@@txorimorea3869 unlike cherno lol

Bullshit. You should get your overthinking head out from here. I’m sure you never did anything significant in c++ if that’s the thing you say to anyone struggling with pointers. Fuckn go away.

@@korigamik Why are you so hostile? gtfo

@@korigamik who asked

Smart

Wood is not the variable, is the data.

Appropriate profile picture there... xD

But are you invincible or in fact vincible?

???

@@_Omni I make a meal for my friends, try to make it delicious, try to keep it nutritious, make wonderful dishes. Nobody thinks about the way i feel, none of them compliment the meal!

cherno spittin' that inferno while gettin' on with you're learno

But... Pointers are realy easy to understand when you are in kitchen!

Next video: TEMPLATES in C++ (recorded in the restroom)

🤣🤣🤣🤣🤣

next video: structs in C++(recorded while skydiving into the pacific ocean)

Segmentation faults incoming

Don't be dumb

@@michielarkema ++++++++++[>+++++++>++++++++++>+++>+.

what an underrated comment

I think it's because when you cast to double, it doesn't stop to the first 4 bytes (08 00 00 00) as the int, but it forces to take 8 because the double data type is 8B long, so the same 4B as before plus some junk that was already there (es: 08 00 00 00 c6 8a 6f 37), which results in a seemingly completely unrelated decimal number when printed

int a=4; int *b=0; b=&a; int **c=0; c=&b; printf("%d",**c); //this will print 4

Both pointers are pointing at each other

So a point is a memory address but when you make a pointer it has to store somewhere else in memory what memory address you are storing so a pointer to that pointer is the memory address thats storing the original pointer Why is this useful? Let's say you are making a linked list in C++ you have a series of structs to be list nodes now every time you create a struct its put somewhere random in memory so to organizer your node you make an array of pointers to where each node struct is. Well one way to do arrays in C/C++ is just make a pointer to the first value in the array. but since its an array of point of where each list node is you have a pointer that points to a pointer.

EXAMPLE WRITTEN IN C struct Node { int value; Node* prev; Node* next; } Node** initialize_linked_list(int size) { Node** list = (Node**) malloc(size * sizeof(Node*)); for (int i = 0; i < size; i++) { list[i] = (Node*) malloc(sizeof(Node)); memset(list[i], 0, sizeof(Node)); if (i = 0) continue; list[i]->prev = list[i-1] list[i-1]->next = list[i] } return list; } void free_linked_list(Node** list, int size) { for(i = 0; i < size; i++) free(list[i]); free(list); } int main() { int size = 3 Node** list = initialize_linked_list(size); free_linked_list(list, size); return 0; }

I know the example program does nothing but you can see the struct Node for each node in the linked list is referred to via pointers, and when I made a pointer array it was a pointer that pointed to a pointer

References are just your variable name aliased as something else - "under the hood" they are the same, it's an easier way to use pointers without having to explicitly deference them to access the data.

A pointer is a box that hold memory, a reference is a new name for the same box of memory. Let's say you have a toy box with a sticker on it with the name "toy box", you've put that box somewhere in the house for long term use. then near you you have a box, in that box is the name of the room you have put your toy box. that is a pointer a new box pointing you to the old box whereabout. now assume you have the same toybox, but with two stickers on it the first say "toybox" the second says "oldtoys". that's a reference. it's a second name for the same box.

So a reference is like the "TYPE" of a regular Object?

A reference is just the safe version of a pointer. A pointer can hold any address and can change this address anytime. References hold only one address (the one for the original.source) and will never chamge it. The priginalC pointer had basically two jobs: 1)create data structures holding complex and big data (one can "connect" and "dosconnect" big chunks of data without needing copies) and 2) pass just the addres of a data as an argument for a function. The second use can be almost exclusivelly be done better with references, since there is no interest in changing the original address, just access the variablr inside the function. Refrrences can also frequently be used on the first use, but there is still places where you need pointers. The idea behind the creation of references is to use it everywhere it is possible and keep pointers (da gerous objects) only where they are strictly necessary.

@@mortvald so reference is like a new name for that memory or the data but different from the previous name that memory had

I would only imagine a Vulkan series coming way later down the line to never. To use Vulkan effectively you need to be an expert (if you want to build good applications with it); fluent in C++ and certain programming paradigms. Getting a 2D triangle in Vulkan with one tutorial I did took nearly 1000 lines of code. Its nowhere near as simple as OpenGL.

and then you say "smart pointers???" Alright, now I'm terrified, probably gonna bust a blood vessel trying to get my head around this, credit where credit is due though, you've made it make more sense than any other UKpostsr I've seen cover it, still doesn't make all that much sense though

HOLY SHITBALLS CHERNO, I GET IT, NOT GAY BUT I FUCKING LOVE YOU MAN

lol

The problem with pointers is the syntax, not the concepts. See the concept of a pointer is baby level easy. It's the damn syntax. An asterisk means different damn things. In declarations you put in the address, but you wouldnt do that after. Thats hard and counterintuitive as programmers who consider grammar. This inconsistency is mind bending but something to have to get used to

@@catharsis222 "is mind bending but something to have to get used to" most people, when asked how is to learn c++.

For each new, there must be a delete. this is the universal rule in c++. *Unless you bother with smart pointers

You need to use delete to dealocate your memory so that it can be used later again or else you will have a dangeling pointer that uses your memory for nothing. Thats why you always need to call delete or delete[ ] .

I know why, I just didn't know in what situations it would be done automatically.

TomHazRedstone if you create something on the heap (with a 'new' keyword for example) then you want to delete it. If you create it on the stack though (eg. Local variable inside a function or method) then you don't need to worry about it, as it will be discarded from the stack automatically when that block or section of code finishes running.

That makes sense, thank you.

vtastek exactly the point where I'm struggling. Why don't just use variables? What are pointers actually good for? It's not the how, it's the why for me :S

+vtastek Pointers are very useful to manipulate memory directly when simple variables might be very limiting... It's hard to explain so let me give you an exemple. In OpenGL there are these things called shaders that are basically programs that are executed by the GPU. You have the option to compile these shaders inside your graphics application. The argument that OpenGL takes (glShaderSource) is the reference of the pointer that points to the first character of the sequence of characters that represent your entire shader program, that is usually written into a file. That's a very smart way to deal with this task of compiling shaders inside a graphics application IMO. Another exemple, when you're dealing with files like images, sounds etc... They are all basically datas stored in the memory, in other words, sequence of bytes that can be manipulated freely. You will want to store the memory address of these sequence of bytes that represent your file to *address* the file right. As Cherno said memory, data manipulation(store, retrieve, access stuff in memory) is probably most of what we do when we're programming, as you said simple variables are just an abstraction to memory, pointers is just another more faithful of what memory really is. That's why we say C++ is a very powerful language, Java for exemple doesn't even give you this tool for safety reasons. About the second part of your question: yes, is the operating system the handles the whole memory system, how it actually does it, is a very complicated task and there is this book: Modern Operating Systems from Andrew Tanenbaum that you can read if you wanna go in depth about it, but for graphics programmers you don't have to worry how the OS handles it. That's kinda one of the functions of the OS TBO: abstract the computer system for programmers to worry about just with the application they are developing.

BlackPhillip2018 glshadersource taking a pointer instead of the shader file directly is a smart way because? I would guess so we can manipulate the shader source files, change keywords, create templates, combine files ourselves and stuff like that...

The reason as I understand it at least (as it relates to functions), is because whenever you pass a variable into a function normally, C++ actually copies that variable before using it. Normally that wouldn't be an issue, but if your dealing with memory sensitive applications, there's no reason to have two copies of everything you're passing into functions (again depending on the situation). The very act of copying also takes up CPU cycles, so that can be important when you're dealing with variables holding a lot of data and/or applications that need to be as fast as possible. Also, if you want to modify a variable in place, passing the pointer to that variable would allow the function to do that as well.

Jonah Loctar hmm... Can we say that this copying is the default behaviour for most other programming languages? Because it feels like pointers then should be default/right way of doing it. variables must be a fallback. I write shaders and use functions but never used stars or saw them anywhere for that matter, hopefully that's not critical for shaders. ^_^

I could*

@@doxo9597 is there a difference?

@@mastershooter64 Could is past tense of can. He no longer remembers, so he should say could.

@@jangtheconqueror ah I see, got it

Don't worry, this dude is the most self absorbed crock head I've ever seen. This, and all other videos, aren't about C++, they're about Cherno. This guy has zero clue and zero industrial, real world, working knowledge of C++. This guy is equivalent to RealTutGML and TheRealBoston. But hey, this isn't just my view, check programming on Reddit and you'll see many Redditors advise against this guy.

Types are a matter of housekeeping on the level of the compiler, but on the level of machine code, the CPU dosn't care.

@@kaizen9451 I disagree. First of all doesn't he work for EA? This video is good, he is just focussing on certain aspects and clearing certain things up. Of course types matter when you actually use the data, but he said that.

also in arabic but we spell it bayte hhh.

bae loves to byte

Jeff Tang Is he a german?, because i speak German as well and could hear that german accent

They have their screen upside down