arrays are weird 

i am no bueno at words nor maffs

As a mathematician it also hurt quite a lot when he said "transitivity" 😂

But it doesn't work for 1[a], right?

Mfw the binary operation is a group

@@luwi8125 It does

Yeah. It makes a lot of sense. I can't imagine anyone accepting it without first coming to this conclusion.

You do realise you can use things like a[-1]? What does it mean to have -1 elements before the one you're accessing?

I thought of it as 00000000 being the first positive integer in binary, and thought the reason indexes start at zero was to be able to make arrays one element bigger, since element 11111111 would be element 2^8 and not (2^8) - 1.

@@cigmorfil4101not in c, or not without unexpected results

@@cigmorfil4101 only in languages like python which apply special rules to negative indexes. Most languages have no such feature as it adds arguably unnecessary levels of code complexity

was going to comment this. understanding that c arrays decay to pointers was difficult for me to understand as a noob and really makes me appreciate c++ std::array

People always love saying "c is such a simple language". Well it is if you ignore all the more technical parts like value categories, value transformations (including array decay) etc.

@@sinom what do you mean by value categories and value transformations? although I do agree that C arrays can be a little hard to work with

@@sinom value categories are c++

One way of looking at this is that a pointer is a variable that _contains_ an address, but an array-variable _is_ the address. The difference is subtle, but can be important. For example, suppose you have an array `char str[] = "string";` in one file that you're trying to access it in another via `extern char *str;`. This should work, because arrays and pointers are the same, right? But if you do, say, `printf("%s", str);`, it'll try to interpret the string itself as an address and you get nonsense if not a crash.

If those assembly programmers could read they'd be very upset

The difference is the implication of "const" when defining an array over a pointer. Nothing more.

In fact, the %p is just a format specified. It doesn’t care what’s passed as a parameter; it will simply try to print it as a pointer. If you try to pass an integer variable instead it will just print the value of the integer in hex with 0x before it.

@@BlueSheep95 there are some other strange differences. Multi dimensional arrays are quite different than pointers. We had quiz questions in class about these differences and my takeaway was nobody should write such code that could distinguish between arrays and pointers anyway

The point is not so much the data type, as more what's behind it, the reason is technical. Most important aspect is that we are talking about a fixed size array, from which the size is decided at compile time. In the case of a local variable this adds up to stack allocation size. So rules for what you can and cannot do with that fixed buffer is something which has to be enforced. It cannot be changed and the variable is directly bound to it, therefore it cannot be changed either.. And actually the difference between this array itself vs a pointer to it has been made even clearer in more modern programming languages, like Rust. In Rust you can get a slice from an array and use that everywhere in your code. This slice is also technically described as a "thick pointer", because it internally contains both the memory address as well as the length of the actual array. But the idea is not so much different. By understanding that this difference also actually exists in C even if it doesn't look like it does, it becomes harder to get confused by it.

Fair enough. Even when working with coordinates, I still prefer zero indexing since I like to think of the "origin" as 0,0

MATLAB also uses 1-based indexes and column-major order.

It's that 1st element that's the bugger. Does the null pointer point to the first element of an array that starts at the beginning of virtual memory??

why?

1-based ordinals were the first mistake. We could actually keep the words "first" and "second" and just spell them "0st" and "1nd", but I guess it's too late now.

