I received data from some other function to myfunction(const void *data) where pointer data stores the values like {0,0,0,0,0,0,0,40,20,0,0,0,0,0,0}.
I want to access just values from {40,20,0,0,0,0,0,0} and convert into a double type value that should give 8.0 . For accessing and conversion to double type I have tried pointer to double:
double* dptr;
dptr=&(*data+8);
dptr;
that was giving error like
"error: ‘const void*’ is not a pointer-to-object type"
In C you cannot de-reference a void pointer. So you can type cast the void pointer and use it. something like this dptr=((double*)data+8); So the data which is void is considered as a double pointer now.
Edit Your post is very unclear. Assuming data is actually a pointer to an array of double the solution is even simpler:
double * pd = static_cast<double const *>(data);
double d0 = pd[0];
double d1 = pd[1];
or (C):
double * pd= (double const *)(data);
double d0 = pd[0];
double d1 = pd[1];
You cannot perform pointer arithmetics and dereferencing on void * so *data or data + 8 are invalid.
I don’t understand exactly what you are trying to do, but here is how you access data in your array:
Assuming the data stored is actually int, to access the 8th element and convert it into double you should write:
double el = static_cast<double>*(static_cast<int const *>(data) + 8));
better yet:
int *p = static_cast<int const *>(data);
double el = static_cast<double>(p[8]);
Please note that is is really important that you convert data to the original pointer type . In my example I used int but you should replace it with what your data actually is.
On that note, if what you are showing as {0,0,0,0,0,0,0,40,20,0,0,0,0,0,0} are actually bytes, then the original pointer type is char * and you should convert to char *.
To clarify furthermore converting data from pointers:
Let’s say you have a pointer to int:
int i = 24;
int *pi = &i;
How would you convert to double the data found on address pi?
// wrong:
double *pd = &i;
cout << *pd << endl;
That is wrong because what you do is converting the pointer type and not the actual data. In effect you interpret the bit pattern found at address pi as a bit pattern representing a double. But that bit pattern represents and int.
What you need to do is retrieve the data as it is: an int and then convert the int to double:
int x = *pi;
double d = (double) x;
You cannot perform pointer arithmetic in void pointers, since you don't know the size of the inner data (as it says, it is void). You have to typecast it to a type with a known size.
The correct typecasting and pointer arithmetic is as follows (using old C conversions):
char * ptr=(char *)data;
double * myDoublePtr=(double *)(ptr+8);
double myDouble=*myDouble;
Or, as you have two doubles consecutive:
double * ptr=(double *)data;
double myDouble=*(ptr+1); //This will access the second double.
This is because an offset in pointer arithmetics will perform a jump of offset*sizeof(type) bytes, so in a char type, the number of bytes jumped will actually be the same as your offset.
#include <stdio.h>
#include <string.h>
double myfunction(const void *data){
double v;
memcpy(&v, data, sizeof(v));
return v;
}
int main (int argc, char *argv[]) {
unsigned char data[] = {0x40,0x20,0,0,0,0,0,0};
int i, len = sizeof(data);
//reverse data If necessary
for(i=0;i<len/2;++i){
unsigned char c = data[i];
data[i] = data[len -1 -i];
data[len -1 -i] = c;
}
double v;
v = myfunction(data);
printf("%f\n", v);//8.000000
return 0;
}
