Index of element pointed to by pointer

Question

I have a 2D char array declared as

char A[100][100]

I also have a pointer that points to one element of that array

char *ptr;
ptr = A[5]

This pointer gets passed to another function, which needs to be able to know the index of that pointer (in this case, 5)

void func(void *ptr) {
int index = ???
}

How can I do this? Is this even possible?

Why not just pass the index along: `void func(void *ptr, size_t i);`? — alk, Oct 30 '16 at 09:57

Jean-François Fabre · Accepted Answer · 2016-10-30T16:06:34.683

3

Yes it is possible if you can see A in func (A is just a doubly-indexed 1D array, not a pointer on arrays, that's why it is possible).

#include <stdio.h>

char A[100][100];

void func(void *ptr) {
  char *ptrc = (char*)ptr;
  printf("index %d\n",int((ptrc-A[0])/sizeof(A[0])));
}

int main()
{
  char *ptr = A[5];
  func(ptr);
}

result:

index 5

of course, if you pass an unrelated pointer to func you'll have undefined results.

Note: it is required to cast the incoming void * pointer to char * or the compiler won't let us diff pointers of incompatible types.

EDIT: as I was challenged by chqrlie to compute both indexes, I tried it and it worked (also added safety to prevent the function being called with an unrelated pointer):

#include <stdio.h>
#include <assert.h>

char A[100][100];

void func(void *ptr) 
{
  char *ptrc = (char*)ptr;
  ptrdiff_t diff = (ptrc-A[0]);
  assert(0 <= diff);
  assert(diff < sizeof(A));
  printf("index %d %d\n",(int)(diff/sizeof(A[0])),(int)(diff % sizeof(A[0])));
}

int main()
{
  char *ptr = &(A[5][34]);
  func(ptr);
}

result:

index 5 34

edited Oct 30 '16 at 16:06

answered Oct 29 '16 at 21:54

Jean-François Fabre

137,073
23
153
219

Just curious, why do you do that initial cast of char *ptrc = (char*) ptr;? Can you not just use ptr in that print statement? – Bob Oct 29 '16 at 21:57
I need the pointer to be of the same type, or the compiler won't let me diff the pointers. – Jean-François Fabre Oct 29 '16 at 21:58
The pointer could point *inside* the 2D array, computing both indices seems palatable. – chqrlie Oct 29 '16 at 22:02
@chqrlie it is indeed possible with another routine, see my edit. – Jean-François Fabre Oct 29 '16 at 22:07
@Jean-FrançoisFabre: let's congratulate each other with up ticks ;-) – chqrlie Oct 29 '16 at 22:14
1

Using C there there is no need to cast here `char *ptrc = (char*)ptr;`. – alk Oct 30 '16 at 09:54
For this `int diff` there is `ptrdiff_t`. – alk Oct 30 '16 at 09:58
And in any case `%d` is the wrong conversion specifier. – alk Oct 30 '16 at 10:01
@alk I knew I was doing something wrong. Will edit. Is %p all right for pointer diffs? – Jean-François Fabre Oct 30 '16 at 10:05
`sizeof` evaluates to `size_t` which, as being unsigned, probably ranks higher then `ptrdiff_t`, so it would need to `%zu`. – alk Oct 30 '16 at 10:09
Subtraction of two pointers evaluates to an integer value. `%p` is for pointers, but you probably know this ... ;-) – alk Oct 30 '16 at 10:10
To be super save one also wants to add something like `assert(diff > 0);` before going to devide the `signed` by the `unsigned`. – alk Oct 30 '16 at 10:12
added assert, but `%zu` doesn't work. It just prints `zu`. – Jean-François Fabre Oct 30 '16 at 11:05
The `printf` statement is incorrect: `diff / sizeof(A[0])` has the larger type of `ptrdiff_t` and `size_t`, which may be larger than `int`. You should cast the operands as `(int)(diff / sizeof(A[0]))` or possibly use `%zu` and cast as `(size_t)diff / sizeof(A[0])` – chqrlie Oct 30 '16 at 11:21
okay but my gcc 4.9 does not accept `%zu`. and pointer diff should be %td as stated here: http://stackoverflow.com/questions/7954439/c-which-character-should-be-used-for-ptrdiff-t-in-printf – Jean-François Fabre Oct 30 '16 at 11:24
`gcc` is fine, but your C library (Microsoft?) is not C99 compliant: cast the operands as `(int)`. – chqrlie Oct 30 '16 at 11:26
Oops: `assert(0 <= diff < sizeof(A));`? Might do what you expect in Python, but not in C. – alk Oct 30 '16 at 11:55
The equivalent for `zu` when using VC is `lu`. – alk Oct 30 '16 at 11:58
fixed the assert part (too much python those days!!) and cast to int, else it would require to set some GNU define so gcc doesn't use windows printf. Not worth it IMHO. – Jean-François Fabre Oct 30 '16 at 16:07

chqrlie · Answer 2 · 2016-10-30T11:19:28.627

2

You can compute the offset of ptr from the beginning of the array and derive the coordinates:

#include <stdio.h>
#include <stdlib.h>

char A[100][100];

void func(void *ptr) {
    if (ptr == NULL) {
        printf("ptr = NULL\n");
        return;
    }
    ptrdiff_t pos = (char *)ptr - A[0];
    if (pos < 0 || pos > (ptrdiff_t)sizeof(A)) {
        printf("ptr points outside A: ptr=%p, A=%p..%p\n",
               ptr, (void*)A, (void*)&A[100][100]);
    } else {
        printf("ptr = &A[%d][%d]\n",
               (int)((size_t)pos / sizeof(A[0])),  // row number
               (int)((size_t)pos % sizeof(A[0])))  // column number
    }
}

int main(void) {
    char *ptr = &A[5][3];
    func(ptr);
    return 0;
}

edited Oct 30 '16 at 11:19

answered Oct 29 '16 at 22:07

chqrlie

131,814
10
121
189

For this `size_t pos` there is `ptrdiff_t`. – alk Oct 30 '16 at 09:59
@alk: That's correct, but `pos` is positive by constuction if `ptr` is a valid pointer inside `A` or at its upper edge. The conversion is fine in this case. If `ptr` is `NULL` or points outside `A`, computing the difference is meaningless anyway. – chqrlie Oct 30 '16 at 11:14

Index of element pointed to by pointer

2 Answers2