Bit Setting for long long

I'm trying to write an expression in a single line that can do the following:

take the sizeof(type), then fill a long long variable with 1's for the amount of bytes given by the sizeof.

For example:

type = long - then my number is: 0x00000000ffffffff

type = long long - then my number is 0xffffffffffffffff

Thanks!

How will you handle this type X?

Code:

---

struct X
{
    long long a, b;
};

---

i need to do this:

static const double SCALE = 2.0 / VALUE;

where value is the variable i need to calculate with the sizeof. So I can fill half of VALUE with type long, and all of VALUE with type long long.

edit: iMalc gave a way better example below, I removed my /fail pseudo code.

The C++ witch makes a good point, not only could you receive a struct larger than any of the basic/standard data types, but you could receive a struct with two or three chars, you won't actually know what you're dealing with unless you require some extra input.

I don't know what you're trying to do, but it may not work out like you want without convoluted functions (eww gross!) in this approach. ;p

May-be a template function:

Code:

---

#include <iostream>
template <class N>
N all_ones()
{
    return ~N();
}

int main()
{
    unsigned long long a = all_ones<unsigned long>();
    unsigned long long b = all_ones<unsigned long long>();
    std::cout << std::hex << a << '\n' << b << '\n';
}

---

This won't work with signed types, though, because the result would be seen as -1 in either case, and the implicit cast from -1L to -1LL would flip the rest of the bits.

However, it also appears to me that you might just want to divide 2.0 by the maximum value of corresponding unsigned type:

Code:

---

#include <limits>

double d = 2.0 / std::numeric_limits<unsigned long>::max();

---

Be warned that you could lose some precision with unsigned long long, since its maximum value might not be exactly representable as double.

~0ULL>>(64-sizeof(type)*8) should do it :p.