CPP02 / the Fixed class, explained

00 · orientationOne class, four layers

Module 01 gave you seven independent exercises. Module 02 gives you one class, Fixed, built in four layers. A decision made in ex00 is still alive in ex03, and that is both the difficulty and the lesson: you are watching a type grow.

What each layer teaches

The rules that apply everywhere

• c++ -Wall -Wextra -Werror -std=c++98, zero warnings. Everything here is also clean under -pedantic.
• Orthodox Canonical Form is mandatory from this module to module 09. Every class writes out its default constructor, copy constructor, copy assignment operator and destructor, even when the compiler generated ones would behave identically.
• No friend, no using namespace, no STL containers, no C++11. roundf from <cmath> is authorized from ex01.
• Function bodies never live in a header. Headers carry include guards and their own dependencies.
• No comments in any source file. Explanations live in the walkthrough and here.

File map

01 · orientationWhat the compiler sees

Before any object exists there is a build, and half the confusion about “which file does what” dissolves once the build is a picture. Three source files become one program in two steps.

The header is a contract, not a program

Fixed.hpp says what exists. A class named Fixed, holding an int, offering these functions with these signatures. It contains no bodies, so nothing in it ever runs. #include is literal text pasting, so both Fixed.cpp and main.cpp end up with an identical copy of that contract at their top. That is why a header must have an include guard. If two headers both pulled in Fixed.hpp, the class would be defined twice in one file, and the guard turns the second copy into nothing.

#ifndef FIXED_HPP
# define FIXED_HPP
class Fixed { ... };
#endif

The .cpp is the implementation

Fixed.cpp says how. Every body starts with Fixed::, which reads as “this belongs to Fixed”. It includes the header so the compiler can check each body against its declaration. Nothing in Fixed.cpp runs top to bottom either. It is a catalogue of operations waiting to be called.

main.cpp is the only thing that runs

Execution starts in main and goes nowhere else unless main calls something. When it writes Fixed a; the compiler consults the contract, finds a default constructor, and the linker later finds its body in Fixed.o. That is the whole relationship. Header declares. Source defines. Main requests.

Where the operator<< lives, and why

One declaration sits outside the class, at the bottom of Fixed.hpp. It is still part of the contract, it just is not a member. Z6 explains why it cannot be one.

02 · orientationThe other three tools

This handbook is the text. Three companions show the same ideas moving.

Suggested order if the module feels like fog. Read Level zero here, then run ex01 in the tracer with ▶ step, then come back for the number.

Z1 · level zeroClass, object, state

Forget Fixed for a moment. Nothing about the object model needs 256 or a triangle, and mixing them together is exactly what made the module hard to hold. Here is a class that counts.

class Counter
{
private:
	int	_value;

public:
	Counter();
	void	addOne();
	int	getValue() const;
};

The class is a description. It says that a Counter has one integer inside and three things you can do to it. Writing the class creates nothing. No memory is set aside, no _value exists yet. It is a blueprint, or better, a catalogue of operations.

An object is one actual instance. Counter a; reserves memory for one int and calls the constructor on it. Counter b; reserves another. Each object has its own _value. That per object data is its state.

Two things follow immediately. The functions are not copied per object. There is one addOne in the program, and it works on whichever object it was called through. And private means the class controls access, not the object. Any member function of Counter may read any Counter's _value, including another object's. That is the fact that lets operator= read other._value in ex01 without any friend.

The same picture for Fixed

Fixed is structurally a Counter. One int of state, called _value. What makes it a number type is a rule the class enforces about that integer, which N1 introduces. The rule is not stored anywhere. The object contains 2560, and the class interprets it as 10.

Z2 · level zeroMember functions and this

How does a.addOne() know to increase a and not b? The compiler sees that a has type Counter, looks in Counter's catalogue for addOne, and calls it with a hidden extra argument. Inside the function that hidden argument is named this, and it is a pointer to the object the call went through.

So _value += 1 inside the body really means this->_value += 1, and *this means “the object itself”. That is why the copy constructor in every exercise can write *this = other: it is saying “assign other into the object currently being constructed”.

A const at the end of a member function, as in int getValue() const, is a promise about this. The function will read the object and never write it. The compiler enforces it, and it is also what allows the function to be called on a const object. Fixed const b(10); b.toInt(); compiles only because toInt made that promise.

