9.x — Chapter 9 comprehensive quiz

In this chapter, we explored topics related to operator overloading, as well as overloaded typecasts, and topics related to the copy constructor.


Operator overloading is a variant of function overloading that lets you overload operators for your classes. When operators are overloaded, the intent of the operators should be kept as close to the original intent of the operators as possible. If the meaning of an operator when applied to a custom class is not clear and intuitive, use a named function instead.

Operators can be overloaded as a normal function, a friend function, or a member function. 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 modifies its left operand (e.g. operator+=), do so as a member function if you can.
  • If you’re overloading a binary operator that does not modify its left operand (e.g. operator+), do so as a normal function or friend function.

Typecasts can be overloaded to provide conversion functions, which can be used to explicitly or implicitly convert your class into another type.

A copy constructor is a special type of constructor used to initialize an object from another object of the same type. Copy constructors are used for direct/uniform initialization from an object of the same type, copy initialization (Fraction f = Fraction(5,3)), and when passing or returning a parameter by value.

If you do not supply a copy constructor, the compiler will create one for you. Compiler-provided copy constructors will use memberwise initialization, meaning each member of the copy is initialized from the original member. The copy constructor may be elided for optimization purposes, even if it has side-effects, so do not rely on your copy constructor actually executing.

Constructors are considered converting constructors by default, meaning that the compiler will use them to implicitly convert objects of other types into objects of your class. You can avoid this by using the explicit keyword in front of your constructor. You can also delete functions within your class, including the copy constructor and overloaded assignment operator if desired. This will cause a compiler error if a deleted function would be called.

The assignment operator can be overloaded to allow assignment to your class. If you do not provide an overloaded assignment operator, the compiler will create one for you. Overloaded assignment operators should always include a self-assignment check.

New programmers often mix up when the assignment operator vs copy constructor are used, but it’s fairly straightforward:

  • 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.

By default, the copy constructor and assignment operators provided by the compiler do a memberwise initialization or assignment, which is a shallow copy. If your class dynamically allocates memory, this will likely lead to problems, as multiple objects will end up pointing to the same allocated memory. In this case, you’ll need to explicitly define these in order to do a deep copy. Even better, avoid doing your own memory management if you can and use classes from the standard library.

Quiz Time

1) Assuming Point is a class and point is an instance of that class, should you use a normal/friend or member function overload for the following operators?

1a) point + point
1b) -point
1c) std::cout << point
1d) point = 5;

Show Solution

2) Write a class named Average that will keep track of the average of all integers passed to it. Use two members: The first one should be type int32_t, and used to keep track of the sum of all the numbers you’ve seen so far. The second should be of type int8_t, and used to keep track of how many numbers you’ve seen so far. You can divide them to find your average.

2a) Write all of the functions necessary for the following program to run:

and produce the result:


Hint: Remember that int8_t is usually typedef’d as a char, so std::cout treats it accordingly.

Show Solution

2b) Does this class need an explicit copy constructor or assignment operator?

Show Solution

3) Write your own integer array class named IntArray from scratch (do not use std::array or std::vector). Users should pass in the size of the array when it is created, and the array should be dynamically allocated. Use assert statements to guard against bad data. Create any constructors or overloaded operators needed to make the following program operate correctly:

This programs should print:

5 8 2 3 6
5 8 2 3 6

Show Solution

4) Extra credit: This one is a little more tricky. A floating point number is a number with a decimal where the number of digits after the decimal can be variable. A fixed point number is a number with a fractional component where the number of digits in the fractional portion is fixed.

In this quiz, we’re going to write a class to implement a fixed point number with two fractional digits (e.g. 12.34, 3.00, or 1278.99). Assume that the range of the class should be -32768.99 to 32767.99, that the fractional component should hold any two digits, that we don’t want precision errors, and that we want to conserve space.

4a) What type of member variable(s) do you think we should use to implement our fixed point number with 2 digits after the decimal? (Make sure you read the answer before proceeding with the next questions)

