Thread: Casting short to char*

data[0] is not two bytes of the byte array. It is one byte of the byte array.

Interpreting two bytes of an array as a short will depend on your endianness. If you want data[0] to be the high byte and data[1] to be the low byte, then just do

Code:

data[0]<<8+data[1]

Unless, of course, you intend to use the endianness for all its glory; in that case, you would want to reinterpret the pointer (not the thing pointed to, but the pointer itself -- once you dereference the pointer with the old data type, it's game over) as a pointer to the new type.

Thanks for the answer.

I just found in some of my old code that I had already solved this problem.
As you said, I may only do it with a new pointer.

I also saw that I had to live with the compiler warnings ([Warning] initialization from incompatible pointer type) due to it.

Code:

unsigned short* data2 = data+3;
printf("%hu\n", *data2);

Output: 27392 (0x6B00)

It's works perfectly like this but I have tons of compiler warnings in my old projects. At some point it was difficult telling new warnings apart from the old ones and debugging became a hassle :S

And I have no choice about the endianness. This is the raw data I receive, this is the raw data I have to work with.

Originally Posted by Hawkin

I also saw that I had to live with the compiler warnings ([Warning] initialization from incompatible pointer type) due to it.

That's what casts are for.

Code:

short *newpointer = (short *)whatever;

You can convince the compiler you know what you're doing by using a cast

Code:

          unsigned short* data2 = (unsigned short *)data+3;

laserlight: And exactly there is my problem in understanding.

Code:

int *a = malloc(0);

int foo(int** array)
{
int *temp = malloc(0);
temp = (int*) realloc(array, somenumber*sizeof(int));
if(temp != NULL) *array = temp;
else return -2;
//Do stuff...
}

//edit: I forgot:
foo(&a);

I think it might have something to do with *array being array[0], but no I don't understand, why a[0] becomes the address of a (&a) and what to do to make it work as intended.

a[0] = 2358913;
a[1] = 1;
a[2] = 2;
a[3] = 3;
...

Salem: Does this also apply for unsigned short *data2 = (unsigned short*)(data+3);
I've been able to run it at several computers (all on windows though), so the only safe way to do it is by calculating the bytes?

Code:

int foo(int** array)
{
int i;
for(i = 0; i < 8; i++)
{
int *temp = malloc(0);
temp = (int*) realloc(*array, (i+1)*sizeof(int));
if(temp != NULL) *array = temp;
else
{
free(temp);
return -2;
}
array[i] = (int*) i;
printf("%d - %d - %d\n", i, array[i], array);
printf("%08X %08X %08X %08X %08X %08X %08X %08X\n", *array, *(array+1), *(array+2), *(array+3), *(array+4), *(array+5), *(array+6), *(array+7));
free(temp);
}
}

int main()
{
int *a = malloc(0);
int g_i;
foo(&a);
for(g_i = 0; g_i < 8; g_i++)
printf("%d - %d\n", (int*) a, (int*) a[g_i]);
}

Output:

Code:

0 - 0 - 0023FF74
00000000 0023FFB0 004011E7 00000001 00032468 00032B08 00404000 0023FFA4
1 - 1 - 0023FF74
000324D0 00000001 004011E7 00000001 00032468 00032B08 00404000 0023FFA4
2 - 2 - 0023FF74
000324D0 00000001 00000002 00000001 00032468 00032B08 00404000 0023FFA4
3 - 3 - 0023FF74
000324D0 00000001 00000002 00000003 00032468 00032B08 00404000 0023FFA4
4 - 4 - 0023FF74
00032508 00000001 00000002 00000003 00000004 00032B08 00404000 0023FFA4
5 - 5 - 0023FF74
00032508 00000001 00000002 00000003 00000004 00000005 00404000 0023FFA4
6 - 6 - 0023FF74
00032548 00000001 00000002 00000003 00000004 00000005 00000006 0023FFA4
7 - 7 - 0023FF74
00032548 00000001 00000002 00000003 00000004 00000005 00000006 00000007

00032548 - 206152

00032548 - 196984

00032548 - 131200

00032548 - 5046350

00032548 - 1599557448

00032548 - 1096041796

00032548 - 1163282770

00032548 - 3818301

These are my 2 problems. In memory array[0] is never 0. And with applying your fix a[i] does not point to the memory I have written to.

I am so confused :S

In foo, array[i] is not a data element -- it is a pointer (if it was anything valid which it isn't really). (*array)[i] are your data elements.

Oooh in the beginning I tried to convince myself that it's logical for it to be *array[i] and tried it. The result was a crashing program. I would have never found out that it must be (*array)[i]
Thanks!

Now the remaining problem stays:

Output:

Code:

...
00032550 - 206160

00032550 - 197976

00032550 - 2

00032550 - 3

00032550 - 4

00032550 - 5

00032550 - 6

00032550 - 7

So why is a[0] and a[1] not 0 and 1?

Originally Posted by Hawkin

Code:

int foo(int** array)
{
int i;
for(i = 0; i < 8; i++)
{
int *temp = malloc(0);
temp = (int*) realloc(*array, (i+1)*sizeof(int));
if(temp != NULL) *array = temp;
else
{
free(temp);
return -2;
}
array[i] = (int*) i;
printf("%d - %d - %d\n", i, array[i], array);
printf("%08X %08X %08X %08X %08X %08X %08X %08X\n", *array, *(array+1), *(array+2), *(array+3), *(array+4), *(array+5), *(array+6), *(array+7));
free(temp);
}
}

int main()
{
int *a = malloc(0);
int g_i;
foo(&a);
for(g_i = 0; g_i < 8; g_i++)
printf("%d - %d\n", (int*) a, (int*) a[g_i]);
}

I don't know how this worked for you. Luck, maybe. I first made what I think are all the appropriate (*array)[i] changes tabstop mentioned, but my program crashed on that free call. Since temp and *array point to the same place, when you free temp, you are effectively freeing *array too, which means the realloc wont work, except by sheer, magical coincidence. Once I removed that free, I seemed to have a working program.

Wow I got a good portion of dumbness
Thanks, this is the big mistakes, I totally didn't think about it.

Well, day ended, I've learned couple of things. Thanks guys!