A static member function has no this. Fixed::max(a, b) is called through the class, not an object, because comparing two objects is nobody's method in particular. Both arguments arrive explicitly.

Z3 · level zeroBorn versus changed

This is the distinction the whole module turns on, and the one most often blurred. There are two entirely different ways for an object to end up holding the value of another.

Fixed b( a );
Fixed d = b;     // also construction

Fixed c;
c = b;

The four canonical members are the four moments in an object's life, and each is a separate function you write.

Why the copy constructor in this repo produces three lines

ex00's expected trace shows Copy constructor called, then Copy assignment operator called, then getRawBits member function called. That happens only if the copy constructor is written as a delegation.

Fixed::Fixed(const Fixed &other) : _value(0)
{
	std::cout << "Copy constructor called" << std::endl;
	*this = other;
}

“Construct me at zero, then assign the other into me.” The assignment operator prints its own line and, in ex00, reads through the getter, which prints a third. A copy constructor that wrote : _value(other._value) would produce one line, which is why the subject marks the middle line as one that may be missing. It is not a different mechanism, only a different choice about reuse. The tracer shows both lines landing under the copy constructor in ex00, statement 2.

Z4 · level zeroWho gets called

Several functions share a name and the compiler picks one. That is overloading, and the picking is overload resolution. It is not magic and it is not guesswork. It is a short procedure run at compile time, and once you can run it in your head, every constructor call in this module becomes predictable.

The four constructor calls in ex01

Fixed has four constructors after ex01. Run the procedure on each call the subject makes.

Constness is a type too

ex02 declares max twice, once taking Fixed & and once taking const Fixed &. The subject then calls Fixed::max( a, b ) with a non const and b declared Fixed const. Run the procedure. The non const overload would need to bind b to a Fixed &, which would silently drop its constness, so the language refuses and that overload is not viable. The const overload binds both, since a non const object binds happily to a const reference, and it wins. It returns a const Fixed &.

This is what the module title means by ad-hoc polymorphism. One name, several behaviours, selected at compile time by the types of the arguments, constness included.

Operators are overloaded functions with unusual names

a + b is resolved exactly the same way. The compiler sees a binary + with a Fixed on the left, looks for a function named operator+ that it could call as a.operator+(b), and finds the member. ++a becomes a.operator++() and a++ becomes a.operator++(0), where the 0 is a dummy that exists only to make the two signatures different. None of this is a new mechanism. It is name lookup plus the procedure above.

Z5 · level zeroLife of an object

Every object has a beginning and an end, and the language decides both by rules, never by chance. Two rules cover everything in this module.

• A named object dies at the closing brace of the scope that declared it. Objects in the same scope die in reverse order of construction.
• An unnamed temporary dies at the end of the full expression that created it, which is the semicolon.

Anatomy of one statement

ex01 statement 5 does more than it looks like it does. a = Fixed( 1234.4321f ); produces three trace lines from one line of source, and the third is the one that surprises people.

The right hand side is evaluated first. Fixed( 1234.4321f ) is a constructor call with no name attached, so it builds a temporary at a fresh address. Then operator= copies its raw value into a, which already exists. Then the semicolon arrives, the full expression is over, and the temporary is destroyed. In the subject's expected output this is the lone Destructor called in the middle, before any value is printed.

The end of main

ex01 has four named objects, a b c d, constructed in that order. When main returns they are destroyed d c b a. Every destructor prints the same text, so in the real output only the order tells you which object each line belongs to. Five constructions in the program, five destructions. Four named plus one temporary, and the temporary is the one whose destructor came early because its lifetime ended early.

Where copy elision fits

The language permits the compiler to skip a copy when a function returns an object by value, constructing the result straight into its destination. GCC does this. ex02's Fixed const b( Fixed( 5.05f ) * Fixed( 2 ) ); shows no Copy constructor called for b: the float constructor that operator* calls runs at b's own address. This is why the subject's expected traces say “something similar”. Elision is allowed, not required, so two correct programs can print different numbers of lines.

Z6 · level zeroHanding objects around

Every parameter and every return type in this module is a decision between three options, and each option has a visible cost in the trace.

Parameters

