You need to understand the reason behind this claim. Have you ever questioned yourself why it is faster? Let’s compare some code: int i; int a[20]; // Init all values to zero memset(a, 0, sizeof(a)); for (i = 0; i < 20; i++) { printf(“Value of %d is %d\n”, i, a[i]); } They are all … Read more
Is it possible, for a pointer variable p, that p<(p+1) is false? If p points to a valid object (that is, one created according to the C++ object model) of the correct type, then no. p+1 will point to the memory location after that object, and will always compare greater than p. Otherwise, the behaviour … Read more
To add the standard quote: expr.add#5 When two pointer expressions P and Q are subtracted, the type of the result is an implementation-defined signed integral type; this type shall be the same type that is defined as std::ptrdiff_t in the <cstddef> header ([support.types]). (5.1) If P and Q both evaluate to null pointer values, the … Read more
The assignment: void *ptr = (char *)0x01; Is implementation defined behavior because it is converting an integer to a pointer. This is detailed in section 6.3.2.3 of the C standard regarding Pointers: 5 An integer may be converted to any pointer type. Except as previously specified, the result is implementation-defined, might not be correctly aligned, … Read more
The quote is just wrong. Pretty tragic that such garbage is still published in this decade. In fact, the C Standard defines x[y] as *(x+y). The part about lvalues later on the page is completely and utterly wrong too. IMHO, the best way to use this book is to put it in a recycling bin … Read more
Here is where I learned pointers: http://www.cplusplus.com/doc/tutorial/pointers.html Once you understand pointers, pointer arithmetic is easy. The only difference between it and regular arithmetic is that the number you are adding to the pointer will be multiplied by the size of the type that the pointer is pointing to. For example, if you have a pointer … Read more
When you add 1 to a pointer, the result is the location of the next object in a sequence of objects of the pointed-to type (i.e., an array). If p points to an int object, then p + 1 will point to the next int in a sequence. If p points to a 5-element array … Read more
Final conclusion: arithmetic on a void* is illegal in both C and C++. GCC allows it as an extension, see Arithmetic on void– and Function-Pointers (note that this section is part of the “C Extensions” chapter of the manual). Clang and ICC likely allow void* arithmetic for the purposes of compatibility with GCC. Other compilers … Read more
The C standard defines the [] operator as follows: a[b] == *(a + b) Therefore a[5] will evaluate to: *(a + 5) and 5[a] will evaluate to: *(5 + a) a is a pointer to the first element of the array. a[5] is the value that’s 5 elements further from a, which is the same … Read more