问题描述:

Was having a discussion with some friends based on a brain tester on whether or not the question was valid as written. It lead us to discussing if it was possible to overload + or - for primitive types in any language.

Are there any languages where you could get the following to evaluate:

answer = 8 + 11;

if (answer == 96){

//Yay! It worked!

}

网友答案:

C# implementation; not exactly what you want (Trick is not a primitive type), but with the required behaviour:

  public struct Trick {
    public override bool Equals(object obj) {
      return true;
    }

    public override int GetHashCode() {
      return 0;
    }

    // Trick can be implicitly created from any int (e.g. from 19, 96 etc.)
    public static implicit operator Trick(int value) {
      return new Trick();
    } 

    // All Trick instances are equal to each other
    public static bool operator == (Trick left, Trick right) {
      return true;
    }

    public static bool operator != (Trick left, Trick right) {
      return false;
    }
  }

Now, we are ready to test Trick:

  Trick answer;

  // ------ Now goes your fragment -----------------------

  answer = 8 + 11; // Trick instance can be implicitly created from int (from 19)

  // .Net can't compare answer (which is Trick) and int (96), however
  // Trick instance can be implicitly created from int (from 96) 
  // so .Net will create Trick instance from 96 and compare two Tricks
  if (answer == 96) { 
    // when comparing two Trick instances:
    // one created from 19 and other created from 96 
    // they are equal to one another
    Console.Write("Yay! It worked!");
  } 

And you'll get

"Yay! It worked!"

网友答案:

C++ and Ruby.

//C++    
class X
    {
     public:
      X& operator+=(const X& rhs) // compound assignment (does not need to be a member,
      {                           // but often is, to modify the private members)
        /* addition of rhs to *this takes place here */
        return *this; // return the result by reference
      }

      // friends defined inside class body are inline and are hidden from non-ADL lookup
      friend X operator+(X lhs,        // passing lhs by value helps optimize chained a+b+c
                         const X& rhs) // otherwise, both parameters may be const references
      {
        lhs += rhs; // reuse compound assignment
        return lhs; // return the result by value (uses move constructor)
      }
    };

Ruby:

class String
  def <<(value)
    self.replace(value + self)
  end
end

str = "Hello, "
str << "World."
puts str
相关阅读:
Top