C++ 定义一个作用类似整数无穷大的对象

我创建了一个对象，它的行为有点像长整数的无穷大。具体而言：

#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

这一切都非常有效，允许我运行以下形式的单元测试：

  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);

冒着无法指定复选标记的风险，我有三个问题：

C++是否已经提供了类似的东西，和/或有一个比我在这里做得更好的方式吗？
• 我想在我的系统中提供一个Inf实例。我不能将它声明为

  静态常量

  ，因为它不是一个“简单”对象。什么是正确的方法：全球？单件模式
• 有没有一种方法可以处理长int首先出现的对称运算符，即

  ASSERT（（1+inf）==inf）

  ？（如果没有，我不会太难过。）

我不知道，尽管在我看来，您在重载中以一种混乱的方式使用了对

Inf

的引用和实际对象

通常情况下，除了复合赋值运算符（通过引用返回）之外，您还可以按值或

const

引用获取参数，并按值返回所有运算符，以获得预期的语义。当然，由于您的Inf对象没有状态，这一切只有在一定程度上才有意义

我会使用

const

global来避免单例中的括号和潜在函数调用。这是否也是

静态的

应该几乎没有区别（您没有以任何方式访问

此

）

您必须将运算符编写为自由函数：

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

---

static const Inf kInfinity工作并将使用默认构造函数

运算符+
应该是按值返回的自由函数：

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

您表示希望返回对
kInfinity
的引用，而不是值。这是可能的（尽管我觉得有点笨拙）；当然必须返回
const
引用，因为
kInfinity
是
const
 每个人都帮我找到了真正的方向。为了帮助其他来寻找答案的人，而不是让你把整个线索的答案一针见血地拼凑在一起，我想我应该发布我最终得到的答案。当然，建议改进的评论是受欢迎的

#ifndef MU_INDEFINITE_H
#define MU_INDEFINITE_H

namespace mu {

  class Indefinite {
  public:

    static const Indefinite kIndefinite;

    Indefinite() {}
    ~Indefinite() {}

  };

  inline Indefinite operator+ (long int i, Indefinite t) { return Indefinite::kIndefinite; }
  inline Indefinite operator+ (Indefinite t, long int i) { return Indefinite::kIndefinite; }
  inline Indefinite operator+ (Indefinite t1, Indefinite t2) { return Indefinite::kIndefinite; }

  inline Indefinite operator- (long int i, Indefinite t) { return Indefinite::kIndefinite; }
  inline Indefinite operator- (Indefinite t, long int i ) { return Indefinite::kIndefinite; }
  inline Indefinite operator- (Indefinite t1, Indefinite t2) { return Indefinite::kIndefinite; }

  inline Indefinite operator* (long int i, Indefinite t) { return Indefinite::kIndefinite; }
  inline Indefinite operator* (Indefinite t, long int i ) { return Indefinite::kIndefinite; }
  inline Indefinite operator* (Indefinite t1, Indefinite t2) { return Indefinite::kIndefinite; }

  // It's not clear what i / Indefinite should produce.  Forbid it for now.
  // inline long int operator/ (long int i, Indefinite t) { return 0; }
  inline Indefinite operator/ (Indefinite t, long int i ) { return Indefinite::kIndefinite; }
  inline Indefinite operator/ (Indefinite t1, Indefinite t2) { return Indefinite::kIndefinite; }

  inline bool operator> (long int i, Indefinite t) { return false; }
  inline bool operator> (Indefinite t, long int i) { return true; }
  inline bool operator> (Indefinite t1, Indefinite t2) { return false; }

  inline bool operator>= (long int i, Indefinite t) { return false; }
  inline bool operator>= (Indefinite t, long int i) { return true; }
  inline bool operator>= (Indefinite t1, Indefinite t2) { return true; }

  inline bool operator< (long int i, Indefinite t) { return true; }
  inline bool operator< (Indefinite t, long int i) { return false; }
  inline bool operator< (Indefinite t1, Indefinite t2) { return false; }

  inline bool operator<= (long int i, Indefinite t) { return true; }
  inline bool operator<= (Indefinite t, long int i) { return false; }
  inline bool operator<= (Indefinite t1, Indefinite t2) { return true; }

  inline bool operator== (long int i, Indefinite t) { return false; }
  inline bool operator== (Indefinite t, long int i) { return false; }
  inline bool operator== (Indefinite t1, Indefinite t2) { return true; }

  inline bool operator!= (long int i, Indefinite t) { return true; }
  inline bool operator!= (Indefinite t, long int i) { return true; }
  inline bool operator!= (Indefinite t1, Indefinite t2) { return false; }

}

#endif

#如果不确定
#定义MU__H
名称空间mu{
类不定{
公众：
静态常数不定定常数；
不定（）{}
~unfinite（）{}
};
内联不定运算符+（长整数i，不定t）{返回不定：：kIndefinite；}
内联不定运算符+（不定t，长int i）{返回不定：：kIndefinite；}
内联不定运算符+（不定t1，不定t2）{返回不定：：kIndefinite；}
内联不定运算符-（长整数i，不定t）{return infinite:：kIndefinite；}
内联不定运算符-（不定t，长整数i）{return infinite:：kIndefinite；}
内联不定运算符-（不定t1，不定t2）{返回不定：：kIndefinite；}
内联不定运算符*（长整数i，不定t）{返回不定：：kIndefinite；}
内联不定运算符*（不定t，长int i）{返回不定：：kIndefinite；}
内联不定运算符*（不定t1，不定t2）{返回不定：：kIndefinite；}
//不清楚我/我应该制作什么。暂时禁止。
//内联长整型运算符/（长整型i，不定t）{返回0；}
内联不定运算符/（不定t，长int i）{返回不定：：kIndefinite；}
内联不定运算符/（不定t1，不定t2）{返回不定：：kIndefinite；}
内联布尔运算符>（长整数i，不定t）{return false；}
内联布尔运算符>（不定t，长整数i）{return true；}
内联布尔运算符>（不定t1，不定t2）{return false；}
内联布尔运算符>=（长整数i，不定t）{return false；}
内联布尔运算符>=（不定t，长整数i）{返回真；}
内联布尔运算符>=（不定t1，不定t2）{return true；}
内联布尔运算符<（长整数i，不定t）{return true；}
内联布尔运算符<（不定t，长整数i）{返回false；}
内联布尔运算符<（不定t1，不定t2）{返回false；}
内联布尔运算符你是什么意思
它不是一个“简单”的对象
？如果你的代码运行正常，并且你希望得到关于如何改进的建议，你可能会在codereview.stackexchange上得到更好的帮助。@BryanChen:我的意思是我不能做
静态常量Inf kInfinity=new Inf（）
或任何类似于使其成为静态常量的东西。要生成对称运算符，它们应该是自由函数：
Inf operator+（Inf a，Inf b）{return a+=b；}
。现有的
运算符+
不符合
运算符+
的通常语义，使用起来可能会混淆（它做了
操作符+=
通常做的事情）。@fearless\u傻瓜
静态常量Inf kInfinity；
注意：静态常量的初始化需要用户提供的默认构造函数。系统默认值不会将其删除。我之所以提到它，是因为OP发布的类没有构造函数。（和+1 btw）注意，如果使用SFINAE驱动的一组自由函数，OP可以覆盖比
long
更多的基础。回答不错。