3

I have the following function:

void func(unsigned long v)
{
  char max_byte = 0xFF;
  char buffer[8];

  buffer[0] = static_cast<char>((v)       & max_byte);
  buffer[1] = static_cast<char>((v >> 8)  & max_byte);
  buffer[2] = static_cast<char>((v >> 16) & max_byte);
  buffer[3] = static_cast<char>((v >> 24) & max_byte);
  buffer[4] = static_cast<char>((v >> 32) & max_byte);
  buffer[5] = static_cast<char>((v >> 40) & max_byte);
  buffer[6] = static_cast<char>((v >> 48) & max_byte);
  buffer[7] = static_cast<char>((v >> 56) & max_byte);
}

which takes an unsigned long argument and insert its 8 bytes to char buffer ( don't try to figure out why. it is a concise version of a meaningful function).

This code compiles well on 64 bit but on 32 bit I get the following warning:

warning: right shift count >= width of type

referring to lines:

  buffer[4] = static_cast<char>((v >> 32) & max_byte);
  buffer[5] = static_cast<char>((v >> 40) & max_byte);
  buffer[6] = static_cast<char>((v >> 48) & max_byte);
  buffer[7] = static_cast<char>((v >> 56) & max_byte);

I think I understand the warning but I'm not sure what should I do to be able to compile it smoothly on 32 bit as well.

idanshmu
  • 5,061
  • 6
  • 46
  • 92
  • 4
    Yes, it is [undefined behavior](http://stackoverflow.com/questions/18918256/is-right-shift-undefined-behavior-if-the-count-is-larger-than-the-width-of-the-t/18918340#18918340) to perform a shift with a width greater or equal to number of bits. – Shafik Yaghmour May 09 '14 at 14:57
  • What is the length of `unsigned long` on the 32-bit-system? – Codor May 09 '14 at 14:58
  • @ShafikYaghmour I understand that, but what is the solution. `unsigned long` is 64 bit in length and I need to process it correctly. – idanshmu May 09 '14 at 14:59
  • Let's speak on shift operators <<, >> - http://www.viva64.com/en/b/0142/ –  May 09 '14 at 16:14

4 Answers4

8

Use the fixed-width integer types. In this case, you want std::uint64_t.

ecatmur
  • 152,476
  • 27
  • 293
  • 366
5

unsigned long is only guaranteed to have 32 bits. See here. You need to use unsigned long long to have 64 bits guaranteed.

Even better would be to use a fixed width integer, i.e. uint64_t. They are defined in header <cstdint> (or <stdint.h>).

Danvil
  • 22,240
  • 19
  • 65
  • 88
  • "also in earlier versions of C++" - only if your library/compiler has non-standard extensions. They weren't standard until C++11. – Mike Seymour May 09 '14 at 15:33
2

When writing code that depends on integer size, you really, really need to be using <stdint.h>.

#include <stdint.h>

void func(uint64_t v)
{
  static const uint8_t max_byte = 0xFF; // Let the compiler hardcode this constant.
  uint8_t buffer[8];

  buffer[0] = static_cast<uint8_t>((v)       & max_byte);
  buffer[1] = static_cast<uint8_t>((v >> 8)  & max_byte);
  buffer[2] = static_cast<uint8_t>((v >> 16) & max_byte);
  buffer[3] = static_cast<uint8_t>((v >> 24) & max_byte);
  buffer[4] = static_cast<uint8_t>((v >> 32) & max_byte);
  buffer[5] = static_cast<uint8_t>((v >> 40) & max_byte);
  buffer[6] = static_cast<uint8_t>((v >> 48) & max_byte);
  buffer[7] = static_cast<uint8_t>((v >> 56) & max_byte);
}
Mike DeSimone
  • 41,631
  • 10
  • 72
  • 96
0

I may be wrong with the assumption that none of the answers truly gets to the point of this question, therefore here goes.

Compiling as a 64bit binary a long is defined as a 64bit value (or 8 bytes), whereas a 32 bit binary a long is the same as an int which is 32 bits or 4 bytes.

There are several solutions to the problem:
1. redefine the parameter to a long long or an int64 as suggested in other responses.
2. add a preprocessor define to block out the offending bit operations. Such as...

#ifdef __LP64__
buffer[4] = static_cast<uint8_t>((v >> 32) & max_byte);
buffer[5] = static_cast<uint8_t>((v >> 40) & max_byte);
buffer[6] = static_cast<uint8_t>((v >> 48) & max_byte);
buffer[7] = static_cast<uint8_t>((v >> 56) & max_byte);
#endif


This will ensure that a long is processed according to the processors architecture and not forcing a long to always be 64 bits.
3. Using a union would accomplish the same end result too, for the code provided

void func(unsigned long v)
{
    union {
        unsigned long long  ival;
        unsigned char       cval[8];
    } a;

    a.ival = v;
}

of course if you use c++ then you can store any basic datatype in a similar fashion by modifying the above as follows:

template<class I>
void func(I v) {
    union {
        unsigned long long  ival;
        unsigned char       cval[8];
        I                   val;
    } a;

    a.val = v;
}
Gary Barnes
  • 73
  • 8