@@notdeep236 Making a for loop over an array leads to more operations with 1 based indexing (by checking for

@@_clemens_ okay okay for languages like c I would agree with all of this but a language like lua. why care? lua is not for the same things.

@@notdeep236 Not sure about lua internals, alsomost never used that. Also when a language is there, it can't be changed anymore for obvious reasons ;)

yes, assuming it's a byte array, otherwise #define x[y] *(x+y*sizeof(whatever type you want to store))

​@@louisauffretwhen adding an integer to a pointer in C, the multiplication by sizeof(T) is done automatically.

​@somenameidk5278 so would manually multiplying it by sizeof have the same effect since sizeof is otherwise implied?

@@dspivey_music nope, it would be incorrect, the "implicit" sizeof is always applied

@@dspivey_music no, you would be multiplying it twice

That would be interesting. I've heard there was a CPU that ran Java bytecode as its native machine language but it was unsuccessful as an alternative to virtual machines

There was some 8 bit simulator (can't remember the name), it had 4 registers A, B, C, D, and used square brackets for pointer dereference. It was essentially a Z80 with fewer instructions. In terms of speed it was obviously faster since it was being emulated on modern hardware but I'd hesitate to call it better since as far as I remember there were no bit rotates

@@williamdrum9899 that sounds really interesting! You mean like the ones described here: en.m.wikipedia.org/wiki/Java_processor ? I wonder how complex the java virtual machine actually is compared to something like a 6502. :o

@@Vancha112 JVM has more instructions. I think it's a stack machine so probably minimal registers

@@Vancha112 Yeah that's the one. Although I have no idea how it would work.

Yes! local arr = {[0] = 20, 21, 22, 23} for i = 0, #arr do print(arr[i]) end

The trick is Lua doesn't have arrays! (well it does but that's niche). They're all hash tables so you can just as easilly index -2 billion as you can 0 and start from 150. You can even index starting from "porkypie" if you want. iirc you need to use strings and userdata to get actual arrays. userdata is C binary

@@Mallchadi havent totally fact-checked this yet but as it turns out if you do just use integers as keys Lua will actually initially only make your table an array on the C side until you use something else as a key for it which it will then create the hashtable part of your table

@@Templarfreak damn, that sounds very cool

Since when is mathetmatics 1 based? In a polynomial, which is one of the most common objects in math, we have to start at 0 (the smallest term in a typical polynomial is muliplied by x^0, not x^1). Not to mention, when solving equations, we often like to set things equal to 0, for easy equation manipulation. I don't think you can argue that mathematics is 1 based. You can argue that 0 can often be ignored, since there are many applications where 0 simply SHOULD be ignored, but you can't reasonably argue that it is 1 based.

@@simonwillover4175 This just is my memory of the 1 based vs 0 based programming language arguments I've heard over the years. I could have sounded less sure in my comment. I'm not an expert but you general hear this is the first element in ... rather than 0th.

@@simonwillover4175 It depends on what type of math you mean. You can just as easily argue and the identity element of multiplication in certain given groups is 1. There are cases to be made and most scientific programming languages and CS literature tends to favor indices starting at 1. That argument isn't that far off.

@@Finkelfunk source for "CS literature tends to favor indices starting at 1"? i understand programming langs for math like matlab, wolfram, maple, etc. often are 1-based, but all the big general-purpose langs like c/c++, java, lisp, and their descendants are all 0-based. also see Dijkstra's argument for 0-based.

it makes sense to use the number 1 as "the first element of an array" but when you have a pointer that points to the start of an array the question is "how far away am i from the first element?" and the answer is always 0.

Yep though the third is an extension

Just as a reminder, sizeof(my_array) can't be used like this: int getArraySize(size_t* my_array) { return sizeof(my_array); } Because then it will just give you the size of a pointer on your machine

This is, of course, frustrating to deal with when trying to pass arrays, especially multidimensional ones, between functions

@@natnial1 added to C23

Interesting. So the array can have metadata before element zero in this setup?

@@williamdrum9899 For instance. But it could also be that a function returns relative indices in an array that was passed to it as a pointer. Items to the left will have negative relative inidices and items to the right will have positive indices). The compilere does not force you to use a zero or a one as the first index in an array. As far as it is concerned the moment it needs to do something with an array, it will add the index to the pointer to the start of the array. Remember: subtracting is just adding with a negative (2-complement's) value. So: int *p = NULL; int a[100]; /* Let's assume for brevity's sake that this array is actually initialized */ int b = 50; int v; then: v = a[b - 3]; is equivalent to p = &a[b]; v= p[-3]; and: p = &a[b]; v = *(p - 3); I'm not saying that this is always good practice, but the many, many ways one can go about referencing an array (or any other object that is fundamentally a pointer under the hood) and its contents, simply warms my heart ;-).

No, not true. 0 is the start of the array. No space is allocated before 0. Sure, you can potentially do negative indexing, but that would be illegal. You might as well say that all arrays are huge because even if you declare a 3 element array you can still attempt to access the 20,000th element (and likely trigger an exception on any system with an MMU).

@@williamdrum9899 If you use malloc to allocate space, then in integer and a pointer (usually) are stored before the space itself to store the information required by the free() call.

