template<typename T> int round(T value) { return int(value + 0.5); }

O>А школу вспомнить не помогает?

O>template<typename T> int round(T value) { return int(value + 0.5); }
O>

double round_d2d(double fSrc)
{
 char cbBuff[32];
 sprintf(cbBuff, "%3.1f", fSrc);
 return atof(cbBuff);
}

#include <stdio.h>
#include <math.h>

#ifndef M_PI
#define M_PI 3.1415926
#endif

double round_up ( double val, unsigned int digits )
{
  return floor (val * pow ( 10.0, digits ) + 0.5) / pow ( 10.0, digits );
}

void main ( void )
{
  int digits;

  for ( digits = 0; digits < 7; digits++ )
    printf ( "%d: %.7f\n", digits, round_up ( M_PI, digits ) );
}

0: 3.0000000
1: 3.1000000
2: 3.1400000
3: 3.1420000
4: 3.1416000
5: 3.1415900
6: 3.1415930

double round(double x, double accuracy)
{
  assert(accuracy > 0);
  return floor(x / accuracy + 0.5) * accuracy;
}

double round(double x, double digits) // digits -- кол-во десятичных знаков, которые надо оставить, 
{
    double intDg=floor(log10(x)+1);
    double acc=pow(10,intDg-digits);

    return floor(x/acc+0.5)*acc;
}

// file : FixedPoint.h

#pragma once

#include <math.h>
#include <stdio.h>

typedef __int64 VAL_TYPE;

template<unsigned char accuracy, unsigned char sbuf_len = 22>
class FixedPoint
{
public:

    FixedPoint()
    {
        init();
        *this = (VAL_TYPE)0;
    }

    FixedPoint( VAL_TYPE val )
    {
        init();
        *this = val;
    }

    FixedPoint( double val )
    {
        init();
        *this = val;
    }

    template<unsigned char T>
    FixedPoint( const FixedPoint<T> & obj )
    {
        init();
        *this = obj;
    }

    inline unsigned char get_accuracy() const
    {
        return accuracy;
    }

    inline VAL_TYPE get_mult() const
    {
        return _mult;
    }

    inline VAL_TYPE get_val() const
    {
        return _val;
    }

    inline VAL_TYPE get_abs_val() const
    {
        return _val * get_sign();
    }

    inline double get_double() const
    {
        return ((double)_val) / ((double)_mult);
    }

    inline const char * get_str( char separator = '.' )
    {
        return get_str( _str, separator );
    }

    inline char * get_str( char * buf, char separator = '.' )
    {
        sprintf(
            buf,
            "%.0f%c%.0f",
            (double)( _val / _mult ),
            separator,
            (double)( _val % _mult * get_sign() ));
        return buf;
    }

    inline VAL_TYPE get_sign() const
    {
        return get_sign( _val );
    }

    template<class T>
    inline static T get_sign( T val )
    {
        return (T)( val < (T)0 ? -1 : 1 );
    }

    template<unsigned char T>
    inline FixedPoint<accuracy + T> operator * ( const FixedPoint<T> & obj ) const
    {
        return FixedPoint<accuracy + T>( _val * obj.get_val() );
    }

    template<unsigned char T>
    inline FixedPoint<accuracy> & operator *= ( const FixedPoint<T> & obj )
    {
        *this = *this * obj;
        return *this;
    }

    template<unsigned char T>
    inline FixedPoint<accuracy> operator + ( const FixedPoint<T> & obj )
    {
        return FixedPoint<accuracy + T>( _val + obj._val );
    }

    inline FixedPoint<accuracy> & operator += ( const FixedPoint<accuracy> & obj )
    {
        *this = *this + obj;
        return *this;
    }

    inline FixedPoint<accuracy> operator - ( const FixedPoint<accuracy> & obj )
    {
        return FixedPoint<accuracy>( _val - obj._val );
    }

    inline FixedPoint<accuracy> & operator -= ( const FixedPoint<accuracy> & obj )
    {
        *this = *this - obj;
        return *this;
    }

