POINTERS ARE JUST MEMORY ADDRESSES
SAY YOU WANT TO POINT TO A MEMORY LOCATION:
VOID* PTR = 0XA800;
POINTS TO THE DATA LOCATED IN MEMORY ADDRESS 0XA800. YOU CAN ACCESS THAT DATA LIKE SO:
INT VALUE = (INT*) *PTR;
YOU EXTRACT VALUE FROM MEMORY ADDRESS BY DOING "*PTR". IT BEING TYPE *VOID MEANS THE DATA YOU EXTRACT FROM THAT MEMORY LOCATION IS A WILDCARD. YOU WILL NEED TO TELL THE TYPE OF THE DATA YOU ARE EXTRACTING. THIS IS WHERE THE (INT*) TYPECASTING COMES IN - YOU TELL IT YOU WANT TO EXTRACT AN INT FROM THAT MEMORY LOCATION. WELL THEN THE REST IS SIMPLE, THAT DATA GETS STORED IN THE "VALUE" VARIABLE.
OF COURSE IF YOU TRY TO RUN THAT CODE IT WILL CRASH BECAUSE WINDOWS OR WHATEVER OS YOU USE GETS
REALLY MAD WHEN YOU TRY TO ACCESS MEMORY LOCATIONS IT DOESNT APPROVE YOU OF ACCESSING. THE MEMORY LOCATIONS IT DOES APPROVE OF YOU ACCESSING ARE THE ONES WHERE VARIABLES YOU DECLARE ARE STORED IN.
SO SAY YOU HAVE
INT VALUE = 2;
THEN YOU CAN GET THE MEMORY LOCATION WHERE THAT 2 IS STORED IN BY DOING
INT MEM = &VALUE;
"&VALUE" IS HOW YOU EXTRACT A MEMORY ADDRESS FROM A VALUE. NOTICE THE PATTERN? *X IS EXTRACTING VALUE FROM MEMORY ADDRESS, AND &X IS EXTRACTING MEMORY ADDRESS FROM VALUE. AND YES, DOING *&X IS BASICALLY LIKE DOING X + 2 - 2, IT CANCELS OUT.
KNOWING ALL THIS YOU CAN DO SOME PRETTY NEAT STUFF LIKE:
INT X = 5
INT* Y = &X
*Y = 7;
AND GUESS WHAT? X IS NOW 7! THAT'S BECAUSE WE MADE Y POINT TO THE MEMORY LOCATION WHERE X IS, AND THEN WE CHANGED THE VALUE OF THE DATA IN THAT MEMORY LOCATION TO A 7 THROUGH Y.
SO WHY USE POINTERS? BECAUSE WHEN YOU ASSIGN THINGS, YOU ARE COPYING DATA. IMAGINE PASSING IMAGE DATA TO A FUNCTION THAT IS SEVERAL MB IS SIZE. IT WILL LAG THE SHIT OUT OF YOUR COMPUTER BECAUSE YOU ARE GOING TO BE COPYING THAT DATA. INSTEAD, YOU PASS ITS MEMORY LOCATION AND ONLY END UP COPYING THE MEMORY LOCATION VALUE. THAT FUNCTION CAN THEN ACCESS BITS AND PIECES OF THAT IMAGE DATA USING THE MEMORY LOCATION IT IS STORED IN.