Negative zero int

Question

I require a vector of integers, where I can distinguish between 0 and -0. So far i've come up with the idea of defining a new class called zero_int for this special case..

However, now I can't push both normal integers and the zero_int into the same vector. The solution std::variant has the size of 8 Bytes and I need to retain the size of 4 per variable.. Defining a virtual base class my_int and setting zero_int to be its derived class increases the size of zero_int to 32 Bytes...

I'm aware one could use something like a vector<void*> but I don't know how.. - Also, are objects pointed to by the pointers in a vector of pointers contiguous in memory?? - This is important in this case.

I would appreciate any suggestions on how to solve this

Do your integers fit within a 24 bit range ? If so you could just use float without any loss of precision. — Paul R, Jun 11 '20 at 18:19
You should create a new integer class that contains a bool for sign and an unsigned int for value ([hints here](https://stackoverflow.com/questions/269268/how-to-implement-big-int-in-c) and [here](https://stackoverflow.com/questions/7914972/create-c-integer-class-to-act-absolutely-identical-to-integral-integer-type)) and fill your vector only with instances of that class. — Giovanni Cerretani, Jun 11 '20 at 18:26
@GiovanniCerretani _"I need to retain the size of 4 per variable"_ — Asteroids With Wings, Jun 11 '20 at 18:26
@GiovanniCerretani Bitfields are a plague. Their behaviour is remarkably underspecified — Asteroids With Wings, Jun 11 '20 at 18:28
@AsteroidsWithWings -- the behavior of bitfields is **deliberately** underspecified. — Pete Becker, Jun 11 '20 at 18:52
@PeteBecker Doesn't really matter whether it was deliberate or not — Asteroids With Wings, Jun 11 '20 at 18:57
@AsteroidsWithWings -- it does matter, to the extent that "remarkably underspecified" suggests that there's a possibility that this might change. — Pete Becker, Jun 11 '20 at 18:58
@PeteBecker That suggestion was certainly not my intent. Nonetheless, it still doesn't matter in the context of whether one should use them for this now, today. — Asteroids With Wings, Jun 11 '20 at 18:59
@AsteroidsWithWings -- people read answers and comments for far more than their immediate technical content. — Pete Becker, Jun 11 '20 at 19:13
@PeteBecker Let's stay on the topic of this question. Have a good night! — Asteroids With Wings, Jun 11 '20 at 19:20

Asteroids With Wings · Accepted Answer · 2020-06-12T10:36:37.997

4

The solution std::variant has the size of 8 Bytes and I need to retain the size of 4 per variable..

That's impossible, unless you don't mind losing one possible non-zero int value.

Which brings us to the "obvious" solution: treat 0 as -0, and every positive number as itself minus one.

    vec[i]:  -5 -4 -3 -2 -1  0 +1 +2 +3 +4 +5
my "value":  -5 -4 -3 -2 -1 -0 +0 +1 +2 +3 +4

(Or do it the other way around, which gives you symmetry in positive and negative ranges; whatever you like.)

Make whatever class wraps your vector handle this "mapping" in whatever way is appropriate for your project.

are objects pointed to by the pointers in a vector of pointers contiguous in memory??

No.

You don't want more indirection here.

Someone will suggest using floating-point, since IEEE 754 supports signed zero. However, I submit that switching to floating-point for representing real numbers in any case is likely to introduce more problems than it solves.

edited Jun 12 '20 at 10:36

answered Jun 11 '20 at 18:16

Asteroids With Wings

17,071
2
21
35

You lose the value (2^31)-1 with this solution, but that is probably ok? Basically need to be careful of overflow and such... – Michael Dorgan Jun 11 '20 at 18:49
I'd be tempted to go the other way: treat non-negative numbers as their natural value, and treat negative numbers as their value plus one. That way, positive numbers are all positive and negative numbers are all negative. It also removes the asymmetry in the range of twos-complement numbers. – Pete Becker Jun 11 '20 at 18:54
Yeah, or that. Whatever the OP needs. But the basic idea is a simple off-by-one mapping to add a slot for neg zero. – Asteroids With Wings Jun 11 '20 at 18:57
Great solution thanks!, I have no problem with giving up one int value – Adam Jun 11 '20 at 19:21
Seems to me like the "obvious" solution is to give up -2^31 and use one's complement. That gives you a symmetric range of representable values, whereas this answer has two more representable negative values than positive values. – user2357112 Jun 11 '20 at 21:30
As the others have said, yes. OP can adjust to their needs. – Asteroids With Wings Jun 12 '20 at 10:36

Pete Becker · Answer 2 · 2020-06-11T21:25:08.163

0

I'd consider using an unsigned type and explicitly managing the top bit as a sign bit:

class my_int {
public:
    my_int(int v) { set(v); }
    explicit operator int() const { return get(); }
    bool is_negative() const { return value & sign_bit; }
private:
    const static unsigned sign_bit =
        1u << (std::numeric_limits<unsigned>::digits - 1);
    unsigned value;
    void set(int v) { value = v < 0 ? (-v) & sign_bit : v;
    }
    int get() const { return value & sign_bit ? -(value & ~sign_bit) : value; }
};

Caution: written but not tested.

edited Jun 11 '20 at 21:25

answered Jun 11 '20 at 19:10

Pete Becker

74,985
8
76
165

Wouldn't changing one bit change the value? – Adam Jun 11 '20 at 19:25
@Adam — yes. That’s why `get()` masks out the sign bit. – Pete Becker Jun 11 '20 at 19:43
this doesn't compile at the moment. my changes changes got it to compile but not to work properly, thanks anyway – Adam Jun 11 '20 at 19:53

Negative zero int

2 Answers2