    FixedPoint<accuracy> operator / ( const FixedPoint<accuracy> & obj )
    {
        VAL_TYPE obj_val = obj.get_abs_val();
        VAL_TYPE loc_val = get_abs_val();
        VAL_TYPE v = loc_val / obj_val;
        VAL_TYPE dr = loc_val % obj_val;
        for( int i = 0; i < accuracy + 1; i++ )
        {
            dr *= 10;
            v = v * 10 + dr / obj_val;
            dr = dr % obj_val;
        }
        return FixedPoint<accuracy + 1>( v * get_sign() * obj.get_sign() );
    }

    template<unsigned char T>
    inline FixedPoint<accuracy> & operator = ( const FixedPoint<T> & obj )
    {
        _val = obj.get_val();
        if( accuracy < T )
        {
            VAL_TYPE md = obj.get_mult() / _mult;
            _val = _val / md + (( obj.get_abs_val() % md < 5 ) ? 0 : obj.get_sign() );
        }
        else if( accuracy > T )
            _val *= _mult / obj.get_mult();

        return *this;
    }

    inline FixedPoint<accuracy> & operator = ( VAL_TYPE val )
    {
        _val = val;
        return *this;
    }

    inline FixedPoint<accuracy> & operator = ( double val )
    {
        _val = (VAL_TYPE)floor( fabs( val ) * _mult + .5 );
        _val *= get_sign( val );
        return *this;
    }

private:

    void init()
    {
        _mult = (VAL_TYPE)pow( 10., accuracy );
    }
    
private:
    
    VAL_TYPE    _val;
    VAL_TYPE    _mult;
    char        _str[ sbuf_len + 1 ];
};

XXX>Я написал класс-обертку, о котором Вы говорили, для реализации чисел с фиксированой

XXX>запятой. Может найдутся желающие его "попинать" или те, кому он может пригодиться ?

template<int A> // A = 1/accuracy. То есть 0.001 --> 1000
class FixedPoint
{
public:
  typedef _int64 value_t;
  typedef FixedPoint<A> self_t;

private:
  value_t v_;

public:
  value_t value() const { return v_; }

  value_t floor() const { return v_ / A; }
  value_t ceil() const { return (v_+A-1) / A; }
  value_t round() const { return (v_+A/2) / A; }

  value_t frac() const { return v_ % A; }

  double dbl() const { return double(v_) / A; }

  operator value_t() const { return round(); }
  operator double() const { return dbl(); }


  FixedPoint(int v) : v_(v * A) {}

  template<int B>
  FixedPoint(const FixedPoint& v) : v_(v.value() * A/B) {}

  FixedPoint(double v) : v_(v * A) {}

  // все остальные - только со своим типом. Чужие типы - через имплицитные конструкторы

  self_t& operator = (const self_t& v) { v_ = v.value(); return *this; }
  self_t& operator += (const self_t& v) { v_ += v.value(); return *this; }
  self_t& operator -= (const self_t& v) { v_ += v.value(); return *this; }

  self_t& operator *= (const self_t& v) { v_ = v_ * v.value() / A; return *this; }
  self_t& operator /= (const self_t& v) { v_ = v_ * A / v.value(); return *this; }
};

template<int A, class T>
FixedPoint<A> operator + (FixedPoint<A> const& x, const T& y) { FixedPoint<A> z(x); z += y; return z; }
// и т.п.
// или можешь затащить их в члены класса.

template<int A>
int floor(const FixedPoint<A>& v) { return v.floor(); }

template<int A>
int ceil(const FixedPoint<A>& v) { return v.ceil(); }

template<int A>
int frac(const FixedPoint<A>& v) { return v.frac(); }

template<int A>
int round(const FixedPoint<A>& v) { return v.round(); }

К>double round(double x, double accuracy)
К>{
К>  assert(accuracy > 0);
К>  return floor(x / accuracy + 0.5) * accuracy;
К>}
К>

double round(double x, double accuracy)
{
  assert(accuracy > 0);
  if(x<0)
    return ceil(x / accuracy - 0.5) * accuracy;
  return floor(x / accuracy + 0.5) * accuracy;
}