Fixed-point number class with float->int conversions.

fixed.cpp

// testing fixed point numbers

// g++ -std=c++11 -W -Wall -Werror -Wextra fixed.cpp -o fixed

#include <iostream>
#include <cstdint>
#include <limits>
#include <typeinfo>

template <typename fixedBase, unsigned fracDigits>
class fixed_t {
    
    private:
        fixedBase number;
        
    public:
        constexpr fixed_t       ()                     : number( 0 ) {}
        constexpr fixed_t       ( const fixed_t& f )   : number( f.number ) {}
        constexpr fixed_t       ( fixedBase f )        : number( f ) {}
        constexpr fixed_t       ( float f )            : number( (fixedBase(1) << fracDigits) * f ) {}
        ~fixed_t                () = default;
        
        fixed_t&    operator    ++  ()                                      { return *this = fixed_t( ++number ); }
        fixed_t&    operator    --  ()                                      { return *this = fixed_t( --number ); }
        
        fixed_t     operator    ++  ( int )                                 { return fixed_t( ++number ); }
        fixed_t     operator    --  ( int )                                 { return fixed_t( --number ); }
        
        constexpr   bool        operator    !   () const                    { return !number; }
        
        constexpr   bool        operator    ==  ( const fixed_t& f ) const  { return number == f.number; }
        constexpr   bool        operator    !=  ( const fixed_t& f ) const  { return number != f.number; }
        constexpr   bool        operator    >=  ( const fixed_t& f ) const  { return number >= f.number; }
        constexpr   bool        operator    <=  ( const fixed_t& f ) const  { return number <= f.number; }
        constexpr   bool        operator    >   ( const fixed_t& f ) const  { return number > f.number; }
        constexpr   bool        operator    <   ( const fixed_t& f ) const  { return number < f.number; }
        
        constexpr   fixed_t     operator    +   ( const fixed_t& f ) const  { return fixed_t( number + f.number ); }
        constexpr   fixed_t     operator    -   ( const fixed_t& f ) const  { return fixed_t( number - f.number ); }
        constexpr   fixed_t     operator    -   () const                    { return fixed_t( -number ); }
        constexpr   fixed_t     operator    *   ( const fixed_t& f ) const  { return fixed_t( number * f.number ); }
        constexpr   fixed_t     operator    /   ( const fixed_t& f ) const  { return fixed_t( number / f.number ); }
        constexpr   fixed_t     operator    %   ( const fixed_t& f ) const  { return fixed_t( number % f.number ); }
        constexpr   fixed_t     operator    &   ( const fixed_t& f ) const  { return fixed_t( number & f.number ); }
        constexpr   fixed_t     operator    |   ( const fixed_t& f ) const  { return fixed_t( number | f.number ); }
        constexpr   fixed_t     operator    ^   ( const fixed_t& f ) const  { return fixed_t( number ^ f.number ); }
        constexpr   fixed_t     operator    ~   () const                    { return fixed_t( ~number ); }
        constexpr   fixed_t     operator    >>  ( const fixed_t& f ) const  { return fixed_t( number >> f.number ); }
        constexpr   fixed_t     operator    <<  ( const fixed_t& f ) const  { return fixed_t( number << f.number ); }
        
        constexpr   fixed_t&    operator    =    ( const fixed_t& f )       { number = f.number; return *this; }
        fixed_t&                operator    +=   ( const fixed_t& f )       { number += f.number; return *this; }
        fixed_t&                operator    -=   ( const fixed_t& f )       { number -= f.number; return *this; }
        fixed_t&                operator    *=   ( const fixed_t& f )       { number *= f.number; return *this; }
        fixed_t&                operator    /=   ( const fixed_t& f )       { number /= f.number; return *this; }
        fixed_t&                operator    %=   ( const fixed_t& f )       { number %= f.number; return *this; }
        fixed_t&                operator    &=   ( const fixed_t& f )       { number &= f.number; return *this; }
        fixed_t&                operator    |=   ( const fixed_t& f )       { number |= f.number; return *this; }
        fixed_t&                operator    ^=   ( const fixed_t& f )       { number ^= f.number; return *this; }
        fixed_t&                operator    >>=  ( const fixed_t& f )       { number >>= f.number; return *this; }
        fixed_t&                operator    <<=  ( const fixed_t& f )       { number <<= f.number; return *this; }
        
        constexpr   operator    float       ()          { return float(1.f / (fixedBase(1) << fracDigits)) * number; }
        constexpr   fixed_t&    operator =  ( float f ) { return *this = fixed_t( f ); }
};

typedef fixed_t< int32_t, 8 >   lowp_t;     // 24.8
typedef fixed_t< int32_t, 16 >  medp_t;     // 16.16
typedef fixed_t< int32_t, 24 >  highp_t;    // 8.24

//typedef fixed_t< int64_t, 16 >  lowp_t;    // 48.16
//typedef fixed_t< int64_t, 32 >  medp_t;    // 32.32
//typedef fixed_t< int64_t, 48 >  highp_t;   // 16.48

int main() {
    constexpr float     testNum     = 4.2f * 1.3f;
    constexpr lowp_t    fixed_t1    = testNum;
    constexpr medp_t    fixed_t2    = testNum;
    constexpr highp_t   fixed_t3    = highp_t( testNum ) + highp_t( testNum );
    
    //++fixed_t3 = fixed_t3 - (fixed_t3 >> fixed_t3);
    
    std::cout.precision( std::numeric_limits< float >::digits10 );
    std::cout << std::fixed
        << testNum << '\n'
        << fixed_t1 << ' '
        << fixed_t2 << ' '
        << fixed_t3 << std::endl;
    
    return 0;
}