@@cccmmm1234 You are confusing the convention with how the C compiler treats arrays under the hood. An OS or firmware may put boundaries on the memory you are allowed to access, but the C compiler does not care about that, nor does the C language specifically say an array should be 0-based or that indices in an array should always be 0 or positive. For instance: //------------------------------------------ char *p = "Hello World!"; char *q = NULL; int i, n = strlen(p); q = (char *) malloc(n + 1); p += n; for(i = 0; i < n; i++) { *q++ = *p--; } q[n] = 0; //------------------------------------------ is functionally equivalent to: //------------------------------------------ char *p = "Hello World!"; char *q = NULL; int i, n = strlen(p); q = (char *) malloc(n + 1); p += n; for(i = 0; i < n; i++) { q[i] = p[0 - i]; // Remember p points to the last non-nul character of the string } q[n] = 0; //------------------------------------------ In C, strings are merely character arrays. By convention we assume 0 as the start of the array, but there are circumstances where a function may return a pointer to a portion of memory where the "left hand side" (negative index) contains data we may want to use as well as the "right hand side" (positive index). In the above example, after the initial loop, p points to the last non-nul character in the array, but not to the very last character in the array (which is the nul-character). In other words: we have valid data both on the left side of p and on the right side of it. p[0] contains the exclamation mark, p[-1] contains 'd', and as mentioned before p[1] contains the string terminator.

True, but it'll really boggle you when you try to use _Generic and it matches every array passed to it as a pointer to the given type instead of an array of any dimension. It's just super annoying because it kind of reduces the utility of the functionality. I can't seem to determine if it's a bug in gcc or if that's accurate to the standard, but I don't like it either way.

@@anon_y_mousse i really don't know, didnt use these features a lot ^^

I kinda hate that so many people say lua doesn't have arrays or classes. It does! a = {1,2,3}

Huh, I never knew basic tables were represented as arrays under the hood. Guess I should change my comment then, though, that still doesn't really change the fact that the actual name for this is a "Table", not an array in the Lua programming language. It still functions as a dictionary which keys increment from 1.@@skaruts

@@BeconIsYeck the name isn't very relevant, though. An array is simply _"an ordered series or arrangement"_ (google), and it can apply to lists or groups of things, like solar panels. The names we use are just conceptual distinctions for arrays with different functionalities. A Set is an array that excludes duplicates. A Deque is an array with a specific mode of access. The name _"associative array"_ is often used to refer to Dictionaries / hash-tables / maps. The Lua table can be made to work as any of the above and more.

tables themselves are associative arrays, it's why Lua describes them as having a "table" part and an "array" part, in actuality they are both the same thing, you're just using different keys to access different values that are stored in the same table, with integers being valid keys which allows you to write syntax like a traditional array :D

That's not quite right. Lua does have arrays. It's just that tables adapt to your usage. And internally Lua actually uses C arrays when your table is used solely as a 1-indexed array. It will only turn it into a hash-table internally if you deviate from that. *_"In Lua you very rarely have to even use a syntax like array[1]"_* That entirely depends on the requirements of what you're doing, and on the framework behind it. I use love2d most of the time, and I rarely use ipairs, because I'm usually using 0-indexing and/or doing performance taxing things because the default loop is quite faster. *_" If you decide to index directly there's an argument to be made that arr[_**_#arr_**_] gets the last element of the array. If you had them 0-indexed you'd always need to do arr[_**_#arr_**_-1]."_* Therein lies a problem that you didn't catch: the # operator only counts from 1. If you're 0 indexing, #arr will already give you the length-1, so your code is wrongly overcompensating. But the blame isn't really yours to carry, as the fundamental problem is that 1-indexing introduces traps like that into the language. Ultimately you actually can't use the # operator with 0-index. If the array has < 2 elements, the # op will always report 0 length, but the real length could be 1 or 0, and there's no way to tell. You also have to keep in mind that _ipairs_ assumes base 1, which is also a bit of a trap. And that's actually the main reason why I like avoiding ipairs. This is actually a big deal. Not the worse thing, sure, but still somewhat of a big deal, because it's error prone and annoying. I'll just copy-paste below the comment I just posted on the video, where I tried to lay out some issues succinctly: There's also a lot of indexing math that you have to do yourself that only works if the arrays are 0-indexed. If you are making a platformer game, you'll have a 2D array of tiles for the levels, and you'll certainly use "index = x+y*width" or "x = i%width" and "y = i/width" to access the tiles. None of that works with 1-indexing unless you spend some time figuring out how to -adapt- overcomplicate the math. I've talked about this with a lot of people over the years, and I've seen many people who confuse indexing with counting, and also many who think 1-indexing is just something you get used to and it becomes a complete non-issue. It doesn't, ever. You just learn to live with it. It's not the worst thing, to be fair, but it's a perpetual rock in your shoe. While Lua (and also Julia) actually allows you to easily 0-index arrays, realistically you won't do that with every single array you ever create, because the language itself pushes for base-1. If you create an array literal, like "a = {1,2,3}", it will be naturally 1-based. The # operator only counts the elements from 1. The _for_ loops include the upper limit, because Lua expects you to loop from 1 to limit, not from 0 to limit-1. All of this plays a part in making it quite annoying and very prone to human mistakes. - You have to worry about not forgetting to -1 the for loop limits when looping from 0, or you get an extra iteration that can cause problems. - Sometimes you have to waste time thinking whether you should 0-index an array or just let Lua have it its way. I've had times I chose the latter, only to then regret it and have to waste even more time carefully changing my code to accommodate to 0-indexing. - Your code becomes inevitably inconsistent, with some 0-based arrays and some 1-based arrays, and then you have to be extra careful to keep in mind the ones that are 1-based, because you might have to +1 or -1 whatever variable carries the index. - It's harder to do utility functions that deal with arrays, because you can't predict the base of the arrays users might throw in there, and you have to waste more time making them work for both. - It's harder to port code to and from Lua. It requires extra care and attention, because loops will need corrections, arrays may or may not need to be made 1-based, and consequentially some code may need to account for that, etc. And then if the code isn't working, you have to double check all of the above on top of double checking if the translation is correct. I've been coding in Lua for about half a decade, and that's been my experience. Lua is actually a brilliant language, maybe my favorite ever, but this was a really unfortunate design decision that I wish had never happened. My initial months with Lua (not a beginner programmer), were also quite confusing. It took me quite some time to figure out when I should 0-index and when I shouldn't, and to this day, sometimes I'm still not 100% sure in all cases until I try one of them.

