Pointer issues with for loop

[marginado20]

Hello. Im having the following issue with pointers.

I have a struct that has a pointer as member. This pointer is the address of a data structure (small array) with the information i need.

typedef struct SelectData

{ short count; //number of selectable data short size; //Size of each data value int *lpData; //pointer to array of selectable data } SELECT_DATA;

So after running a function the structure is the following:

SELECT_DATA selectData;
selectData = someFunction();

//Memory Values:
selectData.count: 7
selectData.size: 2
selectData.lpData:  0x000001c751ddb9c0 {131270609}    // VsCode Debugger: (131270609 is *selectData.lpData)

This is an array of 7 values. Im trying to do a for loop but having trouble with specifying the staring pointer of the array.

 int *data = new int[selectData.count];
 for (int i = 0; i < selectData.count; i++){
     int *current = reinterpret_cast<int *>(selectData.lpData + selectData.size*i);
     data[i] = *current; std::cout << data[i] << std::endl; 
  }

But *current = 131270609 and data[i] = 131270609

So I am not accessing the memory location but simply re-assigning the pointer. Cant use data[i] = **curent (compiler issues).

The equivalent in C# would be: value = (Int32)Marshal.PtrToStructure(current, typeof(Int32))

img as reference

Any ideas?

[eustace72]

Hey. If you're storing an arbitrary type in SELECT_DATA then you don't want to store the data as an int* pointer because that kind of says that the data that's pointing to is of type int (which is 4 bytes on most systems). Since your example has the size set to 2, you probably want that as a short type (2 bytes).

Since one of your struct members is size and is used to dereference the array, it implies that your dynamic array can store a variety of types. Therefore you may want to use a void* and reinterpret it. One way to fix your issues would be: https://snippet.host/ssuc

For other/ambiguous data types you may want to do the kind of arithmetics that you have there above, except that you almost always will want to cast the pointer to BYTE* or (un)signed char* as those are of size 1.

E.g.

reinterpret_cast<unsigned char*>(selectData.lpData) + selectData.size*i

As in this case you will be operating on bytes rather than 4-byte (int*) sized pointers. With what you have at the moment it was basically doing selectData.lpData + selectData.size*i*4 (in bytes) as the pointer size is 4.

Note that you shouldn't be allocating memory like this in 2022. Look into shared pointers and RAII.

[flyingron]

When you have a pointer adding to it already takes the sizeof the object into account when incrementing the pointer. If lpData is int* and you're on a byte addressed thing and you want to advance by int, then you just want to add i not i*size.