CareerCup

// ZoomBA
// define Point 
def Point : {
   $$ : def(x=0,y=0){  $.x = x ; $.y = y },
   $add : def (o) { new ( Point , $.x + o.x , $.y + o.y ) },
   $str : def(){ str('(%s,%s)', $.x, $.y)}
}

a = new ( Point, 1,2)
b = new ( Point, 3,4)
c = a + b 
println(c)

class Point{
    private:
        int x, y;   
    public:
        Point(int xval, int yval):x(xval),y(yval){}
        Point operator+(const Point& other)
        {
            this->x += other.x;
            this->y += other.y;
            return *this;
        }
        void print()
        {
            std::cout << "x: " << x << "\n";
            std::cout << "y: " << y << "\n";
        }
        
};

int main()
{
    Point p1(1,2);
    Point p2(3,4);
    Point p4(4,5);
    Point p3 = p1+p2+p4;
    p3.print();
}

:: - steephen
====
Your + operator is *mutable*. It should never be, definitely NO for a arithmetic type.
What you did is this:
stackoverflow.com/questions/4581961/c-how-to-overload-operator
wikipedia.org/wiki/Immutable_object

Found a Ruby implementation:

class Point
    attr_accessor :x, :y

    def initialize(x,y)
        @x, @y = x, y
    end


    def +(other)
      Point.new(@x + other.x, @y + other.y)
    end


    def to_s
        "(#{@x}, #{@y})"
    end
end