プリミティブ型の+演算子を無効にできますか？

Question

質問が書かれているように有効であるかどうかについて、脳の検査官に基づくいくつかの友人との話し合いがありました。任意の言語のプリミティブ型に対して+または-をオーバーロードすることが可能かどうかを議論することにつながります。

あなたが得ることができる任意の言語がありますを評価するには、次

answer = 8 + 11; 
if (answer == 96){ 
    //Yay! It worked! 
} 

Answer 1

C＃実装。ない正確あなたは（Trickがないプリミティブ型である）が、必要な行動で何をしたい：今

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：

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

そして、あなたは得ます

"よかった！"

Answer 2

C++と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) 
     } 
    }; 

ルビー：

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

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