char buf[32]; // вроде должно хватить
sprintf(buf, "%g", 1.23); // %g - выбирать наиболее подходящую запись: 0.123e+0001 или 1.23

char buf[32];
_gcvt(1.23, 12, buf); // MS-specific

К>char buf[32]; // вроде должно хватить
К>sprintf(buf, "%g", 1.23); // %g - выбирать наиболее подходящую запись: 0.123e+0001 или 1.23
К>

string str = boost::lexical_cast<string>( 1.23 );

К>char buf[32]; // вроде должно хватить
К>sprintf(buf, "%g", 1.23); // %g - выбирать наиболее подходящую запись: 0.123e+0001 или 1.23
К>

#include <boost/format.hpp>
...
std::string S = (boost::format("%g") % 1.23).str();
...

К>>char buf[32]; // вроде должно хватить
К>>sprintf(buf, "%g", 1.23); // %g - выбирать наиболее подходящую запись: 0.123e+0001 или 1.23
К>>

A>string str = boost::lexical_cast<string>( 1.23 );
A>

    template<typename Target, typename Source>
    Target lexical_cast(Source arg)
    {
        detail::lexical_stream<Target, Source> interpreter;
        Target result;

        if(!(interpreter << arg && interpreter >> result))
            throw_exception(bad_lexical_cast(typeid(Target), typeid(Source)));
        return result;
    }

            bool operator<<(const Source &input)
            {
                return !(stream << input).fail();
            }
            template<typename InputStreamable>
            bool operator>>(InputStreamable &output)
            {
                return !is_pointer<InputStreamable>::value &&
                       stream >> output &&
                       (stream >> std::ws).eof();
            }
            bool operator>>(std::string &output)
            {
                #if defined(BOOST_NO_STRINGSTREAM)
                stream << '\0';
                #endif
                output = stream.str();
                return true;
            }
            #ifndef DISABLE_WIDE_CHAR_SUPPORT
            bool operator>>(std::wstring &output)
            {
                output = stream.str();
                return true;
            }
            #endif
        private:
            typedef typename widest_char<
                typename stream_char<Target>::type,
                typename stream_char<Source>::type>::type char_type;

            #if defined(BOOST_NO_STRINGSTREAM)
            std::strstream stream;
            #elif defined(BOOST_NO_STD_LOCALE)
            std::stringstream stream;
            #else
            std::basic_stringstream<char_type> stream;
            #endif

        typedef num_put<_Elem, _Iter> _Nput;
                
        _Myt& operator<<(double _Val)
                {       // insert a double
                ios_base::iostate _State = ios_base::goodbit;
                const sentry _Ok(*this);

                if (_Ok)
                        {       // state okay, use facet to insert
                        const _Nput& _Nput_fac = _USE(ios_base::getloc(), _Nput);

                        _TRY_IO_BEGIN
                        if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this,
                                _Myios::fill(), _Val).failed())
                                _State |= ios_base::badbit;
                        _CATCH_IO_END
                        }

                _Myios::setstate(_State);
                return (*this);
                }

        _OutIt put(_OutIt _Dest,
                ios_base& _Iosbase, _Elem _Fill, double _Val) const
                {       // put formatted double to _Dest
                return (do_put(_Dest, _Iosbase, _Fill, _Val));
                }
                                
        _VIRTUAL _OutIt do_put(_OutIt _Dest,
                ios_base& _Iosbase, _Elem _Fill, double _Val) const
                {       // put formatted double to _Dest
                char _Buf[_MAX_EXP_DIG + _MAX_SIG_DIG + 64], _Fmt[8];
                streamsize _Precision = _Iosbase.precision() <= 0
                        && !(_Iosbase.flags() & ios_base::fixed)
                                ? 6 : _Iosbase.precision();     // desired precision
                int _Significance = _MAX_SIG_DIG < _Precision
                        ? _MAX_SIG_DIG : (int)_Precision;       // actual sprintf precision
                _Precision -= _Significance;
                size_t _Beforepoint = 0;        // zeros to add before decimal point
                size_t _Afterpoint = 0; // zeros to add after decimal point

                if ((_Iosbase.flags() & ios_base::floatfield) == ios_base::fixed)
                        {       // scale silly fixed-point value
                        bool _Signed = _Val < 0;
                        if (_Signed)
                                _Val = -_Val;

                        for (; 1e35 <= _Val && _Beforepoint < 5000; _Beforepoint += 10)
                                _Val /= 1e10;   // drop 10 zeros before decimal point

                        if (0 < _Val)
                                for (; 10 <= _Precision && _Val <= 1e-35
                                        && _Afterpoint < 5000; _Afterpoint += 10)
                                        {       // drop 10 zeros after decimal point
                                        _Val *= 1e10;
                                        _Precision -= 10;
                                        }

                        if (_Signed)
                                _Val = -_Val;
                        }

                return (_Fput(_Dest, _Iosbase, _Fill, _Buf,
                        _Beforepoint, _Afterpoint, _Precision,
                                ::sprintf(_Buf, _Ffmt(_Fmt, 0, _Iosbase.flags()),
                                        _Significance, _Val))); // convert and put
                }

char *  gcvt ( double value, int num, char * buffer );

Средство            |  1    2    3    4
====================+=====================
sprintf             |  -    +    +    +
------------------------------------------
gcvt, ecvt, fcvt    |  -    -    +    +
------------------------------------------
stringstream        |  +    +    -    -
------------------------------------------
boost::lexical_cast |  +    -    -    - 
------------------------------------------

char buf[BUF_SIZE];
float f = 0.4;
sprintf(buf, "%f", f);

AD>Средство            |  1    2    3    4
AD>====================+=====================
AD>sprintf             |  -    +    +    +
AD>------------------------------------------
AD>gcvt, ecvt, fcvt    |  -    -    +    +
AD>------------------------------------------
AD>stringstream        |  +    +    -    -
AD>------------------------------------------
AD>boost::lexical_cast |  +    -    -    - 
AD>------------------------------------------
AD>

AD>Как видно, четырёх плюсов подряд нигде не наблюдаеся

// шестнадцатиричный форматтер - может использоваться с любыми семантически подходящими типами
template<typename T>
struct hex_t
{
  T value;
  explicit hex_t(T val): value(val) {}
};

template<typename T>
hex_t<T> hex(T const& val) { return hex_t<T>(val); }

// объявления шаблонов преобразования
tempalte<typename OutIt>
OutIt stringize(OutIt it, unsigned x);

tempalte<typename OutIt>
OutIt stringize(OutIt it, signed x);

tempalte<typename OutIt>
OutIt stringize(OutIt it, hex_t<unsigned> x);

tempalte<typename OutIt>
OutIt stringize(OutIt it, hex_t<signed> x);

// здесь мы несколько выбиваемся из стиля, но должнен же быть шаблон для удобной работы с массивом символов,
// терминирующий нулем и возвращающий указатель на НАЧАЛО массива
template<typename Char, typename T>
Char* stringize_to_array(Char* buf, T const& x)
{
  *stringize(buf, x) = 0;
  return buf;
}

void test()
{
  std::string s;
  stringize(std::back_inserter(s), hex(12345));

  stringize(std::ostreambuf_iterator<wchar_t>(std::wcout), 12345);

  char buf[32];
  std::cout << stringize_to_array(buf, 12345);
}