const makes overload faster?

[Friso1990]

Hello,

I'm working on a class that overloads operators and I was told that by adding const in the parameters and at the end of the declaration I could make them faster.

Could someone explain why that is/how that works?

Thank you in advance,
Friso

[JockX]

There are potential situations in which using const allow compiler to do some optimizations by calculating in compile-time, rather than run-time, but this is not the main reason for using const in operators. You place const in overloaded operator functions to make sure that any arguments passed to it will not be changed directly (as anyone would expect), as in below example:

#include <iostream>

class Pair
{
public:
	int a;
	int b;

	Pair (int A, int B);
	Pair operator+ (Pair & other); 

};

Pair::Pair (int A, int B) {this->a = A;	this->b = B;};

Pair Pair::operator+ (Pair & other)
{
	Pair result(this->a + other.a, 
				this->b + other.b);

	// The below is legal, but 
	// hardly expected for what
	// should operator+ do
	other.a += 99999999; // Constness prevents such
	this->a += 99999999; // alterations to arguments.
	/////

	return result;
}

int main()
{
	Pair one(1,1);
	Pair two(2,2);
	Pair three(0,0);
	
	std::cout << "one:\t" << one.a << ", " << one.b << "\n" 
			  << "two:\t" << two.a << ", " << two.b << "\n" 
			  << "three:\t"<< three.a << ", " << three.b << "\n\n";

	
	three = one + two; // now both one and two are changed!
	std::cout << "after one+two: \n\n";
	std::cout << "one:\t" << one.a << ", " << one.b << "\n" 
			  << "two:\t" << two.a << ", " << two.b << "\n" 
			  << "three:\t"<< three.a << ", " << three.b << "\n\n";
}

[newbieg]

There's also the convenience factor, a function or operator that takes a const variable can also take a regular variable, but a function or operator that is made to take a regular variable can't legally take a const variable because the compiler decides that there is a possibility of the const variable being altered.

It's good practice to make a function or operator accept a const variable whenever possible.

[Friso1990]

@JockX
So if I'm to understand correctly writing the overload like this:
Pair operator+ (const Pair & other);
Will prevent:
other.a += 99999999;

So does that mean that adding another const at the end like so:
Pair operator+ (const Pair & other) const;
would prevent:
this->a += 99999999;?

@newbieg
Thank you, I'll be sure to put that into practice.

[JockX]

@Friso1990 - that's right.