The operators obviously return a bool, indicating true or false for the corresponding operation.

All of the operators take their arguments by const&, because the only thing that does operators do is compare, so they shouldn't modify the objects. Passing by & (reference) is faster than by value, and to make sure that the operators don't modify it, it is a const-reference.

Note that the operators inside the class/struct are defined as const, the reason for this is that without the functions being const, comparing const objects would not be possible, as the compiler doesn't know that the operators don't modify anything.

Section 36.8: Assignment operator

The assignment operator is one of the most important operators because it allows you to change the status of a variable.

If you do not overload the assignment operator for your class/struct, it is automatically generated by the compiler: the automatically-generated assignment operator performs a "memberwise assignment", ie by invoking assignment operators on all members, so that one object is copied to the other, a member at time. The assignment operator should be overloaded when the simple memberwise assignment is not suitable for your class/struct, for example if you need to perform a deep copy of an object.

Overloading the assignment operator = is easy, but you should follow some simple steps.

1. Test for self-assignment. This check is important for two reasons:

a self-assignment is a needless copy, so it does not make sense to perform it; the next step will not work in the case of a self-assignment.

2.Clean the old data. The old data must be replaced with new ones. Now, you can understand the second reason of the previous step: if the content of the object was destroyed, a self-assignment will fail to perform the copy.

3.Copy all members. If you overload the assignment operator for your class or your struct, it is not

automatically generated by the compiler, so you will need to take charge of copying all members from the other object.

4. Return *this. The operator returns by itself by reference, because it allows chaining (i.e. int b = (a = 6) + 4; //b == 10).

//T is some type

T& operator=(const T& other)

{

//Do something (like copying values) return *this;

}

Note: other is passed by const&, because the object being assigned should not be changed, and passing by reference is faster than by value, and to make sure than operator= doesn't modify it accidentally, it is const.

The assignment operator can only to be overloaded in the class/struct, because the left value of = is always the class/struct itself. Defining it as a free function doesn't have this guarantee, and is disallowed because of that.

When you declare it in the class/struct, the left value is implicitly the class/struct itself, so there is no problem with that.

Inside the class/struct you have to make a temporary object, because you can't modify this, as it would modify the original object, which shouldn't be the case.

Section 36.11: Bit shift operators for I/O

The operators << and >> are commonly used as "write" and "read" operators:

std::ostream overloads << to write variables to the underlying stream (example: std::cout)

std::istream overloads >> to read from the underlying stream to a variable (example: std::cin)

The way they do this is similar if you wanted to overload them "normally" outside of the class/struct, except that specifying the arguments are not of the same type:

Return type is the stream you want to overload from (for example, std::ostream) passed by reference, to allow chaining (Chaining: std::cout << a << b;). Example: std::ostream&

lhs would be the same as the return type

rhs is the type you want to allow overloading from (i.e. T), passed by const& instead of value for performance reason (rhs shouldn't be changed anyway). Example: const Vector&.

Example:

//Overload std::ostream operator<< to allow output from Vector's std::ostream& operator<<(std::ostream& lhs, const Vector& rhs)

{

lhs << "x: " << rhs.x << " y: " << rhs.y << " z: " << rhs.z << '\n'; return lhs;

}

Vector v = { 1, 2, 3};

//Now you can do std::cout << v;