14.1 — Introduction to operator overloading
Using function overloading to overload operators is called operator overloading.
Operators as functions
Consider the following example:
int x { 2 };
int y { 3 };
std::cout << x + y << '\n';
The compiler comes with a built-in version of the plus operator (+) for integer operands – this function adds integers x and y together and returns an integer result. When you see the expression x + y, you can translate this in your head to the function call operator+(x, y) (where operator+ is the name of the function).
Resolving overloaded operators
What are the limitations on operator overloading?
Best practice
When overloading operators, it’s best to keep the function of the operators as close to the original intent of the operators as possible.
Best practice
If the meaning of an overloaded operator is not clear and intuitive, use a named function instead.
14.2 — Overloading the arithmetic operators using friend functions
Overloading operators using friend functions
Overloading the subtraction operator (-) is simple as well:
#include <iostream>
class Cents
{
private:
int m_cents {};
public:
Cents(int cents) : m_cents{ cents } { }
// add Cents + Cents using a friend function
friend Cents operator+(const Cents& c1, const Cents& c2);
// subtract Cents - Cents using a friend function
friend Cents operator-(const Cents& c1, const Cents& c2);
int getCents() const { return m_cents; }
};
// note: this function is not a member function!
Cents operator+(const Cents& c1, const Cents& c2)
{
// use the Cents constructor and operator+(int, int)
// we can access m_cents directly because this is a friend function
return c1.m_cents + c2.m_cents;
}
// note: this function is not a member function!
Cents operator-(const Cents& c1, const Cents& c2)
{
// use the Cents constructor and operator-(int, int)
// we can access m_cents directly because this is a friend function
return c1.m_cents - c2.m_cents;
}
int main()
{
Cents cents1{ 6 };
Cents cents2{ 2 };
Cents centsSum{ cents1 - cents2 };
std::cout << "I have " << centsSum.getCents() << " cents.\n";
return 0;
}
Overloading the multiplication operator () and the division operator (/) is as easy as defining functions for operator and operator/ respectively.
Friend functions can be defined inside the class
Even though friend functions are not members of the class, they can still be defined inside the class if desired:
#include <iostream>
class Cents
{
private:
int m_cents {};
public:
Cents(int cents) : m_cents{ cents } { }
// add Cents + Cents using a friend function
// This function is not considered a member of the class, even though the definition is inside the class
friend Cents operator+(const Cents& c1, const Cents& c2)
{
// use the Cents constructor and operator+(int, int)
// we can access m_cents directly because this is a friend function
return c1.m_cents + c2.m_cents;
}
int getCents() const { return m_cents; }
};
int main()
{
Cents cents1{ 6 };
Cents cents2{ 8 };
Cents centsSum{ cents1 + cents2 };
std::cout << "I have " << centsSum.getCents() << " cents.\n";
return 0;
}
We generally don’t recommend this, as non-trivial function definitions are better kept in a separate .cpp file, outside of the class definition. However, we will use this pattern in future tutorials to keep the examples concise.
Overloading operators for operands of different types
Consequently, whenever we overload binary operators for operands of different types, we actually need to write two functions – one for each case. Here is an example of that:
#include <iostream>
class Cents
{
private:
int m_cents {};
public:
Cents(int cents) : m_cents{ cents } { }
// add Cents + int using a friend function
friend Cents operator+(const Cents& c1, int value);
// add int + Cents using a friend function
friend Cents operator+(int value, const Cents& c1);
int getCents() const { return m_cents; }
};
// note: this function is not a member function!
Cents operator+(const Cents& c1, int value)
{
// use the Cents constructor and operator+(int, int)
// we can access m_cents directly because this is a friend function
return c1.m_cents + value;
}
// note: this function is not a member function!
Cents operator+(int value, const Cents& c1)
{
// use the Cents constructor and operator+(int, int)
// we can access m_cents directly because this is a friend function
return c1.m_cents + value;
}
int main()
{
Cents c1{ Cents{ 4 } + 6 };
Cents c2{ 6 + Cents{ 4 } };
std::cout << "I have " << c1.getCents() << " cents.\n";
std::cout << "I have " << c2.getCents() << " cents.\n";
return 0;
}
Note that both overloaded functions have the same implementation – that’s because they do the same thing, they just take their parameters in a different order.
Another example
In other words, this expression evaluates as “MinMax mFinal = (((((m1 + m2) + 5) + 8) + m3) + 16)”, with each successive operation returning a MinMax object that becomes the left-hand operand for the following operator.
Implementing operators using other operators
In the above example, note that we defined operator+(int, MinMax) by calling operator+(MinMax, int) (which produces the same result). This allows us to reduce the implementation of operator+(int, MinMax) to a single line, making our code easier to maintain by minimizing redundancy and making the function simpler to understand.
It is often possible to define overloaded operators by calling other overloaded operators. You should do so if and when doing so produces simpler code. In cases where the implementation is trivial (e.g. a single line) it may or may not be worth doing this.
14.3 — Overloading operators using normal functions
Best practice
Prefer overloading operators as normal functions instead of friends if it’s possible to do so without adding additional functions.
14.4 — Overloading the I/O operators
Overloading operator<<
Conclusion
Overloading operator<< and operator>> make it extremely easy to output your class to screen and accept user input from the console.
Quiz time
Take the Fraction class we wrote in the previous quiz (listed below) and add an overloaded operator<< and operator>> to it.
#include <iostream>
#include <limits>
#include <numeric> // for std::gcd
class Fraction
{
private:
int m_numerator{ 0 };
int m_denominator{ 1 };
public:
Fraction(int numerator=0, int denominator = 1) :
m_numerator{ numerator }, m_denominator{ denominator }
{
// We put reduce() in the constructor to ensure any new fractions we make get reduced!
// Any fractions that are overwritten will need to be re-reduced
reduce();
}
void reduce()
{
int gcd{ std::gcd(m_numerator, m_denominator) };
if (gcd)
{
m_numerator /= gcd;
m_denominator /= gcd;
}
}
friend Fraction operator*(const Fraction& f1, const Fraction& f2);
friend Fraction operator*(const Fraction& f1, int value);
friend Fraction operator*(int value, const Fraction& f1);
friend std::ostream& operator<<(std::ostream& out, const Fraction& f1);
friend std::istream& operator>>(std::istream& in, Fraction& f1);
void print()
{
std::cout << m_numerator << '/' << m_denominator << '\n';
}
};
Fraction operator*(const Fraction& f1, const Fraction& f2)
{
return { f1.m_numerator * f2.m_numerator, f1.m_denominator * f2.m_denominator };
}
Fraction operator*(const Fraction& f1, int value)
{
return { f1.m_numerator * value, f1.m_denominator };
}
Fraction operator*(int value, const Fraction& f1)
{
return { f1.m_numerator * value, f1.m_denominator };
}
std::ostream& operator<<(std::ostream& out, const Fraction& f1)
{
out << f1.m_numerator << '/' << f1.m_denominator;
return out;
}
std::istream& operator>>(std::istream& in, Fraction& f1)
{
// Overwrite the values of f1
in >> f1.m_numerator;
// Ignore the '/' separator
in.ignore(std::numeric_limits<std::streamsize>::max(), '/');
in >> f1.m_denominator;
// Since we overwrite the existing f1, we need to reduce again
f1.reduce();
return in;
}
int main()
{
Fraction f1;
std::cout << "Enter fraction 1: ";
std::cin >> f1;
Fraction f2;
std::cout << "Enter fraction 2: ";
std::cin >> f2;
std::cout << f1 << " * " << f2 << " is " << f1 * f2 << '\n'; // note: The result of f1 * f2 is an r-value
return 0;
}
14.5 — Overloading operators using member functions
So if we can overload an operator as a friend or a member, which should we use? In order to answer that question, there’s a few more things you’ll need to know.
Not everything can be overloaded as a friend function
The assignment (=), subscript ([]), function call (()), and member selection (->) operators must be overloaded as member functions, because the language requires them to be.
Not everything can be overloaded as a member function
When to use a normal, friend, or member function overload
In most cases, the language leaves it up to you to determine whether you want to use the normal/friend or member function version of the overload. However, one of the two is usually a better choice than the other.
The following rules of thumb can help you determine which form is best for a given situation:
- If you’re overloading assignment (=), subscript ([]), function call (()), or member selection (->), do so as a member function.
- If you’re overloading a unary operator, do so as a member function.
- If you’re overloading a binary operator that does not modify its left operand (e.g. operator+), do so as a normal function (preferred) or friend function.
- If you’re overloading a binary operator that modifies its left operand, but you can’t add members to the class definition of the left operand (e.g. operator<<, which has a left operand of type ostream), do so as a normal function (preferred) or friend function.
- If you’re overloading a binary operator that modifies its left operand (e.g. operator+=), and you can modify the definition of the left operand, do so as a member function.
14.6 — Overloading unary operators +, -, and !
Overloading unary operators
Quiz time
Implement overloaded operator+ for the Point class.
Hide Solution
Here’s the obvious solution:
Point Point::operator+ () const
{
return { m_x, m_y, m_z };
}
But because the Point we’re returning is exactly the same one we’re operating on, the following also works:
Point Point::operator+ () const
{
return *this;
}
Note that we’re returning a copy by value rather than a const reference here. This is because users of this function will probably expect the returned object to be modifiable.
Tip
The unary minus operator returns the operand multiplied by -1. In other words, if x = 5, -x is -5.
The unary plus operator returns the value of the operand. In other words, +5 is 5, and +x is x. Generally you won’t need to use this operator since it’s redundant. It was added largely to provide symmetry with the unary minus operator.
FAQ
The following program doesn’t seem to work for me unless I put -f in between parenthesis (-f).print(); Why?
#include <iostream>
class Fraction
{
private:
int m_num{};
int m_den{};
public:
Fraction(int num, int den = 1) : m_num{ num }, m_den{ den }
{}
void print() const
{
std::cout << m_num << "/" << m_den << '\n';
}
Fraction operator-() const;
};
Fraction Fraction::operator-() const
{
return Fraction{ -m_num, -m_den };
}
int main()
{
const Fraction f{ 2, 5 };
-f.print();
return 0;
}
error: expression must have arithmetic or unscoped enum type.
with the first code in this tutorial, I was able to remove the parentheses (line 26 -nickle) and it worked just fine.
Alex:
Operator. has higher precedence than operator-, so this evaluates as -(f.print()). Since Fraction::print() returns a void, the compiler will complain about an illegal operand on void.
You need the parenthesis to ensure that -f is evaluated first, and then print() invoked on the result.
14.7 — Overloading the comparison operators
Best practice
Only define overloaded operators that make intuitive sense for your class.
However, there is one common exception to the above recommendation. What if we wanted to sort a list of Cars? In such a case, we might want to overload the comparison operators to return the member (or members) you’re most likely to want to sort on. For example, an overloaded operator< for Cars might sort based on make and model alphabetically.
Some of the container classes in the standard library (classes that hold sets of other classes) require an overloaded operator< so they can keep the elements sorted.
Here’s a different example overloading all 6 logical comparison operators:
#include <iostream>
class Cents
{
private:
int m_cents;
public:
Cents(int cents)
: m_cents{ cents }
{}
friend bool operator== (const Cents& c1, const Cents& c2);
friend bool operator!= (const Cents& c1, const Cents& c2);
friend bool operator< (const Cents& c1, const Cents& c2);
friend bool operator> (const Cents& c1, const Cents& c2);
friend bool operator<= (const Cents& c1, const Cents& c2);
friend bool operator>= (const Cents& c1, const Cents& c2);
};
bool operator== (const Cents& c1, const Cents& c2)
{
return c1.m_cents == c2.m_cents;
}
bool operator!= (const Cents& c1, const Cents& c2)
{
return c1.m_cents != c2.m_cents;
}
bool operator< (const Cents& c1, const Cents& c2)
{
return c1.m_cents < c2.m_cents;
}
bool operator> (const Cents& c1, const Cents& c2)
{
return c1.m_cents > c2.m_cents;
}
bool operator<= (const Cents& c1, const Cents& c2)
{
return c1.m_cents <= c2.m_cents;
}
bool operator>= (const Cents& c1, const Cents& c2)
{
return c1.m_cents >= c2.m_cents;
}
int main()
{
Cents dime{ 10 };
Cents nickel{ 5 };
if (nickel > dime)
std::cout << "a nickel is greater than a dime.\n";
if (nickel >= dime)
std::cout << "a nickel is greater than or equal to a dime.\n";
if (nickel < dime)
std::cout << "a dime is greater than a nickel.\n";
if (nickel <= dime)
std::cout << "a dime is greater than or equal to a nickel.\n";
if (nickel == dime)
std::cout << "a dime is equal to a nickel.\n";
if (nickel != dime)
std::cout << "a dime is not equal to a nickel.\n";
return 0;
}
This is also pretty straightforward.
Minimizing comparative redundancy
#include <iostream>
class Cents
{
private:
int m_cents;
public:
Cents(int cents)
: m_cents{ cents }
{}
friend bool operator== (const Cents& c1, const Cents& c2) { return c1.m_cents == c2.m_cents; };
friend bool operator!= (const Cents& c1, const Cents& c2) { return !(operator==(c1, c2)); };
friend bool operator< (const Cents& c1, const Cents& c2) { return c1.m_cents < c2.m_cents; };
friend bool operator> (const Cents& c1, const Cents& c2) { return operator<(c2, c1); };
friend bool operator<= (const Cents& c1, const Cents& c2) { return !(operator>(c1, c2)); };
friend bool operator>= (const Cents& c1, const Cents& c2) { return !(operator<(c1, c2)); };
};
int main()
{
Cents dime{ 10 };
Cents nickel{ 5 };
if (nickel > dime)
std::cout << "a nickel is greater than a dime.\n";
if (nickel >= dime)
std::cout << "a nickel is greater than or equal to a dime.\n";
if (nickel < dime)
std::cout << "a dime is greater than a nickel.\n";
if (nickel <= dime)
std::cout << "a dime is greater than or equal to a nickel.\n";
if (nickel == dime)
std::cout << "a dime is equal to a nickel.\n";
if (nickel != dime)
std::cout << "a dime is not equal to a nickel.\n";
return 0;
}
This way, if we ever need to change something, we only need to update operator== and operator< instead of all six comparison operators!
The spaceship operator <=> C++20
C++20 introduces the spaceship operator (operator<=>), which allows us to reduce the number of comparison functions we need to write down to 2 at most, and sometimes just 1!
Author’s note
We intend to add a new lesson on this topic soon. Until then, consider this something to pique your interest – but you’ll have to go off-site to discover more.
14.8 — Overloading the increment and decrement operators
Overloading prefix increment and decrement
Prefix increment and decrement are overloaded exactly the same as any normal unary operator. We’ll do this one by example:
#include <iostream>
class Digit
{
private:
int m_digit;
public:
Digit(int digit=0)
: m_digit{digit}
{
}
Digit& operator++();
Digit& operator--();
friend std::ostream& operator<< (std::ostream& out, const Digit& d);
};
Digit& Digit::operator++()
{
// If our number is already at 9, wrap around to 0
if (m_digit == 9)
m_digit = 0;
// otherwise just increment to next number
else
++m_digit;
return *this;
}
Digit& Digit::operator--()
{
// If our number is already at 0, wrap around to 9
if (m_digit == 0)
m_digit = 9;
// otherwise just decrement to next number
else
--m_digit;
return *this;
}
std::ostream& operator<< (std::ostream& out, const Digit& d)
{
out << d.m_digit;
return out;
}
int main()
{
Digit digit(8);
std::cout << digit;
std::cout << ++digit;
std::cout << ++digit;
std::cout << --digit;
std::cout << --digit;
return 0;
}
Overloading postfix increment and decrement
Normally, functions can be overloaded when they have the same name but a different number and/or different type of parameters. However, consider the case of the prefix and postfix increment and decrement operators. Both have the same name (eg. operator++), are unary, and take one parameter of the same type. So how it is possible to differentiate the two when overloading?
The C++ language specification has a special case that provides the answer: the compiler looks to see if the overloaded operator has an int parameter. If the overloaded operator has an int parameter, the operator is a postfix overload. If the overloaded operator has no parameter, the operator is a prefix overload.
Here is the above Digit class with both prefix and postfix overloads:
class Digit
{
private:
int m_digit;
public:
Digit(int digit=0)
: m_digit{digit}
{
}
Digit& operator++(); // prefix has no parameter
Digit& operator--(); // prefix has no parameter
Digit operator++(int); // postfix has an int parameter
Digit operator--(int); // postfix has an int parameter
friend std::ostream& operator<< (std::ostream& out, const Digit& d);
};
// No parameter means this is prefix operator++
Digit& Digit::operator++()
{
// If our number is already at 9, wrap around to 0
if (m_digit == 9)
m_digit = 0;
// otherwise just increment to next number
else
++m_digit;
return *this;
}
// No parameter means this is prefix operator--
Digit& Digit::operator--()
{
// If our number is already at 0, wrap around to 9
if (m_digit == 0)
m_digit = 9;
// otherwise just decrement to next number
else
--m_digit;
return *this;
}
// int parameter means this is postfix operator++
Digit Digit::operator++(int)
{
// Create a temporary variable with our current digit
Digit temp{*this};
// Use prefix operator to increment this digit
++(*this); // apply operator
// return temporary result
return temp; // return saved state
}
// int parameter means this is postfix operator--
Digit Digit::operator--(int)
{
// Create a temporary variable with our current digit
Digit temp{*this};
// Use prefix operator to decrement this digit
--(*this); // apply operator
// return temporary result
return temp; // return saved state
}
std::ostream& operator<< (std::ostream& out, const Digit& d)
{
out << d.m_digit;
return out;
}
int main()
{
Digit digit(5);
std::cout << digit;
std::cout << ++digit; // calls Digit::operator++();
std::cout << digit++; // calls Digit::operator++(int);
std::cout << digit;
std::cout << --digit; // calls Digit::operator--();
std::cout << digit--; // calls Digit::operator--(int);
std::cout << digit;
return 0;
}
This prints
5667665
There are a few interesting things going on here. First, note that we’ve distinguished the prefix from the postfix operators by providing an integer dummy parameter on the postfix version. Second, because the dummy parameter is not used in the function implementation, we have not even given it a name. This tells the compiler to treat this variable as a placeholder, which means it won’t warn us that we declared a variable but never used it.
Third, note that the prefix and postfix operators do the same job – they both increment or decrement the object. The difference between the two is in the value they return. The overloaded prefix operators return the object after it has been incremented or decremented. Consequently, overloading these is fairly straightforward. We simply increment or decrement our member variables, and then return *this.
The postfix operators, on the other hand, need to return the state of the object before it is incremented or decremented. This leads to a bit of a conundrum – if we increment or decrement the object, we won’t be able to return the state of the object before it was incremented or decremented. On the other hand, if we return the state of the object before we increment or decrement it, the increment or decrement will never be called.
The typical way this problem is solved is to use a temporary variable that holds the value of the object before it is incremented or decremented. Then the object itself can be incremented or decremented. And finally, the temporary variable is returned to the caller. In this way, the caller receives a copy of the object before it was incremented or decremented, but the object itself is incremented or decremented. Note that this means the return value of the overloaded operator must be a non-reference, because we can’t return a reference to a local variable that will be destroyed when the function exits. Also note that this means the postfix operators are typically less efficient than the prefix operators because of the added overhead of instantiating a temporary variable and returning by value instead of reference.
Finally, note that we’ve written the post-increment and post-decrement in such a way that it calls the pre-increment and pre-decrement to do most of the work. This cuts down on duplicate code, and makes our class easier to modify in the future.
14.9 — Overloading the subscript operator
Overloading operator[]
This is both easy syntactically and from a comprehension standpoint. When list[2] evaluates, the compiler first checks to see if there’s an overloaded operator[] function. If so, it passes the value inside the hard braces (in this case, 2) as an argument to the function.
Note that although you can provide a default value for the function parameter, actually using operator[] without a subscript inside is not considered a valid syntax, so there’s no point.
Tip
C++23 will add support for overloading operator[] with multiple subscripts.
Why operator[] returns a reference
Consider what would happen if operator[] returned an integer by value instead of by reference. list[2] would call operator[], which would return the value of list.m_list[2]. For example, if m_list[2] had the value of 6, operator[] would return the value 6. list[2] = 3 would partially evaluate to 6 = 3, which makes no sense! If you try to do this, the C++ compiler will complain:
C:VCProjectsTest.cpp(386) : error C2106: '=' : left operand must be l-value
Dealing with const objects
#include <iostream>
class IntList
{
private:
int m_list[10]{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; // give this class some initial state for this example
public:
int& operator[] (int index);
int operator[] (int index) const; // could also return const int& if returning a non-fundamental type
};
int& IntList::operator[] (int index) // for non-const objects: can be used for assignment
{
return m_list[index];
}
int IntList::operator[] (int index) const // for const objects: can only be used for access
{
return m_list[index];
}
int main()
{
IntList list{};
list[2] = 3; // okay: calls non-const version of operator[]
std::cout << list[2] << '\n';
const IntList clist{};
clist[2] = 3; // compile error: calls const version of operator[], which returns by value. Cannot assign to this because it is an rvalue.
std::cout << clist[2] << '\n';
return 0;
}
If we comment out the line clist[2] = 3, the above program compiles and executes as expected.
Error checking
One other advantage of overloading the subscript operator is that we can make it safer than accessing arrays directly. Normally, when accessing arrays, the subscript operator does not check whether the index is valid. For example, the compiler will not complain about the following code:
int list[5]{};
list[7] = 3; // index 7 is out of bounds!
However, if we know the size of our array, we can make our overloaded subscript operator check to ensure the index is within bounds:
#include <cassert> // for assert()
#include <iterator> // for std::size()
class IntList
{
private:
int m_list[10]{};
public:
int& operator[] (int index);
};
int& IntList::operator[] (int index)
{
assert(index >= 0 && index < std::size(m_list));
return m_list[index];
}
In the above example, we have used the assert() function (included in the cassert header) to make sure our index is valid. If the expression inside the assert evaluates to false (which means the user passed in an invalid index), the program will terminate with an error message, which is much better than the alternative (corrupting memory). This is probably the most common method of doing error checking of this sort.
Pointers to objects and overloaded operator[] don’t mix
If you try to call operator[] on a pointer to an object, C++ will assume you’re trying to index an array of objects of that type.
Consider the following example:
#include <cassert> // for assert()
#include <iterator> // for std::size()
class IntList
{
private:
int m_list[10]{};
public:
int& operator[] (int index);
};
int& IntList::operator[] (int index)
{
assert(index >= 0 && index < std::size(m_list));
return m_list[index];
}
int main()
{
IntList* list{ new IntList{} };
list [2] = 3; // error: this will assume we're accessing index 2 of an array of IntLists
delete list;
return 0;
}
Because we can’t assign an integer to an IntList, this won’t compile. However, if assigning an integer was valid, this would compile and run, with undefined results.
Rule
Make sure you’re not trying to call an overloaded operator[] on a pointer to an object.
The proper syntax would be to dereference the pointer first (making sure to use parenthesis since operator[] has higher precedence than operator*), then call operator[]:
int main()
{
IntList* list{ new IntList{} };
(*list)[2] = 3; // get our IntList object, then call overloaded operator[]
delete list;
return 0;
}
This is ugly and error prone. Better yet, don’t set pointers to your objects if you don’t have to.
The function parameter does not need to be an integer
As mentioned above, C++ passes what the user types between the hard braces as an argument to the overloaded function. In most cases, this will be an integer value. However, this is not required – and in fact, you can define that your overloaded operator[] take a value of any type you desire. You could define your overloaded operator[] to take a double, a std::string, or whatever else you like.
As a ridiculous example, just so you can see that it works:
#include <iostream>
#include <string_view> // C++17
class Stupid
{
private:
public:
void operator[] (std::string_view index);
};
// It doesn't make sense to overload operator[] to print something
// but it is the easiest way to show that the function parameter can be a non-integer
void Stupid::operator[] (std::string_view index)
{
std::cout << index;
}
int main()
{
Stupid stupid{};
stupid["Hello, world!"];
return 0;
}
As you would expect, this prints:
Hello, world!
Overloading operator[] to take a std::string parameter can be useful when writing certain kinds of classes, such as those that use words as indices.
Conclusion
The subscript operator is typically overloaded to provide direct access to individual elements from an array (or other similar structure) contained within a class. Because strings are often implemented as arrays of characters, operator[] is often implemented in string classes to allow the user to access a single character of the string.
Quiz time
Question #1
Tip
Since maps are common, the standard library offers std::map, which is not currently covered on learncpp. Using std::map, we can simplify our code to
#include <iostream>
#include <map> // std::map
#include <string>
int main()
{
// std::map can be initialized
std::map<std::string, char> grades{
{ "Joe", 'A' },
{ "Frank", 'B' }
};
// and assigned
grades["Susan"] = 'C';
grades["Tom"] = 'D';
std::cout << "Joe has a grade of " << grades["Joe"] << '\n';
std::cout << "Frank has a grade of " << grades["Frank"] << '\n';
return 0;
}
Prefer using std::map over writing your own implementation.
Question #3
Extra credit #2: Why does this program potentially not work as expected?
#include <iostream>
int main()
{
GradeMap grades{};
char& gradeJoe{ grades["Joe"] }; // does a push_back
gradeJoe = 'A';
char& gradeFrank{ grades["Frank"] }; // does a push_back
gradeFrank = 'B';
std::cout << "Joe has a grade of " << gradeJoe << '\n';
std::cout << "Frank has a grade of " << gradeFrank << '\n';
return 0;
}
Hide Solution
When Frank is added, the std::vector may need to grow to hold it. This requires dynamically allocating a new block of memory, copying the elements in the array to that new block, and deleting the old block. When this happens, any references to existing elements in the std::vector are invalidated (meaning they are left as dangling references to deleted memory).
In other words, after we push_back(“Frank”), if the std::vector had to grow to make room for Frank, the gradeJoe reference would be invalidated. Accessing gradeJoe to print Joe’s grade would then lead to undefined results.
How a std::vector grows is a compiler-specific detail, so we can expect the above program to work fine when compiled with some compilers and not others.
14.10 — Overloading the parenthesis operator
An example
Now, let’s overload the () operator again, this time in a way that takes no parameters at all:
#include <cassert> // for assert()
class Matrix
{
private:
double m_data[4][4]{};
public:
double& operator()(int row, int col);
double operator()(int row, int col) const;
void operator()();
};
double& Matrix::operator()(int row, int col)
{
assert(col >= 0 && col < 4);
assert(row >= 0 && row < 4);
return m_data[row][col];
}
double Matrix::operator()(int row, int col) const
{
assert(col >= 0 && col < 4);
assert(row >= 0 && row < 4);
return m_data[row][col];
}
void Matrix::operator()()
{
// reset all elements of the matrix to 0.0
for (int row{ 0 }; row < 4; ++row)
{
for (int col{ 0 }; col < 4; ++col)
{
m_data[row][col] = 0.0;
}
}
}
And here’s our new example:
#include <iostream>
int main()
{
Matrix matrix{};
matrix(1, 2) = 4.5;
matrix(); // erase matrix
std::cout << matrix(1, 2) << '\n';
return 0;
}
which produces the result:
0
Because the () operator is so flexible, it can be tempting to use it for many different purposes. However, this is strongly discouraged, since the () symbol does not really give any indication of what the operator is doing. In our example above, it would be better to have written the erase functionality as a function called clear() or erase(), as matrix.erase() is easier to understand than matrix() (which could do anything!).
Having fun with functors
Operator() is also commonly overloaded to implement functors (or function object), which are classes that operate like functions. The advantage of a functor over a normal function is that functors can store data in member variables (since they are classes).
Here’s a simple functor:
#include <iostream>
class Accumulator
{
private:
int m_counter{ 0 };
public:
int operator() (int i) { return (m_counter += i); }
};
int main()
{
Accumulator acc{};
std::cout << acc(10) << '\n'; // prints 10
std::cout << acc(20) << '\n'; // prints 30
return 0;
}
Note that using our Accumulator looks just like making a normal function call, but our Accumulator object is storing an accumulated value.
You may wonder why we couldn’t do the same thing with a normal function and a static local variable to preserve data between function calls. We could, but because functions only have one global instance, we’d be limited to using it for one thing at a time. With functors, we can instantiate as many separate functor objects as we need and use them all simultaneously.
Conclusion
Operator() is sometimes overloaded with two parameters to index multidimensional arrays, or to retrieve a subset of a one dimensional array (with the two parameters defining the subset to return). Anything else is probably better written as a member function with a more descriptive name.
Operator() is also often overloaded to create functors. Although simple functors (such as the example above) are fairly easily understood, functors are typically used in more advanced programming topics, and deserve their own lesson.
Quiz time
Question #3
Extra credit: Implement a member function named substr that returns the same substring as a std::string_view.
#include <cassert>
#include <iostream>
#include <string>
#include <string_view>
class MyString
{
private:
std::string m_string{};
public:
MyString(const std::string& string = {})
:m_string{ string }
{
}
MyString operator()(int start, int length)
{
assert(start >= 0);
assert(start + length <= static_cast<int>(m_string.length()) && "MyString::operator(int, int): Substring is out of range");
return m_string.substr(start, length);
}
std::string_view substr(int start, int length)
{
assert(start >= 0);
assert(start + length <= static_cast<int>(m_string.length()) && "MyString::substr(int, int): Substring is out of range");
return std::string_view{ m_string }.substr(start, length);
}
friend std::ostream& operator<<(std::ostream& out, const MyString& s)
{
out << s.m_string;
return out;
}
};
int main()
{
MyString s { "Hello, world!" };
std::cout << s.substr(7, 5) << '\n'; // start at index 7 and return 5 characters
return 0;
}
Let’s explore return std::string_view{ m_string }.substr(start, length); further. First, we’re creating a temporary std::string_view of m_string, which is inexpensive and lets us access std::string_view member functions. Next, we call std::string_view::substr on this temporary to get our substring (as a non-null-terminated view of m_string). We then return this view to the caller. Since the std::string_view we return to the caller is still a view of m_string, it is not dangling.
The end result is we create 3 std::string_view instead of 3 std::string, which is more efficient.
14.11 — Overloading typecasts
User-defined conversions allow us to convert our class into another data type.
class Cents
{
private:
int m_cents;
public:
Cents(int cents=0)
: m_cents{ cents }
{
}
// Overloaded int cast
operator int() const { return m_cents; }
int getCents() const { return m_cents; }
void setCents(int cents) { m_cents = cents; }
};
There are three things to note:
- To overload the function that casts our class to an int, we write a new function in our class called operator int(). Note that there is a space between the word operator and the type we are casting to. Such functions must be non-static members.
- User-defined conversions do not take parameters, as there is no way to pass arguments to them.
- User-defined conversions do not have a return type. C++ assumes you will be returning the correct type.
We can now also explicitly cast our Cents variable to an int:
Cents cents{ 7 };
int c{ static_cast<int>(cents) };
You can provide user-defined conversions for any data type you wish, including your own user-defined data types!
Converting constructors vs overloaded typecasts
Overloaded typecasts and converting constructors perform similar roles: an overloaded typecast allows us to define a function that converts some program-defined type A into some other type B. A converting constructor allows us to define a function that creates some program-defined type A from some other type B. So when should you use each?
In general, a converting constructor should be preferred to an overloaded typecast, as it allows the type being constructed to own the construction.
There are a few cases where an overloaded typecast should be used instead:
- When providing a conversion to a fundamental type (since you can’t define constructors for these types). Most idiomatically, these are used to provide a conversion to bool for cases where it makes sense to be able to use an object in a conditional statement.
- When providing a conversion to a type you can’t add members to (e.g. a conversion to std::vector, since you can’t define constructors for these types either).
- When you do not want the type being constructed to be aware of the type being converted to. This can be helpful for avoiding circular dependencies. For example, std::string provides an overloaded typecast to std::string_view so that std::string_view doesn’t have to #include .
14.12 — The copy constructor
Recapping the types of initialization
Since we’re going to talk a lot about initialization in the next few lessons, let’s first recap the types of initialization that C++ supports: direct (parenthesis) initialization, uniform (brace) initialization or copy (equals) initialization.
The copy constructor
A copy constructor is a special type of constructor used to create a new object as a copy of an existing object (of the same type).
The copy constructor’s parameter must be a reference
It is a requirement that the parameter of a copy constructor be a (const) reference. This makes sense: if the argument were passed by value, then we’d need the copy constructor to copy the argument into the parameter of the copy constructor (which would result in an infinite recursion).
Preventing copies
We can prevent copies of our classes from being made by making the copy constructor private:
#include <cassert>
#include <iostream>
class Fraction
{
private:
int m_numerator{};
int m_denominator{};
// Copy constructor (private)
Fraction(const Fraction& fraction)
: m_numerator{fraction.m_numerator}, m_denominator{fraction.m_denominator}
{
// no need to check for a denominator of 0 here since fraction must already be a valid Fraction
std::cout << "Copy constructor called\n"; // just to prove it works
}
public:
// Default constructor
Fraction(int numerator=0, int denominator=1)
: m_numerator{numerator}, m_denominator{denominator}
{
assert(denominator != 0);
}
friend std::ostream& operator<<(std::ostream& out, const Fraction& f1);
};
std::ostream& operator<<(std::ostream& out, const Fraction& f1)
{
out << f1.m_numerator << '/' << f1.m_denominator;
return out;
}
int main()
{
Fraction fiveThirds { 5, 3 }; // Direct initialize a Fraction, calls Fraction(int, int) constructor
Fraction fCopy { fiveThirds }; // Copy constructor is private, compile error on this line
std::cout << fCopy << '\n';
}
Now when we try to compile our program, we’ll get a compile error since fCopy needs to use the copy constructor, but can not see it since the copy constructor has been declared as private.
The copy constructor may be elided
Why didn’t our copy constructor get called?
Note that initializing an anonymous object and then using that object to direct initialize our defined object takes two steps (one to create the anonymous object, one to call the copy constructor). However, the end result of initializing our defined object is essentially identical to just doing a direct initialization, which only takes one step.
For this reason, in such cases, the compiler is allowed to opt out of calling the copy constructor and just do a direct initialization instead. The process of omitting certain copy (or move) steps for performance purposes is called elision.
So although you wrote:
Fraction fiveThirds { Fraction{ 5, 3 } };
The compiler may change this to:
Fraction fiveThirds{ 5, 3 };
which only requires one constructor call (to Fraction(int, int)). Note that in cases where elision is used, any statements in the body of the copy constructor are not executed, even if they would have produced side effects (like printing to the screen)!
The rule of three and the rule of zero
The rule of three is a well known C++ principle that states that if a class requires a user-defined destructor, copy constructor, or copy assignment operator, then it probably requires all three. Not following the rule of three is likely to lead to malfunctioning code.
The rule of zero states, “Classes that have custom destructors, copy/move constructors or copy/move assignment operators should deal exclusively with ownership. Other classes should not have custom destructors, copy/move constructors or copy/move assignment operators.” (cite). In this context, “custom” means “user-defined”.
The best way to avoid having to implement these special functions is to use existing types that already support copy semantics (aka. not raw pointers). That way, the compiler-generated defaults for these special functions will behave as expected.
14.13 — Copy initialization
Copy initialization for classes
Best practice
Avoid using copy initialization, and use uniform initialization instead.
Other places copy initialization is used
There are a few other places copy initialization is used, but two of them are worth mentioning explicitly. When you pass or return a class by value, that process uses copy initialization.
Consider:
#include <cassert>
#include <iostream>
class Fraction
{
private:
int m_numerator;
int m_denominator;
public:
// Default constructor
Fraction(int numerator=0, int denominator=1)
: m_numerator(numerator), m_denominator(denominator)
{
assert(denominator != 0);
}
// Copy constructor
Fraction(const Fraction& copy) :
m_numerator(copy.m_numerator), m_denominator(copy.m_denominator)
{
// no need to check for a denominator of 0 here since copy must already be a valid Fraction
std::cout << "Copy constructor called\n"; // just to prove it works
}
friend std::ostream& operator<<(std::ostream& out, const Fraction& f1);
int getNumerator() { return m_numerator; }
void setNumerator(int numerator) { m_numerator = numerator; }
};
std::ostream& operator<<(std::ostream& out, const Fraction& f1)
{
out << f1.m_numerator << '/' << f1.m_denominator;
return out;
}
Fraction makeNegative(Fraction f) // ideally we should do this by const reference
{
f.setNumerator(-f.getNumerator());
return f;
}
int main()
{
Fraction fiveThirds(5, 3);
std::cout << makeNegative(fiveThirds);
return 0;
}
In the above program, function makeNegative takes a Fraction by value and also returns a Fraction by value. When we run this program, we get:
Copy constructor called
Copy constructor called
-5/3
The first copy constructor call happens when fiveThirds is passed as an argument into makeNegative() parameter f. The second call happens when the return value from makeNegative() is passed back to main().
14.14 — Converting constructors, explicit, and delete
Constructors eligible to be used for implicit conversions are called converting constructors (or conversion constructors).
The explicit keyword
Best practice
Consider making your constructors and user-defined conversion member functions explicit to prevent implicit conversion errors.
The delete keyword
14.15 — Overloading the assignment operator
The copy assignment operator (operator=) is used to copy values from one object to another already existing object.
Copy assignment vs Copy constructor
The purpose of the copy constructor and the copy assignment operator are almost equivalent – both copy one object to another. However, the copy constructor initializes new objects, whereas the assignment operator replaces the contents of existing objects.
The difference between the copy constructor and the copy assignment operator causes a lot of confusion for new programmers, but it’s really not all that difficult. Summarizing:
- If a new object has to be created before the copying can occur, the copy constructor is used (note: this includes passing or returning objects by value).
- If a new object does not have to be created before the copying can occur, the assignment operator is used.
Overloading the assignment operator
Overloading the copy assignment operator (operator=) is fairly straightforward, with one specific caveat that we’ll get to. The copy assignment operator must be overloaded as a member function.
Issues due to self-assignment
Consider what happens in the overloaded operator= when the implicit object AND the passed in parameter (str) are both variable alex. In this case, m_data is the same as str.m_data. The first thing that happens is that the function checks to see if the implicit object already has a string. If so, it needs to delete it, so we don’t end up with a memory leak. In this case, m_data is allocated, so the function deletes m_data. But because str is the same as *this, the string that we wanted to copy has been deleted and m_data (and str.m_data) are dangling.
Later on, we allocate new memory to m_data (and str.m_data). So when we subsequently copy the data from str.m_data into m_data, we’re copying garbage, because str.m_data was never initialized.
Detecting and handling self-assignment
Fortunately, we can detect when self-assignment occurs. Here’s an updated implementation of our overloaded operator= for the MyString class:
MyString& MyString::operator= (const MyString& str)
{
// self-assignment check
if (this == &str)
return *this;
// if data exists in the current string, delete it
if (m_data) delete[] m_data;
m_length = str.m_length;
m_data = nullptr;
// copy the data from str to the implicit object
if (m_length)
m_data = new char[str.m_length];
for (int i { 0 }; i < str.m_length; ++i)
m_data[i] = str.m_data[i];
// return the existing object so we can chain this operator
return *this;
}
By checking if the address of our implicit object is the same as the address of the object being passed in as a parameter, we can have our assignment operator just return immediately without doing any other work.
Because this is just a pointer comparison, it should be fast, and does not require operator== to be overloaded.
When not to handle self-assignment
The copy and swap idiom
Default copy assignment operator
Unlike other operators, the compiler will provide a default public copy assignment operator for your class if you do not provide one. This assignment operator does memberwise assignment (which is essentially the same as the memberwise initialization that default copy constructors do).
Just like other constructors and operators, you can prevent assignments from being made by making your copy assignment operator private or using the delete keyword:
#include <cassert>
#include <iostream>
class Fraction
{
private:
int m_numerator { 0 };
int m_denominator { 1 };
public:
// Default constructor
Fraction(int numerator = 0, int denominator = 1)
: m_numerator { numerator }, m_denominator { denominator }
{
assert(denominator != 0);
}
// Copy constructor
Fraction(const Fraction ©) = delete;
// Overloaded assignment
Fraction& operator= (const Fraction& fraction) = delete; // no copies through assignment!
friend std::ostream& operator<<(std::ostream& out, const Fraction& f1);
};
std::ostream& operator<<(std::ostream& out, const Fraction& f1)
{
out << f1.m_numerator << '/' << f1.m_denominator;
return out;
}
int main()
{
Fraction fiveThirds { 5, 3 };
Fraction f;
f = fiveThirds; // compile error, operator= has been deleted
std::cout << f;
return 0;
}
14.16 — Shallow vs. deep copying
Shallow copying
Because C++ does not know much about your class, the default copy constructor and default assignment operators it provides use a copying method known as a memberwise copy (also known as a shallow copy).
However, when designing classes that handle dynamically allocated memory, memberwise (shallow) copying can get us in a lot of trouble! This is because shallow copies of a pointer just copy the address of the pointer – it does not allocate any memory or copy the contents being pointed to!
#include <cstring> // for strlen()
#include <cassert> // for assert()
class MyString
{
private:
char* m_data{};
int m_length{};
public:
MyString(const char* source = "" )
{
assert(source); // make sure source isn't a null string
// Find the length of the string
// Plus one character for a terminator
m_length = std::strlen(source) + 1;
// Allocate a buffer equal to this length
m_data = new char[m_length];
// Copy the parameter string into our internal buffer
for (int i{ 0 }; i < m_length; ++i)
m_data[i] = source[i];
}
~MyString() // destructor
{
// We need to deallocate our string
delete[] m_data;
}
char* getString() { return m_data; }
int getLength() { return m_length; }
};
int main()
{
MyString hello{ "Hello, world!" };
{
MyString copy{ hello }; // use default copy constructor
} // copy is a local variable, so it gets destroyed here. The destructor deletes copy's string, which leaves hello with a dangling pointer
std::cout << hello.getString() << '\n'; // this will have undefined behavior
return 0;
}
The root of this problem is the shallow copy done by the copy constructor – doing a shallow copy on pointer values in a copy constructor or overloaded assignment operator is almost always asking for trouble.
Deep copying
One answer to this problem is to do a deep copy on any non-null pointers being copied. A deep copy allocates memory for the copy and then copies the actual value, so that the copy lives in distinct memory from the source. This way, the copy and source are distinct and will not affect each other in any way. Doing deep copies requires that we write our own copy constructors and overloaded assignment operators.
A better solution
Classes in the standard library that deal with dynamic memory, such as std::string and std::vector, handle all of their memory management, and have overloaded copy constructors and assignment operators that do proper deep copying. So instead of doing your own memory management, you can just initialize or assign them like normal fundamental variables! That makes these classes simpler to use, less error-prone, and you don’t have to spend time writing your own overloaded functions!
Summary
The default copy constructor and default assignment operators do shallow copies, which is fine for classes that contain no dynamically allocated variables.
Classes with dynamically allocated variables need to have a copy constructor and assignment operator that do a deep copy.
Favor using classes in the standard library over doing your own memory management.
1842
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
