0

I have a function in my c++ application that needs an integer as an input. Sadly this integer is only available in form of an usigned char array, which inclines me to do this:

 unsigned char c[4] = {'1','2','3','4'}; 

 void myFuncThatBadlyNeedsInts(int i)
        //compares some memory value(which is an int) with anotherone...

 myFuncThatBadlyNeedsInts((int)c);

This gives me an error, which tells me that this is not allowed. But if i decide to get tricky and do this:

 myFuncThatBadlyNeedsInts(*((int*)&c));

Now the program goes about and gives me always the result i want. My question is: Why is there a diffrence in the result of the two casts? Shouldn't they both do the same, with the diffrence i have two unneccessary pointers in the process?

Help or the guidance to an alredy existing answer to my qustion is much appreciated.

EDIT (since i can't comment): The need for this indeed silly conversion is inheritated from a project which compares a specific memory location (as an int) with a DWORD wich is retrived from a FGPA and comes as an array. The DWORD gets read in the end as one hex-number. I'll try to get permission to change this and THANK YOU ALL for the quick responses. I really didn't get the part of this program nor did I understand why it worked like this in the first place. Now I know someone got lucky

P.S.: Since im new here and this my first qustion please let me know what other specifics you might need or just edit my newby misshabits away.

FruitSokrat
  • 105
  • 9
  • 1
    While I have answered what happens with your two calls, I can't say what you really should be doing as I don't know what you actually want to do. Do you want to pass the whole arrays as a single 32-bit integer? Pass only one element of the array? Please elaborate on the *actual* problem you try to solve ([related reading about the XY problem](http://xyproblem.info/)). – Some programmer dude Feb 26 '16 at 09:47
  • This is one of the better reasons why there is a concept of a union in C and C++ - It allows you to really tell the compiler what you are doing. Right now you're tricking it into doing the right whing..... – tofro Feb 26 '16 at 10:37
  • @tofro Using a union to do [*type punning*](https://en.wikipedia.org/wiki/Type_punning) is okay in C (it's mentioned explicitly in the specification), but not in C++ where it violates the [*string aliasing rule*](http://stackoverflow.com/questions/98650/what-is-the-strict-aliasing-rule). – Some programmer dude Feb 26 '16 at 10:54
  • Is it? Generally? I think if you do it right - And especially in this case I think it can be done right (by sticking to use a pointer to a union and maybe some grain of volatile as the value comes from an FPGA), it doesn't. – tofro Feb 26 '16 at 12:50

3 Answers3

1

When you do myFuncThatBadlyNeedsInts((int)c) the compiler first decay the array c to a pointer to the first element, i.e. &c[0], you then cast this pointer to an int and pass that to the function.

When you do *((int*)&c) you take the address of the array (of type int (*)[4]) and tell the compiler that it's a pointer to an int (which is not correct) and then dereference that (incorrect) int*.

So both calls are actually incorrect. The casting just silences the compiler.

If you want to treat the four bytes of the array as a single 32-bit word, there are ways to do it, but they all breaks the strict aliasing rule.

The simplest way is very close to what you have now, and is done with casting. Using C-casting you cast the pointer that c decays to as a pointer to int and dereference that:

myFuncThatBadlyNeedsInts(*(int*)c);

Note that this is not the same thing as either of your attempts.

The second way is to use a union:

union my_union
{
    char bytes[sizeof(int)];
    int  integer;
};

Then copy the data to your unions bytes member, and read out the integer.

Community
  • 1
  • 1
Some programmer dude
  • 400,186
  • 35
  • 402
  • 621
  • 1
    To extend the comment "both calls are actually incorrect". The second call is lying to the compiler, and "If you lie to the compiler, it will get its revenge" - Henry Spence. Accessing the value returned from the cast is undefined behaviour and could quite easily crash the program. – Martin Bonner supports Monica Feb 26 '16 at 09:58
0

In the second case you get pointer from unsigned char than cast it to integer, so in fact you always use your uchar and 3 bytes just after (in this case whole array c). Because of sizeof int is 4 (usually, but not always), and size of uchar is only 1. So don't do this unless you like to shoot yourself in leg.

To be honest I don't really understand what you are going to achive in this example

Jeka
  • 1,364
  • 17
  • 33
0

In the first case you are trying to cast an char array to an int - this is obviously meaningless in that an list of characters is quite different to an int.

In The second case you first take the address of the array - the & operator gives you a character pointer to the first element of the array. Specifically the type of &c is unsigned char * - it is legal (although dangerous) to cast between pointer types thus the cast from unsigned char * to int * is legal.

Then you dereference the pointer and get the integer that is at this spot which is probably some nasty (meaningless) number derived from the first couple of characters in the string which are those bytes.

So you second solution doesn't convert from char[] to int[] which is presumably what you want, instead it give you an integer representation of the first bytes of the char array.

Elemental
  • 7,365
  • 2
  • 28
  • 33