Const reference is the default for anything you only read. It costs nothing, it accepts const objects, and it accepts temporaries, which plain Fixed & cannot. std::cout << Fixed(5) only compiles because operator<< takes a const reference.

Return types

Why operator<< is not a member

A member operator always takes its own class as the left operand. In std::cout << a the left operand is the stream, so a member version would have to belong to std::ostream, which is not yours to edit. Making it a member of Fixed compiles but reverses the syntax to a << std::cout. Measured. So it is a free function, declared after the class in Fixed.hpp, and it needs no friend because toFloat is public. It returns std::ostream & so the next << in the chain has a stream to attach to. Changing that to void fails with invalid operands of types 'void' and ... to binary 'operator<<'.

Z7 · level zeroThe mechanical map

Every line of C++ in this module falls into one of these rows. When a piece of code feels opaque, find its row.

Z8 · level zeroVocabulary

N1 · foundationsFixed point from zero

An int has 32 bits and a binary point sitting to the right of the last one. Fixed point moves that point. Fixed declares eight fractional bits, so it decides in advance that the low eight bits of the integer are the fraction and the upper twenty four are the whole part. The bits do not change. Their interpretation does.

Some raw values and what they mean

What you buy and what you pay

Every fractional bit doubles the precision and halves the range. Eight bits give a step of 1/256 and a range of about ±8.39 million, since 2³¹ / 256 is 8388608. A float spends its 32 bits differently, on a mantissa and a moving exponent, and gets a vast range with about seven significant digits everywhere. Fixed point gets the same absolute precision everywhere, which is why it suits audio and graphics, and it can be added and compared with plain integer instructions.

N2 · foundationsThree views of one object

One Fixed holding raw 1293 answers three different questions depending on which member you ask. Knowing which one std::cout << a uses ends most of the confusion about the printed output.

The conversion map

N3 · foundationsWhere the digits come from

Why does a print as 1234.43 with two decimals, while c prints as 42.4219 with four? Because std::cout is not printing decimals. It is printing six significant digits, and the whole part uses some of them up.

Count the digits. 1 2 3 4 4 3 is six, so four before the point and two after. 4 2 4 2 1 9 is six, two before and four after. 0.00390625 fits in six because leading zeros do not count. None of this is the Fixed class deciding anything. Leave the stream's formatting alone, since the expected output relies on the default.

N4 · foundationsArithmetic on raw values

One fact decides every arithmetic design choice in ex02. A raw value already carries the factor 256. So when you combine two raw values, you have to ask how many times that factor appears in the result.

Addition and subtraction carry it once

Multiplication carries it twice

So the honest integer form is (_value * other._value) / 256, and it is right until the product no longer fits in 32 bits.

C++98 has no long long, and long is only guaranteed to be at least as wide as int, so there is no portable wider integer to reach for. That leaves floating point.

Fixed	Fixed::operator*(const Fixed &other) const
{
	return Fixed(this->toFloat() * other.toFloat());
}

Both operands go back to real values, multiply, and the float constructor scales and rounds the result. Two measured advantages beyond merely working. The range extends to the type's own limit, confirmed at 200 × 200 = 40000 and 70000 × 2 = 140000. And rounding beats truncation: 5.05 squared is raw 6530.66 exactly, the float path gives 6531, the integer form would give 6530.

Division

Same shape as multiplication through float. The subject says a crash on division by zero is acceptable. This implementation does not crash. Measured: a float infinity comes out, roundf passes it through, and casting infinity to int is undefined behaviour that on this machine saturates to INT_MIN, printing -8.38861e+06, for 10/0, -10/0 and 0/0 alike. A silent wrong number rather than a crash. There is no guard because the subject waives it, and this is the sentence to have ready if asked.

Comparison

Compare the raw integers directly. Both sides carry the same positive constant, so the raw ordering and the real ordering always agree, and the comparison is exact. Converting to float to compare would introduce rounding into an operation that is currently perfect.

Epsilon and the increments

The smallest ε with 1 + ε > 1 is one raw unit. So ++ is _value += 1, a single integer step, never += 1.0 through the rounding path. From zero, one increment prints 0.00390625, two print 0.0078125, exactly as the subject's output shows.

E0 · exerciseex00 · My First Class in Orthodox Canonical Form

The class can only hold zero and the only way to change it is setRawBits. What is graded is the canonical form and the trace that proves which member ran when. The subject supplies both the program and the expected output, so this is a byte for byte matching exercise.

