C++ - Getting size in bits of integer

Question

I need to know whether an integer is 32 bits long or not (I want to know if it's exactly 32 bits long (8 hexadecimal characters). How could I achieve this in C++? Should I do this with the hexadecimal representation or with the unsigned int one?

My code is as follows:

mistream.open("myfile.txt");

if(mistream)
{
    for(int i=0; i<longArray; i++)
    {
        mistream >> hex >> datos[i];        
    }
}

mistream.close();

Where mistream is of type ifstream, and datos is an unsigned int array

Thank you

use `` and compute `sizeof(int)*CHAR_BIT` or test `INT_MAX/INT_MIN` — chux - Reinstate Monica, Mar 26 '15 at 17:46
I am not sure whether you want to know how many bits a variable of type `int` uses in your platform, or how many bits are necessary to represent a specifi integer value. In integer might take 32 bits but it takes only 1 bit to represent the value 0. — R Sahu, Mar 26 '15 at 17:49
A non-portable way to do it is to use non-standard intrinsics. Most machines has instructions to count leading zeros or leading redundant sign bits. — user3528438, Mar 26 '15 at 17:51
To be clear: are you interested in knowing if the _type_ is 32 bits or if the _value_ is between `power(2,31) and power(2,32)-1` or something else? — chux - Reinstate Monica, Mar 26 '15 at 17:56
Yes @chux I am interested in knowing if the value is between power(2, 31) and power(2, 32) - 1. Could you help me? Thank you — fergaral, Mar 26 '15 at 18:30

Useless · Answer 1 · 2018-04-10T09:20:39.020

std::numeric_limits<unsigned>::digits

is a static integer constant (or constexpr in C++11) giving the number of bits (since unsigned is stored in base 2, it gives binary digits).

You need to #include <limits> to get this, and you'll notice here that this gives the same value as Thomas' answer (while also being generalizable to other primitive types)

For reference (you changed your question after I answered), every integer of a given type (eg, unsigned) in a given program is exactly the same size.

What you're now asking is not the size of the integer in bits, because that never varies, but whether the top bit is set. You can test this trivially with

bool isTopBitSet(uint32_t v) {
  return v & 0x80000000u;
}

(replace the unsigned hex literal with something like T{1} << (std::numeric_limits<T>::digits-1) if you want to generalise to unsigned T other than uint32_t).

How can I use this? I mean, I have an unsigned int number, how can I use your method? — fergaral, Mar 26 '15 at 18:02
@fergaral What do you mean? You need only the type, not the value itself. — Neil Kirk, Mar 26 '15 at 18:11

5gon12eder · Answer 2 · 2015-03-26T18:07:34.600

As already hinted in a comment by @chux, you can use a combination of the sizeof operator and the CHAR_BIT macro constant. The former tells you (at compile-time) the size (in multiples of sizeof(char) aka bytes) of its argument type. The latter is the number of bits to the byte (usually 8).

You can encapsulate this nicely into a function template.

#include <climits>   // CHAR_BIT
#include <cstddef>   // std::size_t
#include <iostream>  // std::cout, std::endl

template <typename T>
constexpr std::size_t
bit_size() noexcept
{
  return sizeof(T) * CHAR_BIT;
}

int
main()
{
  std::cout << bit_size<int>() << std::endl;
  std::cout << bit_size<long>() << std::endl;
}

On my implementation, it outputs 32 and 64.

Since the function is a constexpr, you can use it in static contexts, such as in static_assert<bit_size<int>() >= 32, "too small");.

`struct Foo { int a : 5; int b : 13; };` Is there a way to `bit_size` to return 5? — Eljay, Oct 05 '22 at 15:07

Thomas Matthews · Answer 3 · 2015-03-26T18:08:04.443

5

Try this:

#include <climits>

unsigned int bits_per_byte = CHAR_BIT;
unsigned int bits_per_integer = CHAR_BIT * sizeof(int);

The identifier CHAR_BIT represents the number of bits in a char.

The sizeof returns the number of char locations occupied by the integer.

Multiplying them gives us the number of bits for an integer.

edited Mar 26 '15 at 18:08

answered Mar 26 '15 at 17:58

Thomas Matthews

56,849
17
98
154

What's the value of CHAR_BITS? I mean, the exact value, or, if not, how can I get it? Thank you – fergaral Mar 26 '15 at 18:00
This works in practice, but is not guaranteed. The standard allows `int` to use 29 bits. – Christopher Creutzig Mar 26 '15 at 18:02
1

