问哪些语言(如果有的话)可以覆盖基元类型的+运算符？

EN

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

  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!");
  } 

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

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

str = "Hello, "
str << "World."
puts str