@@skaruts couldnt have said it better myself. i actually also did not know that optimization you mention in the beginning, with using an actual C array until you use the table like an associative array which then turns it into a hashtable. i too really love Lua, it is definitely my favorite language, and the 1-indexing assumption most built-in Lua functions have is irksome. however, you do have a distinct advantage in Lua in that you can *override* these built-in functions and make them work for both 0 and 1-indexing, which helps to address many of the problems you bring up. the other main things i dislike about Lua is the lack of a continue statement and no typing, i think those were not good decisions to make either. ultimately, though, since Lua is free and open source and has reasonably relaxed licensing, you could actually make whatever changes to Lua you like for your own use or even to ship into other products with and i think that's really cool :)

@@Templarfreak I tend to avoid tampering with the standard stuff, because I could forget that I did it. But yea, you can still create your own variations of it. The flexibility of Lua is actually one of my favorite things about it. Also, you can use goto if you really, really need a continue. I think it's usage is discouraged, but I've used it when porting code that used continues with very complicated if statements I didn't want to mess with. for ... do if complex_condition then goto continue end -- code ::continue:: end end

@@skaruts yeah, this is like the only way that i know of that you can use to get a continue-like statement using a goto, which i do all the time. i think this particular use-case of goto is perfectly fine. it still sucks that we dont have a more proper solution, though. in some cases, tampering with the built-in functions is also a necessity, though, if you want to implement your own types then certain functions would benefit from being overridden. for example if you want the built-in type function to return the correct value then you have to override it because Lua does not provide a better method of doing so. also by default all usertypes you define C-side that you expose to Lua will always just be considered a usertype by the type function and Lua in general, which may not be appropriate depending on your situation.

Why can't it just default the size of the data to 1 bit or 8 bits? That would be a pretty understandable thing. Or maybe 64-bits, since most systems use 64 bit memory addresses.

@@simonwillover4175 void pointers are intentionally defined as "typeless" so that they may be used to abstract away the underlying type it's pointing to. Assigning any default size is going against that, if you want to inspect the memory byte-wise you can always cast (void*) to (char*) - since their alignment is guaranteed to match. Also bitwise memory access isn't a thing afaik, memory granularity is generally on a byte scale.

@@natnial1 Yeah. If the bitwise memory access was a thing, it would just compile into an inefficient mess, probably.

This is actually the same as writting array[index], I've always seen the array brackets as another dereferencing method. You can do pretty weird stuff with that, f.e:. typedef struct { int x, y, z; } Vec3; void printFoo(Vec3* foo) { printf("x = %d ", foo->x); printf("y = %d ", *((int*)foo + 1)); printf("z = %d ", ((int*)foo)[2]); } Those dereferencing methods are completely valid, as you always interpret a block of memory.

