Defining an object that acts like integer infinity

Question

I've created an object that acts somewhat like infinity for long ints. Specifically:

#ifndef MU_INF_H
#define MU_INF_H
#include "mu.h"
namespace mu {
  class Inf {
  public:
    bool operator> ( long int i ) { return true; }
    bool operator> ( Inf i ) { return false; }
    ... lots of other boolean operators ...
    Inf& operator+ ( long int i ) { return *this; }
    Inf& operator+ ( Inf i ) { return *this; }
    ... lots of other integer operators ...
  };   // class Inf
}      // namespace mu
#endif

And this all works pretty well, allowing me to run unit tests of the form:

  mu::Inf inf;
  long int n = -1;
  long int z = 0;
  long int p = 1;

  ASSERT((inf + inf) == inf);
  ASSERT((inf + n) == inf);
  ASSERT((inf + z) == inf);
  ASSERT((inf + p) == inf);

  ASSERT((inf > inf) == false);
  ASSERT((inf > n) == true);
  ASSERT((inf > z) == true);
  ASSERT((inf > p) == true);

At the risk of making it impossible to assign a checkmark, I have three questions:

• Does C++ already provide something like this, and/or is there an obvious better way than what I'm doing here?
• I want to make an instance of Inf available throughout my system. I can't declare it a static const because it's not a "simple" object. What's the right approach: global? singleton pattern?
• Is there a way to handle symmetric operators where the long int comes first, i.e. ASSERT((1 + inf) == inf)? (I won't be too sad if there isn't.)

Answer 1

static const Inf kInfinity; works and will use the default constructor.

operator+ should be a free function that returns by value:

Inf operator+(Inf a, Inf b) { return a += b; }

You indicated that you would prefer to return a reference to kInfinity instead of a value. This is possible (although it seems a bit unwieldy to me); a const reference would have to be returned of course, since kInfinity is const.

Answer 2

1. Not that I'm aware of, although it seems to me that you are using references to Inf and actual objects in a messy manner in your overloads.

   Normally, you take arguments by value or const reference and return by value for all operators besides the compound assignment ones (where you return by reference) to obtain the expected semantic. Of course, since your Inf object has no state, this all makes sense only to a certain extent.

2. I'd use a const global to avoid the parentheses and the potential function call involved in a singleton. Whether this is also static should make almost no difference (you aren't accessing this in any way).

3. You have to write your operator as a free function:

    inline Inf operator+(long int i, const Inf&) { return *this;}