If your class will mimic built-in types, base its interface on the interface provided by the complex class, which comes with most C++ compilers. After all, you're probably using C++ for code reuse, so why derive a new interface when one with years of debugging is available? (There are a few twists to the implementation of the interface that I'll discuss in detail later.)

Once you've developed the basics of the class, you're nearly done. Since built-in types such as ints and floats behave in a well-documented manner, make sure your class behaves as closely to a built-in type as possible to minimize surprises. So in addition to the default constructor, destructor, copy constructor, and assignment operator, you'll need the math operators, comparison operators, and also some conversion operators that allow a fixed-point number to interact with built-in types.

The actual storage is a union between a long and a struct of two integers (one signed for the whole numbers, and the other unsigned for the fraction). The typedef for the union is:

typedef union
{
signed long long_rep;
struct {
   unsigned int fractional_part;
   signed int whole_part;
   } half_rep;
} FixedData;

Fixed A,B;    // default constructor
A=10; B=10.1; // assignment from ints or floats
A = B;       // assignments from other Fixed point numbers
Fixed C=B;    // copy constructor
Fixed D(20),E(10.1),F(B); // ctors with arguments

You should be aware that C++ will generate a default constructor, copy constructor, assignment operator, and address-of operators if you don't provide them. Thus, if you've been using one of these implicit functions unawares, you may have let yourself in for some unexpected behavior such as memory leaks or improperly initialized classes. Program defensively by not depending too much on the compiler to provide these functions for you. If necessary, you can turn any of these defaults off by simply declaring a private prototype for them in your header, but never actually implementing the function. This effectively prevents the compiler from providing implicit functions. This way either the compiler or the linker will catch the attempted use.

The compiler will provide the address-of operator (operator&), a function frequently forgotten, usually until it's too late, if you don't provide it. But if you are implementing a class where you want to perform reference counting, that is, having a pointer to the data with a "use count" recording the number of different classes sharing the data, then you'll need to implement your own operator& to track the data usage.

For a class to mimic a built-in type, you need a default constructor, because when you create an array the default constructor will be called for each element. If you create a default constructor, you should create a destructor, even if the destructor (as in this case) is a null function.

A copy constructor is used for creating a new Fixed object from a preexisting Fixed object. Constructors that take arguments, particularly arguments that are built in types, will provide an easy method of implementing some of the math operators. (More on this later.)

You should initialize all the data in the constructor. This way you always leave a freshly-instantiated variable in a known state. For more complicated classes with more internal data, you should create one private member function to take care of initializing all of the variables in a standard order. This makes it easier to write the destructor, since no matter which constructor you call, there will be only one destructor function. If you allocate memory in the constructors, the destructor is the place you would free it.

The math operators needed for Fixed point are addition, subtraction, multiplication, and division. The same associative rule used for the equality operators will work for addition and subtraction. You simply pretend that you have multiplied each Fixed point value by 64K, added or subtracted them, then divided by 64K. This won't work with higher-order operators such as multiplication or division, since, for example, multiplying two numbers by 64K before you multiply them together results in the original two numbers multiplied by 64K squared, which quickly reduces the applicable range. So, for multiplication and division (recognizing that multiplication consumes the most time) you probably will have to break down and use assembly language to properly perform the operations.

For purposes of brevity, I'll restrict myself to an 80386+ discussion of how to perform these operations. The 80386 chip has a 32-bit multiply and a 32-bit divide instruction, which greatly speeds these operations when used in the Fixed class. They can also be applied to any chip capable of a native 32-bit or greater operation. For a chip like the 8086, you will have to break the operation into steps tedious in their bookkeeping.

Class Fixed
   {
   public:
   Fixed();// default constructor
   Fixed( int );
      // constructor taking an int
   Fixed operator+( const Fixed& );
   .. other implementation details...
   }

Fixed fixed_var, result1, result2;
result1 = fixed_var + 1;
                 // compiles OK
result2 = 1 + fixed_var; // error!

result1 = fixed_var.operator+(1);
result2 = 1.operator+(fixed_var);

What you need is a global function. You remove the operator+ member function from class Fixed and replaced it with a global function, like so:

Fixed operator+( const Fixed&, const Fixed& );

Fixed Fixed::operator+ (Fixed rhs1, Fixed rhs2 )
{
   Fixed return_value;
   return_value.long_rep = rhs1.long_rep + rhs2.long_rep;
   // add the long numbers
   return return_value;
}

Fixed Fixed::operator+( Fixed rhs1, Fixed rhs2 )
{
   return Fixed( rhs1.long_rep,rhs2.long_rep);
}

As a final touch, fine tuning the class by using a profiler is not only a great way of identifying the hot-spots in the program, but it'll let you know when you'll need to do some optimization of the class interface. In the example program, I'm performing a matrix multiplication — this is an operation that involves a repetitive sequence of multiplications and additions. Since our interest is to eke out as much performance from the class as possible, I've created a member function, addProduct, that replaces the operation of a multiplication of two fixed point numbers and then the summing of the result into a third fixed point. The function takes two references to fixed point numbers, performs the multiplication of the two and then sums the result into the current object (pointed to by the this pointer), all in assembly language. For a complex operation that is going to be performed a number of times, it can be a significant speed increase to hand-code some assembly instructions of maximize the benefit of using the Fixed point class. Using this optimized function significantly increased the execution speed, mostly through the simple elimination of Fixed point temporaries created by the compiler during the math operation. Testing performed on an 80386 / 80387 @ 20Mhz for a simple 3 by 3 matrix multiplication showed that the optimized C++ code was 86% faster than using floats and 165% faster than using doubles. This illustrates that while C++ compilers are getting better at optimizing away inefficiencies, you're currently better off examining the operations that you need to perform repeatedly or that take up the most time (for which you need the profiler) and hand-coding some assembly code. Aside from using a profiler to figure out how to make your program run faster, it's also a great way to gain insight into the way that the compiler (and by inference, C++) operates. Once you understand how the compiler does things, you've acquired a considerable body of useful knowledge that will prove invaluable in that quest for tight, optimized code.