Place least significant bits of int into char in C++

Question

I would like to find a maximally efficient way to compute a char that contains the least significant bits of an int in C++11. The solution must work with any possible standards-compliant compiler. (I'm using the N3290 C++ draft spec, which is essentially C++11.)

The reason for this is that I'm writing something like a fuzz tester, and want to check libraries that require a std::string as input. So I need to generate random characters for the strings. The pseudo-random generator I'm using provides ints whose low bits are pretty uniformly random, but I'm not sure of the exact range. (Basically the exact range depends on a "size of test case" runtime parameter.)

If I didn't care about working on any compiler, this would be as simple as:

inline char int2char(int i) { return i; }

Before you dismiss this as a trivial question, consider that:

• You don't know whether char is a signed or unsigned type.

• If char is signed, then a conversion from an unrepresentable int to a char is "implementation-defined" (§4.7/3). This is far better than undefined, but for this solution I'd need to see some evidence that the standard prohibits things like converting all ints not between CHAR_MIN and CHAR_MAX to '\0'.

• reinterpret_cast is not permitted between a signed and unsigned char (§5.2.10). static_cast performs the same conversion as in the previous point.

• char c = i & 0xff;--though it silences some compiler warnings--is almost certainly not correct for all implementation-defined conversions. In particular, i & 0xff is always a positive number, so in the case that c is signed could quite plausibly not convert negative values of i to negative values of c.

Here are some solutions that do work, but in most of these cases I'm worried they won't be as efficient as a simple conversion. These also seem too complicated for something so simple:

• Using reinterpret_cast on a pointer or reference, since you can convert from unsigned char * or unsigned char & to char * or char & (but at the possible cost of runtime overhead).

• Using a union of char and unsigned char, where you first assign the int to the unsigned char, then extract the char (which again could be slower).

• Shifting left and right to sign-extend the int. E.g., if i is the int, running c = ((i << 8 * (sizeof(i) - sizeof(c)) >> 8 * (sizeof(i) - sizeof(c)) (but that's inelegant, and if the compiler doesn't optimize away the shifts, quite slow).

Here's a minimal working example. The goal is to argue that the assertions can never fail on any compiler, or to define an alternate int2char in which the assertions can never fail.

#include <algorithm>
#include <cassert>
#include <cstdio>
#include <cstdlib>

using namespace std;

constexpr char int2char(int i) { return i; }

int
main(int argc, char **argv)
{
  for (int n = 1; n < min(argc, 127); n++) {
    char c = -n;
    int i = (atoi(argv[n]) << 8) ^ -n;
    assert(c == int2char(i));
  }
  return 0;
}

I've phrased this question in terms of C++ because the standards are easier to find on the web, but I am equally interested in a solution in C. Here's the MWE in C:

#include <assert.h>
#include <stdlib.h>

static char int2char(int i) { return i; }

int
main(int argc, char **argv)
{
  for (int n = 1; n < argc && n < 127; n++) {
    char c = -n;
    int i = (atoi(argv[n]) << 8) ^ -n;
    assert(c == int2char(i));
  }
  return 0;
}

Answer 1

a far better way is to have an array of chars and generate a random number to pick a char from that array. This way you get 'well behaved' characters; or at least characters with well defined badness. If you really want all 256 chars (note 8 bit assumption) then create an array with 256 entries in it ('a','b',....'\t','n'.....)

This will be portable too

Answer 2

Given that you appear to be interested in bit value (rather than numeric value), and have also asked for C solutions, I'm going to post what I believe to be something that's compliant and optimal:

inline char int2char(int i) {
    char ret;
    memcpy(&ret, (char *)&i + OFFSET, 1);
    return ret;
}

where OFFSET is a macro that expands to either 0 or sizeof(int)-1, based on an endianness check.

AFAICS, this works invariant of whether char is signed or unsigned, of what representation is used for negative values, or of the width of char or int. It doesn't rely on any weird type-punning tricks, and has no branching or complex operations (such as divide).

I say "optimal" because I'm assuming that any sane compiler treats memcpy as an intrinsic, and thus will do something smart here.