It does. The reason you can write either one is that architectures access arrays slightly differently but are all capable of doing it, some cpus just need to take extra steps. For example, in MIPS Assembly you can only use constants as offsets for a memory load. If you want a variable offset you must add it to the array's base pointet first.

Maybe because of ancient numerals didnt had zero, like roman numbers dont have a zero at all.

It's a great trick but you have to be careful when writing the assembly for it. Use relative offsets for jumps, and absolute addresses for calls. Otherwise you end up just executing the original code in the former and risk a program counter escaping in the latter

You can make the same argument for -17 based indexing. ;-)

Yes, because of the way C does multidimensional arrays. Though, an array of pointers doesn't qualify as a multidimensional array, and in general you shouldn't do it, so don't.

Yeah, I was going to mention Delphi which naturally can do this too.

You mean a list that it automatically fills? Ever tried Haskell? With syntax like x = [1,3..] I can generate an infinite list of all odd numbers. Many languages have this type of feature nowadays.

​@@FinkelfunkI think he means an array of sized 3 where the indices are just 2018,2019,2020. Afaik you can replicate with a hashmap / dictionary.

@@bayzed Indeed you can, assuming you’re prepared to accept the performance hit.

Lua can also do this. It just starts at 1 by default.

Indeed, the explanation doesn't make sense to me. If you are indexing from 0 using array syntax I would expect that the 0 would be treated as a void*, so the compiler wouldn't multiply any type size, since that's unknown, and just work with raw bytes instead.

Always remember arr[i] is equal to *(arr + i). And the index always increments by the sizeof() the datatype (int, char, ...). This is valid too: int a = 0xAABBCCDD; int b = (int)(*((char*)&a + 2)); printf("%x", b); Which will print BB, because you only take one byte (char) out of a 4byte integer, as you interpret the integer memory as char. Pointers are amazing 😅

>:(

The lack of an argument when coming with an opinion speaks for itself ;)

A subtraction can usually be done in a single clock cycle and the multiplication with a 4 byte data type is just a left shift by 2 places which is also something any modern processor can do in a cycle. So you have 1 cycle vs 2 cycles on a machine that does 5.000.000.000 cycles per second. I _seriously_ doubt you would even be able to tell the difference if any program can fluctuate in several million cycles of pure compute time at any given point depending the current load of the operating system. Back in the 50s this might have saved a second or two of compute time but on a modern processor this is indistinguishable from one another.

I like this, but it has a downside. Let's say I store these two strings: (7) "go home" (13) "Don't go home" Now if these were null terminated I could just store the second string, and still print the first with a little pointer arithmetic. With a pascal string you can't really do that

Classes use what's called a "vtable" which means they store a function pointer. The youtuber Creel makes a great video explaining it called "Object Oriented Programming is a Dirty Rotten Low-Down Trick." In short, every class object has a hidden variable - a pointer to its "version" of a polymorphic function. This means you have an extra pointer to dereference. Now, this isn't always a bad thing. In fact, this "polymorphic" style is very important in system calls on many 80s computers, to maintain compatibility between different firmware versions

0-indexing also simplifies the indexing math a lot. index = x + y * width x = index % width y = floor(index / width) None of that works with base 1. If you really wanted base 1, you'd have to overcomplicate that math, and it's actually quite tricky to get right. And if you're working with 3D grids, I don't even want to think about it.

​@@skarutsIt is not really that complicated. index = x + (y-1) * width Just a wasteful subtraction.

@@atomgutan8064 hmm, that does work indeed (I've just tested it). It's actually simpler than I thought, but I personally wouldn't have figured it out. What about the conversion from index to x,y, though?

@@skaruts x = index % width y = ((index - x) / width) + 1 again a wasteful addition

@@atomgutan8064that won't work. That will never point you to the last index of the array. In a 16x16 matrix, the last element is the 256th. If *_index = 256_* , then *index%width* is 0, which is incorrect. Well, it will break anytime *x == width.* As for the Y, it's also wrong. If *x == width,* then that equation will break as well. My Y was also wrong, as I forgot to floor it. For base 1 you might want to just *ceil(index/width),* perhaps. But this is why I was saying this is quite tricky to get right.

friendship with matlab over

Why did you have to index an array using floats?

@@ultimatedude5686 I was modding a game and was using its crappy api, the thing barely worked and was held together with duct tape and glue

@@hughjanes4883 Makes sense. My first thought was that if you're doing array indexing using floats something has already gone horribly wrong.

You're confusing _counting_ with _indexing._ They're not the same thing, neither conceptually nor in practice. Consider these two arrays: [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] -- array with a 10 element count, indexed from 1 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] -- array with a 10 element count, indexed from 0 The actual values are irrelevant, I just used them to illustrate the different indexing. As you can see the count is the same, regardless of the indexing. In practice the indexing math -- that you need for, e.g., convert an index to an X, Y or vice versa -- will only be simple and straightforward if you're indexing from 0. I'm talking about things like this: index = x + y * width x = index % width y = floor(index / width) Pretty simple stuff. But if your array is 1-indexed then you'll have to waste time overcomplicating that math, and you'll probably gonna get it wrong too.