The class

class Fixed
{
private:
	int			_value;
	static const int	_fractionalBits = 8;

public:
	Fixed();
	Fixed(const Fixed &other);
	Fixed	&operator=(const Fixed &other);
	~Fixed();

	int	getRawBits(void) const;
	void	setRawBits(int const raw);
};

The canonical four come first and always in this order, so they can be checked at a glance in every class from here to module 09. The header needs no includes: it names only int and itself. setRawBits(int const raw) is the subject's own spelling, kept character for character, and it means the same as const int raw.

The trace, decoded

Two things the trace encodes that the prose never states. The copy constructor delegates, which is the pair of lines after it. And the assignment operator reads through the getter, which is why a getRawBits line follows every assignment. Both are unusual choices made so that the output matches the subject exactly. Step through it in the tracer.

Why operator= returns Fixed &

Three candidates. void breaks a = b = c, since the inner assignment must produce something for the outer one to consume. By value compiles and chains but constructs a temporary on every assignment, and (a = b) = c would assign into that temporary and throw the result away. By reference chains with no copy and (a = b) = c modifies a. return *this; returns the object that was just assigned into.

The self assignment guard

if (this != &other)
	_value = other.getRawBits();

For this class the guard changes nothing, since assigning an int to itself is harmless. It is there for the class that owns a resource. The classic assignment operator releases what it holds and then copies from the source, and handed x = x without a guard it releases the resource and then reads from the thing it just freed. The habit costs one pointer comparison now. Note it compares addresses. Two objects holding the same value are different objects and must still be assignable.

Gotchas

• Giving setRawBits a message adds a line the reference trace never has. It stays silent.
• Copying _value directly in the copy constructor produces a shorter, also valid, trace that no longer matches the subject's.
• Forgetting return *this; compiles with a warning at best and is undefined behaviour when the result is used.
• Binding _fractionalBits to a reference is a link error, not a compile error.

E1 · exerciseex01 · Towards a more useful fixed point number class

Two converting constructors come in, two conversions go out, and operator<< makes it printable. The subject gives the program and its twenty line output, reproduced exactly.

The one change to code already written

if (this != &other)
	_value = other._value;

ex01's expected trace has no getRawBits line after either assignment, so the operator stops reading through the getter. Legal without friend, because access control is per class, not per object. The getter keeps its message; the class simply never calls it internally from here on, which also stops ex02's operators from burying the output.

The int constructor multiplies, it does not shift

Fixed::Fixed(const int value) : _value(value * (1 << _fractionalBits))

value << 8 looks like the idiomatic fixed point move and is undefined behaviour in C++98 for a negative value. What makes it nasty is that nothing tells you. Measured on −7: multiply gives −1792, shift gives −1792, clean under every warning flag. Undefined code that happens to produce the right answer is worse than a wrong answer, because there is no symptom until the compiler or platform changes. 1 << _fractionalBits alone is fine, since the left operand is the positive literal 1.

The float constructor rounds

Fixed::Fixed(const float value)
	: _value(static_cast<int>(roundf(value * (1 << _fractionalBits))))

roundf becomes authorized here. Rounding rather than truncating makes the conversion symmetric for negatives and the subject's digits depend on it. The static_cast<int> states the narrowing rather than leaving it implied.

toFloat, where the cast is load bearing

return _value / (1 << _fractionalBits);

return static_cast<float>(_value) / (1 << _fractionalBits);

This is the most likely way to end up with a plausible but wrong class. It compiles under -Werror, returns a float as promised, gets every whole number right, and only loses the fractions. A test using only integers would pass.

toInt divides

_value / 256 truncates toward zero. A right shift floors instead. On raw −384, which is −1.5, division gives −1 and the shift gives −2. Division matches what a plain float to int conversion does and keeps toInt symmetric with the constructor's multiplication. Both are implementation defined for negatives in strict C++98, so neither is provably portable, and the subject never exercises negatives.

Stream insertion

std::ostream	&operator<<(std::ostream &out, const Fixed &value)
{
	out << value.toFloat();
	return out;
}

A free function, for the reasons in Z6. Fixed.hpp gains exactly one include, <ostream>, because it names std::ostream. Not <iostream>, since the header needs the type and not the global stream objects.

