Thread: What does it mean to "Subtract one Pointer from another" ?

According to : The C Book — Introduction

Subtracting one pointer from another gives a result whose type differs between different implementations. To allow safe use of the difference, the type is defined in <stddef.h> to be ptrdiff_t. Similarly, you can use size_t to store the result of sizeof.

The idea as it seems to me is to find out the distance (in bytes(?)) between two addresses.

Why would the `difference` between different types of pointers have different types ?

The next paragraph talks about a macro called offsetof for finding the offset of structure members. What is the difference between using it and simply ( *object - *member ) ?

^Sorry... The last line should read ( &object - &member) . Didn't edit it because editing seems to do away with all newlines and some other whitespaces in my case.

When in doubt... look it up...

From the stddef.h supplied with Pelles C...

Code:

/* type definitions */
#ifndef _PTRDIFF_T_DEFINED
#define _PTRDIFF_T_DEFINED
#if __POCC_TARGET__ == 3
typedef long long ptrdiff_t;
#else
typedef int ptrdiff_t;
#endif
#endif /* _PTRDIFF_T_DEFINED */

#ifndef _SIZE_T_DEFINED
#define _SIZE_T_DEFINED
#if __POCC_TARGET__ == 3
typedef unsigned long long size_t;
#else
typedef unsigned int size_t;
#endif
#endif /* _SIZE_T_DEFINED */

since POCC_TARGET is about architecture : 3 = x64, 2 = x86, etc... we can deduce that it's about providing consistent types across differing architectures. As in a uniform definition of something that's actually compiler/platform dependent.

Originally Posted by MK27

I guess for convenience. That way, p++ will always take you to, eg, the next int in an array, and not just the second byte of the current one.

It's not for that. It's because a pointer can be of many different sizes: 16 bit pointers are somewhat common, 32 and 64 bit pointers are extremely common. So what type do you use to hold the difference between 64 bit pointers? It needs at least 64 bits! But you can't use the same type for 16 bit pointers as they might not even have support for 64 bit registers.
So it's likely the difference will be the same size as the pointers itself. Whatever size that is depends on the architecture.

Originally Posted by MK27

That's backwards (it's member - struct), but you are right, that is the same thing. However, note that you cannot subtract a struct address from a member address without casting, because they are different types. So offsetof() is a little tidier:

I think it's the same as casting both to a "const char*", and taking their differences (as a char is defined to be 1 byte in size), assuming that is strictly legal according to the standard.

Edit: the offsetof implementation in my header files are a bit more intelligent though:

Code:

#define offsetof(type, member) ( (int) & ((type*)0) -> member )