Programming/C/Memory Model - Revision history

Brodriguez: Add more about pointers

2023-04-23T02:47:39Z

Add more about pointers

← Older revision		Revision as of 02:47, 23 April 2023
Line 71:		Line 71:

	In other words, pointers are references to specific locations in memory. Any value can have a pointer created for it, regardless of it the value is on the stack or heap.		In other words, pointers are references to specific locations in memory. Any value can have a pointer created for it, regardless of it the value is on the stack or heap.


			The actual size of a pointer depends on the OS. For example, in a 64-bit OS, the pointer is really just a 64-bit unsigned integer.


			When possible, it's better to pass pointers around, as it's faster to pass a pointer than, say a whole class object. Aka, pointers are often preferable to copying a value.


			=== Implicit Vs Explicit References ===

			Pointers are defined by using the {{ ic \|*}} character after the variable type. We can also get the memory location of a value by using the {{ ic \|&}} character before a variable.


			This is an '''implicit''' example. In this code, it will look like and be treated as if it were a standard variable.
			// Create int with value of "5".
			int my_int = 5;

			// Create pointer to above int.
			int& my_pointer = my_int;

			// We can then reference as if it were any standard variable.
			printf("%d", my_pointer);


			This is an '''explicit''' example. In this code, it will look like and be treated as a pointer.
			// Create int with value of "5".
			int my_int = 5;

			// Create pointer to above int.
			int* my_pointer = &my_int;

			// We must then use pointer syntax to actually get our value.
			printf("%d", *my_pointer);


			{{ warn \|If you ever have a variable on the heap (created via {{ ic \|new}}, {{ ic \|malloc()}}, or similar)}} that no longer has a pointer referencing it, then that is a memory leak}}.

Brodriguez: Update page

2023-04-23T01:53:40Z

Update page