@@skaruts Why do you think I'm confusing them? All I'm saying is that in real life indexing (assigning numbers to objects) is TYPICALLY done starting from 1 and counting up. You can show 3 shirts to a friend and tell them: "this is 1, this is 2, this is 3, which one do you think looks best "? Of course you can also say "this is 0, this is 1 and this is 2" or even "this is 5, this is 17 and this is 611" but your friend may find that odd. That is also how it's TYPICALLY done in math. Go to Wikipedia and search for "Row and column vectors" and you'll see it. It's probably why languages like Matlab, Mathematica and Julia are also 1-based. If you're talking about pointer + distance then I think "offset" is a much better name than "index".

There are tons of things in maths that are indexed from zero. Infinite cardinals, base vectors in spacetime algebra, polynomial coefficients, and so on.

@@vytah Sure. And the things that resemble arrays in programming languages the most (row vectors) are indexed from 1.

C is basically just a smidgen of syntactic sugar on top of what your CPU instruction set does (that's why it does not hide endianness, for instance, because that would be an awfully inefficient thing to do on CPUs that have the "wrong" bye order). It requires you to think at least a little bit about the hardware that your program runs on. Not too much, just enough to make you a really good programmer over time. If you are trying to avoid that level of knowledge, then you will always stay a mediocre programmer because performance is, whether we like this or not, hardware dependent. Not saying you can't get around low level stuff most of the time by using optimized libraries and LLVM, but nobody ever died from looking underneath the hood of their car.

Under the hood, i is being multiplied by the size in memory of the variable type in both occasions as you explained in the video

C is full of such remnants. Octal literals. Precedence of bitwise operators. Commutative indexing. Arrays decaying to pointers. Undeclared functions assumed to return int. Functions in stdlib that return or take int when they should return or take char. All of that can be directly traced to B, which was a really simple language designed for a specific CPU architecture.

Most other languages will refuse to compile if you tried "array[0]" since they don't just let you dereference raw numbers like that. C allows it because this is common in most assembly languages, as they usually have a way to do a memory load with a constant offset. Now, chances are the actual assembly will use the array pointer as the base and 0 as the offset regardless of what you write, since most assembly languages have a limit on offset size (typically 7FFF is the max positive distance)

It's a C peculiarity, and probably inherited by C++ too. From what I've read it originated in an early compiler that internally translated the index operator into pointer arithmetic without checking types, and since the integer-pointer addition commutes, the whole construct did too. And now we're stuck with it...

@@magnusmalmborn8665 Which is interesting because not every architecture has commutative pointer arithmetic in hardware. I doubt even the PDP-11 (the computer on which C was developed) had it either, but using multiple instructions to make it happen is typically trivial

0.5 is better. Right in between 0 and 1 so everyone is happy

true@@pie6029

​@@pie6029Based mediator.

The linker will tell you. It's a bit more complicated than that, of course, because not every program on a multi-tasking machine can have the same memory sections mapped to the same hardware address, so what the linker actually tells you is a symbolic address that merely points to the entry in the memory management unit, which then translates that to the physical hardware address that the CPU puts onto the address bus. Even that is a multi-stage process on modern CPUs because the L1 and L2 caches are still between your program and the actual memory. So instead of grabbing the data from the main memory, the machine will try to get it from L1 first, if that fails from L2 and if that fails it will reload the caches from the main memory. Word to the wise: you really, really, really don't want that to happen because your 5.3GHz racer then basically falls back to the speed of an 80 MHz CPU or so... because the CAS latency on DDR4 is still on the order of 12.5ns! I used to have faster (but much, much smaller) memory than that on one of my boards in 1995... so we have been basically standing still with regards to board level memory access times for like 30 years now. Chip level memory is orders of magnitude faster now, of course, so try to write your program in such a way that it doesn't jump around in memory too much so that the multi-level caching strategy can actually perform its miracles.

@@lepidoptera9337 what a knowledge. Thanks for this great answer.