Show Solution

4b) Write a class named FixedPoint2 that implements the recommended solution from the previous question. If either (or both) of the non-fractional and fractional part of the number are negative, the number should be treated as negative. Provide the overloaded operators and constructors required for the following program to run:

This program should produce the result:


Hint: Although it may initially seem like more work initially, it’s helpful to store both the non-fractional and fractional parts of the number with the same sign (e.g. both positive if the number is positive, and both negative if the number is negative). This makes doing math much easier later.
Hint: To output your number, first cast it to a double.

Show Solution

4c) Now add a constructor that takes a double. You can round a number (on the left of the decimal) by using the round() function (included in header cmath).

Hint: You can get the non-fractional part of a double by static casting the double to an integer
Hint: To get the fractional part of a double, you’ll first need to zero-out the non-fractional part. Use the integer value to do this.
Hint: You can move a digit from the right of the decimal to the left of the decimal by multiplying by 10. You can move it two digits by multiplying by 100.

The follow program should run:

This program should produce the result


Show Solution

4d) Overload operator==, operator >>, operator- (unary), and operator+ (binary).

The following program should run:

And produce the output:

Enter a number: 5.678
You entered: 5.68

Hint: Add your two FixedPoint2 together by leveraging the double cast, adding the results, and converting back to a FixedPoint2.
Hint: For operator>>, use your double constructor to create an anonymous object of type FixedPoint2, and assign it to your FixedPoint2 function parameter

Show Solution

10.1 -- Object relationships
9.15 -- Shallow vs. deep copying

170 comments to 9.x — Chapter 9 comprehensive quiz

  • MikiBG

    In the last question, operators +, >> and << do not need to access member variables. Is there any reason why one should prefer to define them as friend functions over just normal functions?

  • kjm

    Why not to use a single int32_t field for 4a? (fixed-point behaves essentially like an integer while memory is aligned anyway)
    Thank you.

  • Hi, worked through 4(b) and then moved on to 4(c) (it's only another function after all) and ended up with the following:

    Hopefully this is good enough to move on to the next?

    • * Line 17
      * Line 19: Unnecessary check. You're checking again in the following lines
      *-Line 24, 36, 38: Can be written without repetition of variable names
      *-@FixedPoint2::FixedPoint2(double): Favor initialization over assignment
      * Line 46: @round should be @std::round
      * Line 46, 51: Use double numbers when calculating with doubles (100.0 instead of 100)
      * Line 64-76: Way to go

      > Hopefully this is good enough to move on to the next?
      See if you can work out the *- suggestions first. Other than that you code looks fine.

  • For number 3 I give you:

    • * Line 16, 22, 24, 36, 53, 65, 68
      * Line 19: That 0 only initializes the first element. Empty curly brackets mean "initialize the entire array to default values (0)".
      * Line 43: Compilation error. Should be

      or for large types

  • Well, here's my attempt at number 2.  It produces the correct result so I suppose it is ok

    • Hi Nigel!

      * Line 11, 12: Thank goodness!
      * Line 11, 12: Should be @std::int32_t and std::int8_t, but those shouldn't be used at all, because they're optional. Alex is to blame for this, you did what you were asked for.
      * @Average::Average is unused, you might as well remove it.
      * Line 37, 54

  • TheBendeee

    Hi! I have problems with understanding this part of the code:
    (line 31:)

    Why does this work, and how?

    • Alex

      Consider a number like 2.56. 2 would be stored in m_base, and 56 would be stored in m_decimal. To reconstruct the actual value, we first need to convert m_base from 56 back to 0.56. We do this by dividing it by 100. We static_cast(m_decimal) to make sure we're doing floating point division instead of integer division. Then we add m_base to finish reconstructing the entire number.

      • Silviu

        Alex great example and great lessons, but i think you should explain this in your code, it's still a key part in the code, that is not really explained and I think it's a good explanation and very helpful.
        Thank you.

Leave a Comment

Put all code inside code tags: [code]your code here[/code]