← Older revision		Revision as of 01:53, 23 April 2023
Line 16:		Line 16:

	== Computer Memory ==		== Computer Memory ==

	A computer's memory is a series of locations called '''addresses'''. Each memory address:		A computer's memory is a series of locations called '''addresses'''. Each memory address:
	* Can contain a set amount of data, represented as a given amount of 1's and 0's.		* Can contain a set amount of data, represented as a given amount of 1's and 0's.
Line 22:		Line 23:
	{{ todo \| Document binary, at least basics. }}		{{ todo \| Document binary, at least basics. }}

	The 1's and 0's are called '''Binary'''. The computer automatically converts data to binary to store it in memory, and then back to the original format, so we as humans can understand it.~~<br>~~		The 1's and 0's are called '''Binary'''. The computer automatically converts data to binary to store it in memory, and then back to the original format, so we as humans can understand it. Similarly, the computer will automatically determine the unique identifiers that correspond to each address space.
	Similarly, the computer will automatically determine the unique identifiers that correspond to each address space.~~<br>~~
	So while it's potentially useful to understand these underlying concepts, we as programmers don't (usually) need to directly deal with these concepts.		So while it's potentially useful to understand these underlying concepts, we as programmers don't (usually) need to directly deal with these concepts.


	{{ Note: For very large pieces of data, we can chain together memory addresses to store more information. Thus, different addresses have varying sizes. }}		{{ Note \| For very large pieces of data, we can chain together memory addresses to store more information. Thus, different addresses have varying sizes. }}


Line 57:		Line 58:


	Note that, unlike the stack, everything in the heap is manually allocated by the programmer. Similarly, it everything in the heap should be manually unallocated when no longer used.		Note that, unlike the stack, everything in the heap is manually allocated by the programmer.

			Similarly, it everything in the heap should be manually unallocated when no longer used. Any instance when a program does NOT release allocated heap memory is a memory leak.


	As long as the OS has enough memory available, memory of any size can be allocated.		As long as the OS has enough memory available, memory of any size can be allocated.
Line 67:		Line 71:

	In other words, pointers are references to specific locations in memory. Any value can have a pointer created for it, regardless of it the value is on the stack or heap.		In other words, pointers are references to specific locations in memory. Any value can have a pointer created for it, regardless of it the value is on the stack or heap.


			== Misc Advice ==

			* Be careful when copying any non-trivial variables, such as classes.
			** Any class variables such as pointers will be copied as-is. This means when the copy is destroyed, the pointer is de-referenced for all classes.
			** This would then potentially cause errors for any other copies (or the original) when trying to access the pointer or deconstruct those as well.
			* With classes, it's generally best to define manually constructors and deconstructors. This can, for example, help avoid the above problem, as well as other potential problems.

Brodriguez: Expand page

2023-04-22T20:33:09Z

Expand page

@@ Line 27: / Line 27: @@
-Note: For very large pieces of data, we can chain together memory addresses to store more information. Thus, addresses defined by pointers have varying sizes.<br>
+{{ Note: For very large pieces of data, we can chain together memory addresses to store more information. Thus, different addresses have varying sizes. }}
-Normally, one assigns a standard integer value to each location and this is fine.
+== Stack Memory Vs Heap Memory ==
-HOWEVER, if one assigns a larger data type to "int pointer #1", then it will overflow into the address space of "int pointer #2", overriding any bits that might have already been there.<br>
-Furthermore, if this other data type is somehow excessively large, it might overflow enough that it continues on past the entirety of "int pointer #2", and overrides even more memory address space.

Brodriguez: Import memory sections for C++ page

2023-04-22T19:15:33Z

Import memory sections for C++ page

← Older revision		Revision as of 19:15, 22 April 2023
Line 1:		Line 1:
	~~TODO~~: ~~Populate page~~		Both [[ Programming/C \| C]] and [[ Programming/C++ \| C++]] force the programmer to manage pointers and memory.


			This is a manual process. This is also both a blessing and a curse.


			On one hand, the programmer can potentially manage references and variable/object deconstruction (aka, what many languages refer to as "garbage collection") much better than any language that has garbage collection built-in and handled automagically.<br>
			In other words, a given [[ Programming/C \| C]]/[[ Programming/C++ \| C++]] program can potentially be magnitudes more efficient.

			On the other hand, if not careful, or if they don't know what they're doing, a programmer can introduce many bugs and unintentional problems by incorrect manual garbage collection.<br>
			A set of memory can be allocated that's too small. So memory references overlap and garble data. Or data can be forgotten about, potentially hanging in memory and taking up space far far longer than it would have been around with automatic garbage collection.


			Pointers and memory management is one of the biggest differences between C/C++ and any other language.


			== Computer Memory ==
			A computer's memory is a series of locations called '''addresses'''. Each memory address:
			* Can contain a set amount of data, represented as a given amount of 1's and 0's.
			* Is represented with a unique identifier number.

			{{ todo \| Document binary, at least basics. }}

			The 1's and 0's are called '''Binary'''. The computer automatically converts data to binary to store it in memory, and then back to the original format, so we as humans can understand it.<br>
			Similarly, the computer will automatically determine the unique identifiers that correspond to each address space.<br>
			So while it's potentially useful to understand these underlying concepts, we as programmers don't (usually) need to directly deal with these concepts.


			Note: For very large pieces of data, we can chain together memory addresses to store more information. Thus, addresses defined by pointers have varying sizes.<br>
			This is how one can make addresses overlap.

			For example, let's say a programmer makes two sequential int address pointers. So we have {{ ic \|<nowiki>... \| open memory \| int pointer #1 \| int_pointer #2 \| open memory \|...</nowiki>}}.<br>

			Normally, one assigns a standard integer value to each location and this is fine.
			HOWEVER, if one assigns a larger data type to "int pointer #1", then it will overflow into the address space of "int pointer #2", overriding any bits that might have already been there.<br>
			Furthermore, if this other data type is somehow excessively large, it might overflow enough that it continues on past the entirety of "int pointer #2", and overrides even more memory address space.