Reading the output

Why the conversions must be const

b, c and d are declared Fixed const and the main calls toInt on all three and prints them. Without const on toFloat, toInt, and the const Fixed & parameter of operator<<, the subject's own program does not compile.

E2 · exerciseex02 · Now we're talking

Sixteen operators and four static functions. The design is decided by N4. This section covers what is left, which is mostly about returning the right thing.

Comparisons

bool	Fixed::operator<(const Fixed &other) const	{ return _value < other._value; }

Six of these, one line each, all const, all on raw values. Exact by the argument in N4.

Prefix and postfix

Fixed	&Fixed::operator++(void)      { _value += 1; return *this; }

Fixed	Fixed::operator++(int)
{
	Fixed	before(*this);

	_value += 1;
	return before;
}

The unnamed int parameter exists only to make the two signatures differ. Leave it unnamed, since a named unused parameter trips -Wextra. Postfix must return by value: its contract is the value from before the change, a reference to *this would show the new value, and a reference to the local before would dangle. The tracer shows the snapshot appear at a reused address and die at the semicolon.

min and max, and why both pairs must exist

static Fixed		&min(Fixed &a, Fixed &b);
static const Fixed	&min(const Fixed &a, const Fixed &b);

Each returns a reference to one of its arguments, never a copy. On a tie both return b, an arbitrary rule that the tests document by comparing addresses. The const pair alone would accept every call, so why write the other two? Because only the non const pair hands back something the caller can modify.

Reading the filtered output

Every temporary prints its constructor and destructor, so the test sections are read with grep -v called. One artifact to know. In std::cout << "10 + 4 " << (ten + four) the label is inserted before the addition runs, the addition prints its own constructor line onto the same physical line, and the filter drops the whole line. The value then appears alone on the next line. That is why the arithmetic section reads as bare 14 6 40 2.5 after filtering.

E3 · exerciseex03 · BSP

A Point with two Fixed const coordinates, and a free function bsp that says whether a point is strictly inside a triangle. A point on an edge or at a vertex is outside.

The trap, and it is the whole lesson

The subject requires Fixed const members and Orthodox Canonical Form, which includes a copy assignment operator. Those two requirements conflict. A const member can be set only in a constructor's initializer list and never assigned afterwards, so an assignment operator physically cannot copy _x or _y.

Point	&Point::operator=(const Point &other)
{
	(void)other;
	return *this;
}

This looks like an unfinished function and it is the only legal one. The design lesson underneath is that const members and value semantics do not mix. A type with const members can be copy constructed but never meaningfully assigned, so it cannot live in anything that reassigns its elements. The subject imposes the const to make that collision visible.

Point

Default constructor initializes both to 0 through the initializer list, selecting Fixed's int constructor. The float constructor selects the float one. The copy constructor copies both through the list, the same constraint seen from the working side. Point prints nothing. The two getters return const Fixed &, because returning by value would copy, every Fixed copy prints two lines, and cross calls the getters twelve times per invocation.

The sign test

static Fixed	cross(const Point &o, const Point &a, const Point &b)
{
	return (a.getX() - o.getX()) * (b.getY() - o.getY())
		- (a.getY() - o.getY()) * (b.getX() - o.getX());
}

For each edge, the two dimensional cross product of the edge vector with the vector from the edge's start to the point. Its sign says which side of that edge's line the point is on. Strictly inside means the same side of all three edges, so all three signs agree.

if (d1 == zero || d2 == zero || d3 == zero)
	return false;
if (d1 > zero && d2 > zero && d3 > zero)
	return true;
if (d1 < zero && d2 < zero && d3 < zero)
	return true;
return false;

The zero test is redundant to the compiler and informative to a reader. A zero fails both strict comparisons and would fall through to false anyway. Removing that line changes nothing, and that was verified by removing it. It stays because it is the only place the code visibly states the subject's boundary rule, in a project where comments are not allowed. Say exactly that if asked.

Accepting both all positive and all negative is necessary. The sign depends on the triangle's winding. Counter clockwise vertices give three positives for an interior point, the same vertices listed clockwise give three negatives. Rejecting one would return false for a point genuinely inside a triangle specified the other way round. Verified on both windings.

The cost of by value parameters

