Keep Custom Operations Predictable
Keep Custom Operations Predictable
An overloaded operator supplies behavior for a user-defined type.
A subject-total value can support addition when that meaning stays close to ordinary arithmetic.
Before this lesson, review Define a Required Capability when needed.
What you’ll learn
- Use operator overloading to keep Custom Operations Predictable.
- Explain how the complete example produces 75.
- Make the practice change and explain why the result changes or stays the same.
Follow a complete C++ example
A subject-total value can support addition when that meaning stays close to ordinary arithmetic.
Read the declarations above main before tracing its statements. Each declared name supplies the value, type or operation used later. The std:: prefix selects a name from the standard library, and cout << sends a value to the output stream.
C++17 · main.cpp · complete program
#include <iostream>
struct Score {
int value;
}
;
Score operator+(Score first, Score second) {
return Score {
first.value + second.value
}
;
}
int main() {
Score first {
35
}
;
Score second {
40
}
;
Score total = first + second;
std::cout << total.value << '\n';
return 0;
}
Expected output
75Connect the code to its result
C++17 · source used in this explanation
#include <iostream>
struct Score {
int value;
}
;
Score operator+(Score first, Score second) {
return Score {
first.value + second.value
}
;
}
int main() {
Score first {
35
}
;
Score second {
40
}
;
Score total = first + second;
std::cout << total.value << '\n';
return 0;
}
Expected output
75An overloaded operator supplies behavior for a user-defined type. A subject-total value can support addition when that meaning stays close to ordinary arithmetic.
Trace the result: Read the complete program below from its starting values to the output operations. Each std::cout statement displays the value supplied at that point; \n begins the next line. The resulting lines, in order, are 75. In this example, distinguish what the program calculates or changes from what it actually displays.
Important mistakes and boundaries
Operator overloading cannot change precedence or invent arbitrary new operators. Avoid surprising mutations in operations users expect to be value-like.
Change the school example
C++17 · edit this complete example
#include <iostream>
struct Score {
int value;
}
;
Score operator+(Score first, Score second) {
return Score {
first.value + second.value
}
;
}
int main() {
Score first {
35
}
;
Score second {
40
}
;
Score total = first + second;
std::cout << total.value << '\n';
return 0;
}
Your task: Use 40 and 45. Before running your edited program, predict the new output and explain which stored value, condition or object changes. Keep the rest of the example intact.
Use the complete source repeated here; this task does not depend on remembering code from another section.
Worked answer and reasoning
Worked variation: Use 40 and 45. The combined score is 85.
An overloaded operator supplies behavior for a user-defined type. A subject-total value can support addition when that meaning stays close to ordinary arithmetic.
Operator overloading cannot change precedence or invent arbitrary new operators. Avoid surprising mutations in operations users expect to be value-like.
For a baseline run, save this source as main.cpp and use clang++ -std=c++17 -Wall -Wextra -pedantic main.cpp -o school, or equivalent g++ flags. Recompile after editing so that you run the updated executable.
The source and output below belong to the edited program. Compare them with the original example to see the consequence of this single change.
C++17 · worked variation · complete program
#include <iostream>
struct Score {
int value;
}
;
Score operator+(Score first, Score second) {
return Score {
first.value + second.value
}
;
}
int main() {
Score first {
40
}
;
Score second {
45
}
;
Score total = first + second;
std::cout << total.value << '\n';
return 0;
}
Expected output
85Check your understanding
C++17 · original program for this question
#include <iostream>
struct Score {
int value;
}
;
Score operator+(Score first, Score second) {
return Score {
first.value + second.value
}
;
}
int main() {
Score first {
35
}
;
Score second {
40
}
;
Score total = first + second;
std::cout << total.value << '\n';
return 0;
}
What to remember
An overloaded operator supplies behavior for a user-defined type. Operator overloading cannot change precedence or invent arbitrary new operators. Avoid surprising mutations in operations users expect to be value-like.
Useful connections: Define a Required Capability, Give a Task a Name.
Language and design guidance: C++ Core Guidelines and C++ working draft. The draft describes an evolving language; these examples deliberately target C++17.
Reaching the recap and completing the quizzes are separate milestones.