digitalmars.D.learn - Operators overloading in D2 again
- Dan (29/29) May 01 2010 Hi everyone,
- =?UTF-8?B?QWxpIMOHZWhyZWxp?= (29/69) May 01 2010 Functions can not be overloaded by return type alone; so I took the one
- Robert Clipsham (40/42) May 02 2010 The following code does it:
- Dan (10/10) May 03 2010 Hi,
- Pelle (6/16) May 03 2010 The D way is superior, because you don't need to come up with arbitrary
- Lars T. Kyllingstad (49/61) May 03 2010 I was sceptic at first, too, but after having written some code using th...
- Lars T. Kyllingstad (4/10) May 03 2010 Sorry, that last line should be:
- Dan (15/15) May 03 2010 I'm still really sceptic, especially because they look to me inconsisten...
- bearophile (5/7) May 03 2010 Yes, they seem divided in two groups, with different level of complexity...
Hi everyone, is there anyway to do this with operators overloading? : class Tester { double x = 0.0; double opBinary(string op:"+")(double value) { return x+value; } Tester opBinary(string op:"+")(Tester other) { Tester ret; ret.x += other.x; return ret; } } int main(char[][] args) { Tester t1 = new Tester; Tester t2 = new Tester; t1.x = 1.0; t2.x = 2.0; Tester t3; t3 = t1+t2; assert (t3.x = 3.0); return 0; } Thanks, Dan
May 01 2010
Dan wrote:Hi everyone, is there anyway to do this with operators overloading? : class Tester { double x = 0.0; double opBinary(string op:"+")(double value) { return x+value; } Tester opBinary(string op:"+")(Tester other) { Tester ret; ret.x += other.x; return ret; } } int main(char[][] args) { Tester t1 = new Tester; Tester t2 = new Tester; t1.x = 1.0; t2.x = 2.0; Tester t3; t3 = t1+t2; assert (t3.x = 3.0); return 0; } Thanks, DanFunctions can not be overloaded by return type alone; so I took the one that returned double out. We are dealing with a Tester class, and it makes sense to me to stay in this type. When necessary, we can provide a conversion function that returns a double value. I've corrected a couple of errors, introduced a constructor, and came up with this: class Tester { double x = 0.0; this(double x) { this.x = x; } Tester opBinary(string op:"+")(const Tester other) const { return new Tester(x + other.x); } } int main(char[][] args) { Tester t1 = new Tester(1.0); Tester t2 = new Tester(2.0); Tester t3 = t1 + t2; assert (t3.x == 3.0); return 0; } Ali
May 01 2010
On 02/05/10 07:14, Dan wrote:Hi everyone, is there anyway to do this with operators overloading? :The following code does it: ---- class Tester { double x = 0.0; T opBinary(string op:"+", T)(T value) if(is(T : double)) { return x+value; } T opBinary(string op:"+", T)(T other) if(is(T : Tester)) { Tester ret = new Tester; ret.x = this.x + other.x; return ret; } } int main(char[][] args) { Tester t1 = new Tester; Tester t2 = new Tester; t1.x = 1.0; t2.x = 2.0; Tester t3 = new Tester; t3 = t1+t2; assert (t3.x == 3.0); return 0; } ---- Some variations from the original code: - Fixed the assert ==, not = - Made sure all testers are initialised... Don't forget to instantiate classes before you use them, otherwise you'll end up with segmentation faults - Fixed a semantic error in the latter of the binary functions - an empty Tester is at 0, if you want to add them you need to make sure you do that, not just add other I'd also advise you replace Tester with a struct if you won't be needing inheritance, this way you save some memory overhead, and don't have to remember to use = new Tester; Hope this helps :)
May 02 2010
Hi, it certainly helps. However I can't help myself, I still thinking that this is the most complicated, hard read and to understand way to overload operators. Maybe there is something I'm missing but I can't really see the reason of all that. Other languages adopts a much easier approach, for example python but also C++ that D is trying to surpass (and it does in most cases) when it comes to operator overloading is much more clear than D. I still thinking that the D1's approach was much better than this. Anyway, now I have another problem: I can't get how to overload operators like these <=, <, >=, >. I read the documentation but I can't really understand it. Thanks for the precious help guys. DAniele
May 03 2010
On 05/03/2010 04:28 PM, Dan wrote:Hi, it certainly helps. However I can't help myself, I still thinking that this is the most complicated, hard read and to understand way to overload operators. Maybe there is something I'm missing but I can't really see the reason of all that. Other languages adopts a much easier approach, for example python but also C++ that D is trying to surpass (and it does in most cases) when it comes to operator overloading is much more clear than D. I still thinking that the D1's approach was much better than this.The D way is superior, because you don't need to come up with arbitrary names, like the D1/Python way, and it's much easier to parse than the C++-way, at least I think it is.Anyway, now I have another problem: I can't get how to overload operators like these<=,<,>=,>. I read the documentation but I can't really understand it.http://digitalmars.com/d/2.0/operatoroverloading.html#compare You should define an opCmp.Thanks for the precious help guys. DAniele
May 03 2010
On Mon, 03 May 2010 14:28:20 +0000, Dan wrote:it certainly helps. However I can't help myself, I still thinking that this is the most complicated, hard read and to understand way to overload operators. Maybe there is something I'm missing but I can't really see the reason of all that. Other languages adopts a much easier approach, for example python but also C++ that D is trying to surpass (and it does in most cases) when it comes to operator overloading is much more clear than D. I still thinking that the D1's approach was much better than this.I was sceptic at first, too, but after having written some code using the new operator overloading system I am convinced: It totally rocks. It is amazing how much boilerplate code one *doesn't* have to write anymore. Here's a trivial example: struct Pair(T) { T a, b; Pair opBinary(string op)(Pair p) { auto r = this; r.opOpAssign!op(p); return r; } Pair opOpAssign(string op)(Pair p) if (op == "+=" || op == "-=" || op == "*=" || op == "/=") { mixin ("a "~op~" p.a"); mixin ("b "~op~" p.b"); return this; } } With just two short function definitions I have written what would have been eight functions with the old system. For real-life examples, check out: http://www.dsource.org/projects/phobos/browser/trunk/phobos/std/bigint.d http://www.dsource.org/projects/phobos/browser/trunk/phobos/std/complex.dAnyway, now I have another problem: I can't get how to overload operators like these <=, <, >=, >. I read the documentation but I can't really understand it.Here's an example which (hopefully) illustrates how it works: // Simple struct that wraps a built-in integer. struct Integer { int n; int opCmp(Integer i) { // If this is smaller than i, return a negative number. if (n < i.n) return -1; // If this is equal to i, return zero. else if (n == i.n) return 0; // If this is greater than i, return a positive number. else return 1; } } Of course, this was a needlessly verbose example, as I could just have written this instead: int opCmp(Integer i) { return n - i.n; } This, I guess, is why the signature of opCmp() is the way it is. -Lars
May 03 2010
On Mon, 03 May 2010 16:46:41 +0000, Lars T. Kyllingstad wrote:[...] Pair opBinary(string op)(Pair p) { auto r = this; r.opOpAssign!op(p);Sorry, that last line should be: r.opOpAssign!(op~"=")(p); -Lars
May 03 2010
I'm still really sceptic, especially because they look to me inconsistent to each other. for example opBinary(string op:"something here")(Object other) and then ther is opCmp(Obejct other) which is not template and there is only one for all these operators < <= > >= Did I understand correctly? if I did I found this really inconsistent and in my experience consistency is better than save lines of code... my personla point of view, off course. I'll take you advice anyway and I'll keep going, hopefully I'll change my mind too. I relly like D so far for pretty much everything, I'm just having hard time with this operators overloading... Thanks for you help guys, Dan
May 03 2010
Dan:I'm still really sceptic, especially because they look to me inconsistent to each other.Yes, they seem divided in two groups, with different level of complexity, etc. This is true, and I think this is by design, opCmp and opEquals and few others are useful in many classes. While overloading the []+= operator is for someone that wants to design a new refined data structure, something less common and that requires quite more care. Bye, bearophile
May 03 2010