The subject's signature takes four Points by value, so each call copies four points, which is eight Fixed copies. One call emits 68 trace lines. Eight copy constructions and their eight delegated assignments, fifteen default constructions from Fixed result; inside operator-, six float constructions from operator*, one int construction for zero, and thirty destructions. Balanced. Passing by const reference would remove 24 lines. The subject fixed the signature, so the cost stays, and the tracer steps through every one of those lines with its origin named.

The precision caveat, which is not where you expect

Edge detection through the float path is robust. For a point exactly on an edge the two products inside cross are mathematically equal, both are correctly rounded from exactly representable operands, so they produce bit identical floats, the same raw integer, and a difference of exactly zero. Verified on all three edges and on a triangle of side 300. The hazard is upstream. Coordinates are quantized to 1/256 when a Point is built, so 4.999 becomes raw 1280, which is exactly 5.0, and a point the caller thinks is strictly inside can land on the hypotenuse before bsp ever sees it. bsp is right about the point it was given, and the point is not the one that was asked for. The resolution limit lives in the type.

The harness

Nineteen cases through a check helper printing PASS or FAIL, a summary line, and a nonzero exit on any failure. The summary exists because the trace output is enormous and a verdict at the very end is the only thing visible without scrolling. The harness was proven capable of failing by flipping every return false in bsp to true, which produced exactly twelve failures, the twelve cases whose expected answer is false.

D1 · defenseEval runbook

What to run, in order, and what you should see. Every command from the directory of that exercise.

Every exercise

• make re compiles with zero warnings. Then make again reports nothing to be done.
• c++ -Wall -Wextra -Werror -std=c++98 -pedantic *.cpp is also silent.
• valgrind --leak-check=full ./<binary> reports zero leaks. The type allocates nothing, so the only heap use is the stream library's.
• make fclean leaves exactly the submitted files.
• No friend, no using namespace, no printf, no comments, no function bodies in headers. Include guards on every header.

ex00

• ./fixed prints exactly the sixteen lines of the subject. The middle line under the copy constructor is present because the copy constructor delegates.
• Be ready to point at the four canonical members in the header, in order.

ex01

• ./fixed prints the subject's twenty lines. The lone destructor in the middle is the temporary.
• Raw values if asked: 10 → 2560, 42.42f → 10860, 1234.4321f → 316015, −1.5f → −384.
• Be ready to explain Fixed x(10.0) not compiling.

ex02

• ./fixed | grep -v called starts with the subject's seven values then four labelled sections.
• Be ready to show Fixed::max(a, b) choosing the const overload, and the non const one returning a modifiable reference.
• Know the numbers: integer multiply dies at 182, float path exact below 65536, ε is 0.00390625, division by zero prints −8.38861e+06.

ex03

• ./bsp | grep -v called prints nineteen PASS lines and SUMMARY 0 failures, exit status 0.
• Be ready to defend the no op assignment operator in one sentence, and the redundant zero test in one more.
• Know that one bsp call is 68 trace lines and why.

D2 · defenseQ&A drill

Grouped by theme. Open one, answer aloud, then read.

D3 · defenseLive modification drills

Evaluators may ask for a small change on the spot. Each of these should take under five minutes. Know where the change lands and what else it touches.

D4 · defenseChoices in this code that invite a question

• The copy constructor initializes _value to 0 before delegating. Redundant with the assignment that follows, kept so the object is never in an indeterminate state, and so the class follows the rule that members are initialized in the list.
• main.cpp in ex00 and ex01 uses the subject's brace style. Transcribed verbatim because the deliverable is a byte for byte output match. Deliberate inconsistency with the rest of the repository.
• ex02's main is long. The subject says to test every feature. Five labelled sections, each observation its own statement.
• The zero test in bsp. Redundant and kept as the visible statement of the boundary rule.
• getRawBits still prints in ex01 onward. The subject never withdraws the message. The class simply stops calling it internally.
• Multiplication and division through float, addition on raw. Addition needs no rescaling and stays exact. Multiplication needs it and overflows in integer form at 182.
• No guard on division by zero. The subject waives it. The observed result is a saturated INT_MIN, not a crash.
• <ostream> rather than <iostream> in the header. The header needs the type, not the global stream objects.
• Tie rule in min and max returns the second argument. Arbitrary, documented by the tests.