Question

我正在玩重载运算符。

当我使用INTEGER和STRING类时，一切正常。

 class INTEGER {
  private:
    int iValue;

  public:
    INTEGER() {
      iValue = 0;
      }

    int& operator=  (int const& iParam) {
      return iValue = iParam;
      }

    friend ostream& operator<< (ostream& os, const INTEGER& obj)  {
      return os << obj.iValue << endl;
      }

    operator int    () const {
      return iValue;
      }

    operator string () const {
      ostringstream os;
      os << iValue;
      return string(os.str().c_str());
      }
    };


  class STRING {
  private:
    string  strValue;

  public:
    STRING () {
      strValue = "";
      }

    string& operator= (string const& strParam) {
      return strValue = strParam;
      }

    friend ostream& operator<< (ostream& os, const STRING& obj) {
      return os << obj.strValue.c_str() << endl;
      }

    operator int() const {
      istringstream ss(strValue);
      int iValue;
      ss >> iValue;
      return iValue;
      }
  };


int main() {  
    INTEGER i1, i2;
    STRING  s1, s2;

    i1 = 1;    
    s1 = "2";

    i2 = i1 + s1;
    s2 = i2;

    cout << i1 << s1 << i2 << s2;

    return 0;
  }

输出：

1 2 3 3

但是如果我用

扩展我的班级INTEGER

operator double    () const {
  return (double)iValue;
  }

（下一课FLOAT的预备）

编译器与以下内容混淆：“operator INTEGER :: int（）const”和“operator INITEGER :: double（）const”之间不明确

  i2 = i1 + s1;

我不懂我的编译器，从不使用浮点值。 i1和i2来自INTEGER类，s2来自STRING类，并且有一个int（） - 运算符。

请点亮我的想法......

Answer 1

您尚未定义operator+(INTEGER,STRING)，因此您的编译器必须使用其中一个内置运算符+。它可以使用int+int或double+int，因为STRING的转化运算符为int，INTEGER为int和double }。但这两个选择含糊不清。

恕我直言，你应该避免'有趣'的转换操作符，因为它们允许各种代码意外地工作，例如

STRING s;
std::cout << std::setw(s) << "oops";

而是直接定义算术运算符。

Answer 2

谢谢！

插入此剪辑时，一切都很好 - 直到下一个障碍！^^

const int operator+(const string& strValue) {
  istringstream ss(strValue);
  int iValue2;
  ss >> iValue2;

  return iValue + iValue2;
  }

尝试运算符会导致操作员错误

2 个答案: