The problem is that the compiler is not trying to use the templated operator<< you provided, but rather a non-templated version. When you declare a friend inside a class you are injecting the declaration of that function in the enclosing scope. The following code has the effect of declaring (and not defining) a free function … Read more
The principle reason why equality and ordering are separated is performance. If you have a type whose ordering operations are user-defined, then more often than not, you can write a user-defined equality test operation that is more efficient at doing equality tests. And therefore, the language should encourage you to write it by not using … Read more
You should put the operator overload in the same namespace as your class. This will allow the operator to be found during overload resolution using argument-dependent lookup (well, actually, since ostream is in namespace std, the overload overload would also be found if you put it in namespace std, but there is no reason to … Read more
The reason it does not just work is that implicit type conversions (that is, via constructors) do not apply during template argument deduction. But it works if you make the outside operator a friend since then the type T is know, allowing the compiler to investigate what can be casted to make the arguments match. … Read more
The basic idea is to overload both the << and the , operators. m << 1 is overloaded to put 1 into m and then returns a special proxy object – call it p – holding a reference to m. Then p, 2 is overloaded to put 2 into m and return p, so that … Read more
I suspect you need bool operator<(const Foo& foo1) const; Note the const after the arguments, this is to make “your” (the left-hand side in the comparison) object constant. The reason only a single operator is needed is that it is enough to implement the required ordering. To answer the abstract question “does a have to … Read more
This has been answered in excruciating detail by Eric Lippert in a blog post that has since been removed. Here is the archived version. There is also another subtler point about value types and instance operators. Static operators make this kind of code possible: class Blah { int m_iVal; public static Blah operator+ (Blah l, … Read more
As of Rust 1.0, you can now implement this: use std::ops::Mul; #[derive(Copy, Clone, PartialEq, Debug)] struct Vector3D { x: f32, y: f32, z: f32, } // Multiplication with scalar impl Mul<f32> for Vector3D { type Output = Vector3D; fn mul(self, f: f32) -> Vector3D { Vector3D { x: self.x * f, y: self.y * f, … Read more
C# compiler converts overloaded operator to functions with name op_XXXX where XXXX is the operation. For example, operator + is compiled as op_Addition. Here is the full list of overloadable operators and their respective method names: ┌──────────────────────────┬───────────────────────┬──────────────────────────┐ │ Operator │ Method Name │ Description │ ├──────────────────────────┼───────────────────────┼──────────────────────────┤ │ operator + │ op_UnaryPlus │ Unary │ │ … Read more
(x=y) means x.operator=(y), which returns the object x. Therefore, (x=y)=z means (x.operator=(y)).operator=(z). The expression in parens sets x to y and returns x, and then the outer bit sets x to z. It does not set y to z as you might expect, and as the expression x = y = z does. This behavior … Read more