(Oct 4, 2017 04:26 AM)Dostoevsky Wrote:  You can just learn by using pointer arithmetic syntax as opposed to using the [] array syntax sugar.

Firstly, you have to understand that arrays start at 0 to satisfy the basic formula:
Address of T[x] in T[]:

Code

T[x] = &T[0] + (x * sizeof(T))

So, the base address (starting address) of the array plus the index multiplied by the size of the array type in bytes. Thus, if you want to access the first element (which is at the base address - (x = 0)), the right hand side of the multiplication will cancel to 0 nicely.

You just have to understand that the underlying pointer types don't really matter until you try to dereference them (as the type information about the size and alignment of types is all the compiler cares about). This is actually why sizeof(char) is defined to be 1 by the standard despite the fact GCC actually allows you to do pointer arithmetic with void* (other compilers like clang simply support this as a GCC extension/plugin).

So, to understand what I mean:

PHP Code


<?php 
puts("memelord" + 2); 


will print melord since string literals will yield const char* and the sizeof(char) == 1, so you're adding (2 1) to that string literal's address.

Similarly:

PHP Code


<?php 
int array[] = { 2, 3, 4 };
printf("%d\n", *(array + 2)); 


Again, the compiler knows that the underlying type is an int (sizeof(int) == 4) so it's abstracted this from you and lets you just write *(array + 2) rather than array + (2 sizeof(int)) which would be the actual memory offset. So this code prints array[2], which as you know, is 4.

(Oct 4, 2017 10:17 AM)0xDEAD10CC Wrote:  

Code

const char *p = "Hello World";
while(*p) putchar(*p++);

Knowing what strlen() actually does, and also, NEVER declare string literals as char* because they are pointers to read-only memory and the compiler can't warn you if you don't make it const like I did above. You'll get a runtime error if you modify that string, but if you declared it as char[] it would be a pointer to a copy of that data which you CAN modify.

As for what Dostoevsky points out.

a[10] is the same as (a + 10)
a[0] is the same as *(a + 0) which is the same as *a

It's syntactic sugar, which is why you can also do this:
0[a], because it is the same as *(0 + a) but it's not as common to write that way so people don't do it.

The type of the pointer with the mathematical expression operating on the pointer address is what determines the byte offset for each index, and this is dealt with for you.

(Oct 4, 2017 01:31 PM)Consulting Detective Wrote:  Let’s say that it’s guaranteed that the program will not modify the string literal declared as char*, is there gonna be difference between that and a string declared as const char* performance wise?

Also, would it be ok if I use while(*p != 0) or while(*p != ‘\0’) instead of while(*p)?