The macro is named `CHAR_BIT` (singular) and it is defined in `climits`, not `cstdint`: http://en.cppreference.com/w/cpp/types/climits – 5gon12eder Mar 26 '15 at 18:05
I am doing it like this: unsigned int bits_per_integer = CHAR_BITS * sizeof(myarray[i]), but it always returns 32. What am I doing wrong? – fergaral Mar 26 '15 at 18:07
Edited per comment of @5gon12eder. – Thomas Matthews Mar 26 '15 at 18:08
What is the declaration of `myarray`? What platform are you using? – Thomas Matthews Mar 26 '15 at 18:09
I am obtaining myarray from a file. It has 6 integers – fergaral Mar 26 '15 at 18:13
32 is the correct number of bits in an int on a 32bit architecture machine. @ChristopherCreutzig, where did you get 29 bits? – user3629249 Mar 26 '15 at 18:16
if `myarray` is an int array, and int is 32 bits on your system (which is almost the case on modern systems) then obviously `CHAR_BIT*sizeof(myarray[i])` would always return 32 which is the number of bits in an `int` or `myarray[i]`. What else do you expect? – phuclv Mar 26 '15 at 18:18
@user3629249 that's allowed by the standard. It only specifies the minimum range for types. – phuclv Mar 26 '15 at 18:19
`sizeof(expression)` only looks at the compile-time *type* of the expression, not the runtime *value*. – fredoverflow Mar 26 '15 at 19:35

score 0 · Answer 4 · answered Mar 26 '15 at 19:12

OP said "if it's exactly 32 bits long (8 hexadecimal characters)" and further with ".. interested in knowing if the value is between power(2, 31) and power(2, 32) - 1". So it is a little fuzzy on negative 32-bit numbers.

Certainly OP wants to know the result based on the value and not the type.

bool integer_is_32_bits_long(int x) = 
    // cope with 32-bit int
    ((INT_MAX == 0x7FFFFFFF) && (x < 0)) ||
    // larger 32-bit int
    ((INT_MAX >  0x7FFFFFFF) && (x >= 0x80000000) && (x <= 0xFFFFFFFF));

Of course if int is 16-bit, then the result is always false.

score 0 · Answer 5 · edited Jun 20 '20 at 09:12

I want to know if it's exactly 32 bits long (8 hexadecimal characters)

I am interested in knowing if the value is between power(2, 31) and power(2, 32) - 1

So you want to know if the upper bit is set? Then you can simply test if the number is negative:

bool upperBitSet(int x)
{
    return x < 0;
}

For unsigned numbers, you can simply shift left and back right and then check if you lost data:

bool upperBitSet(unsigned x)
{
    return (x << 1 >> 1) != x;
}

Christopher Creutzig · Answer 6 · 2015-03-26T17:53:11.823

-2

The simplest way probably is to check if the 32nd bit is set:

bool isReally32bitsLong(uint32_t in) {
  return (in >> 31)!=0;
}

bool isExactly32BitsLong(uint64_t in) {
  return ((in >> 31)!=0) && ((in >> 32) == 0);
}

edited Mar 26 '15 at 17:53

answered Mar 26 '15 at 17:47

Christopher Creutzig

8,656
35
45

2

`1UL << 32` is potential an issue. – chux - Reinstate Monica Mar 26 '15 at 17:48
2

No, it's obviously an issue. – user3528438 Mar 26 '15 at 17:49
@user3528438 `1UL << 32` is not a problem should `unsigned long` uncharacteristically be wider than 32-bit. – chux - Reinstate Monica Mar 26 '15 at 17:51
No, it's not. But I changed the code to also work on exotic systems with `sizeof(unsigned long) < 64`. ;-} – Christopher Creutzig Mar 26 '15 at 17:51
@ChristopherCreutzig: Exotic? You mean like Windows? – Mooing Duck Mar 26 '15 at 17:55
@MooingDuck: Right, that was the name. ;-}} – Christopher Creutzig Mar 26 '15 at 17:55
@MooingDuck Why windows? Almost all implementation on all 32bit machines uses 32bit `long` – user3528438 Mar 26 '15 at 17:58
1

@user3528438: Specifically, _Visual Studio_ (The compiler used to compile almost all Windows programs) uses 32 bit longs when compiling for 64 bit machines. Clang and G++ both use 64 bit longs when compiling for 64 bit machines. `long` is a language thing, so what matters is the compiler, not the hardware. – Mooing Duck Mar 26 '15 at 17:59
This causes undefined behavior with 16-bit integers. – Thomas Matthews Mar 26 '15 at 17:59
@ThomasMatthews What does? The code in my answer only uses integers of specified width now, no 16 bit integers anywhere. – Christopher Creutzig Mar 26 '15 at 18:00

C++ - Getting size in bits of integer

6 Answers6