49

std :: coutで次のことを行うにはどうすればよいですか?

double my_double = 42.0;
char str[12];
printf_s("%11.6lf", my_double); // Prints " 42.000000"

私はsprintf_sをあきらめて使用する準備ができています。

より一般的には、長いチュートリアルですべてを広げるのではなく、すべてを1か所に一覧表示するstd :: ostreamフォーマットのリファレンスをどこで見つけることができますか?

2017年12月21日編集-以下の私の答えを参照してください。2012年にこの質問をしたときに利用できなかった機能を使用しています。

4

8 に答える 8

81
std::cout << std::fixed << std::setw(11) << std::setprecision(6) << my_double;

追加する必要があります

#include <iomanip>

ストリームマニピュレータが必要です

空の場所を好きな文字で「埋める」ことができます。このような:

std::cout << std::fixed << std::setw(11) << std::setprecision(6) 
          << std::setfill('0') << my_double;
于 2012-08-16T14:30:05.547 に答える
15
std::cout << boost::format("%11.6f") % my_double;

必ず#include <boost\format.hpp>

于 2012-08-16T14:40:19.387 に答える
8

C ++ 20では、次のことができるようになります

double my_double = 42.0;
char str[12];
std::format_to_n(str, sizeof(str), "{:11.6}", my_double); 

また

std::string s = std::format("{:11.6}", my_double); 

それまでの間、の実装を提供する{fmt}ライブラリを使用できますformat_to_n

免責事項:私は{fmt}とC++20の作者ですstd::format

于 2020-07-14T16:24:53.977 に答える
7

一般に、出力の時点での11ようなものを指定することは避けたいと思います。6これは物理的なマークアップであり、論理的なマークアップが必要です。例、、pressureまたはvolume。このようにして、圧力またはボリュームのフォーマット方法を1つの場所で定義し、そのフォーマットが変更された場合でも、プログラム全体を検索してフォーマットを変更する場所を見つける必要はありません(誤って他のフォーマットを変更することもあります)。 。C ++では、さまざまなフォーマットオプションを設定するマニピュレータを定義することでこれを行い、できれば完全な式の最後にそれらを復元します。したがって、次のようなものを書くことになります。

std::cout << pressure << my_double;

私は間違いなく本番コードでは使用しませんが、次のFFmtフォーマッターが迅速なジョブに役立つことがわかりました。

class FFmt : public StateSavingManip
{
public:
    explicit            FFmt(
                            int                 width,
                            int                 prec = 6,
                            std::ios::fmtflags  additionalFlags 
                                    = static_cast<std::ios::fmtflags>(),
                            char                fill = ' ' );

protected:
    virtual void        setState( std::ios& targetStream ) const;

private:
    int                 myWidth;
    int                 myPrec;
    std::ios::fmtflags  myFlags;
    char                myFill;
};

FFmt::FFmt(
    int                 width,
    int                 prec,
    std::ios::fmtflags  additionalFlags,
    char                fill )
    :   myWidth( width )
    ,   myPrec( prec )
    ,   myFlags( additionalFlags )
    ,   myFill( fill )
{
    myFlags &= ~ std::ios::floatfield
    myFlags |= std::ios::fixed
    if ( isdigit( static_cast< unsigned char >( fill ) )
             && (myFlags & std::ios::adjustfield) == 0 ) {
        myFlags |= std::ios::internal
    }
}

void
FFmt::setState( 
    std::ios&           targetStream ) const
{
    targetStream.flags( myFlags )
    targetStream.width( myWidth )
    targetStream.precision( myPrec )
    targetStream.fill( myFill )
}

これにより、次のような記述が可能になります。

std::cout << FFmt( 11, 6 ) << my_double;

そして記録のために:

class StateSavingManip
{
public:
    StateSavingManip( 
            StateSavingManip const& other );
    virtual             ~StateSavingManip();
    void                operator()( std::ios& stream ) const;

protected:
    StateSavingManip();

private:
    virtual void        setState( std::ios& stream ) const = 0;

private:
    StateSavingManip&   operator=( StateSavingManip const& );

private:
    mutable std::ios*   myStream;
    mutable std::ios::fmtflags
                        mySavedFlags;
    mutable int         mySavedPrec;
    mutable char        mySavedFill;
};

inline std::ostream&
operator<<(
    std::ostream&       out,
    StateSavingManip const&
                        manip )
{
    manip( out );
    return out;
}

inline std::istream&
operator>>(
    std::istream&       in,
    StateSavingManip const&
                        manip )
{
    manip( in );
    return in;
}

StateSavingManip.cc:

namespace {

//      We maintain the value returned by ios::xalloc() + 1, and not
//      the value itself.  The actual value may be zero, and we need
//      to be able to distinguish it from the 0 resulting from 0
//      initialization.  The function getXAlloc() returns this value
//      -1, so we add one in the initialization.
int                 getXAlloc();
int                 ourXAlloc = getXAlloc() + 1;

int
getXAlloc()
{
    if ( ourXAlloc == 0 ) {
        ourXAlloc = std::ios::xalloc() + 1;
        assert( ourXAlloc != 0 );
    }
    return ourXAlloc - 1;
}
}

StateSavingManip::StateSavingManip()
    :   myStream( NULL )
{
}

StateSavingManip::StateSavingManip(
    StateSavingManip const&
                        other )
{
    assert( other.myStream == NULL );
}

StateSavingManip::~StateSavingManip()
{
    if ( myStream != NULL ) {
        myStream->flags( mySavedFlags );
        myStream->precision( mySavedPrec );
        myStream->fill( mySavedFill );
        myStream->pword( getXAlloc() ) = NULL;
    }
}

void
StateSavingManip::operator()( 
    std::ios&           stream ) const
{
    void*&              backptr = stream.pword( getXAlloc() );
    if ( backptr == NULL ) {
        backptr      = const_cast< StateSavingManip* >( this );
        myStream     = &stream;
        mySavedFlags = stream.flags();
        mySavedPrec  = stream.precision();
        mySavedFill  = stream.fill();
    }
    setState( stream );
}
于 2012-08-16T15:47:58.557 に答える
6
#include <iostream>
#include <iomanip>

int main() {
    double my_double = 42.0;
    std::cout << std::fixed << std::setw(11)
        << std::setprecision(6) << my_double << std::endl;
    return 0;
}
于 2012-08-16T14:52:25.040 に答える
2

std :: ostreamで実際のprintfスタイルのフォーマット仕様を好む将来の訪問者のために、別のSO質問でのMartin Yorkの優れた投稿に基づいたさらに別のバリエーションがあります:https ://stackoverflow.com/a/535636 :

#include <iostream>
#include <iomanip>
#include <stdio.h> //snprintf

class FMT
{
public:
    explicit FMT(const char* fmt): m_fmt(fmt) {}
private:
    class fmter //actual worker class
    {
    public:
        explicit fmter(std::ostream& strm, const FMT& fmt): m_strm(strm), m_fmt(fmt.m_fmt) {}
//output next object (any type) to stream:
        template<typename TYPE>
        std::ostream& operator<<(const TYPE& value)
        {
//            return m_strm << "FMT(" << m_fmt << "," << value << ")";
            char buf[40]; //enlarge as needed
            snprintf(buf, sizeof(buf), m_fmt, value);
            return m_strm << buf;
        }
    private:
        std::ostream& m_strm;
        const char* m_fmt;
    };
    const char* m_fmt; //save fmt string for inner class
//kludge: return derived stream to allow operator overloading:
    friend FMT::fmter operator<<(std::ostream& strm, const FMT& fmt)
    {
        return FMT::fmter(strm, fmt);
    }
};

使用例:

double my_double = 42.0;
cout << FMT("%11.6f") << my_double << "more stuff\n";

あるいは:

int val = 42;
cout << val << " in hex is " << FMT(" 0x%x") << val << "\n";
于 2018-02-02T03:09:25.997 に答える
1

それは私、OP、JiveDadsonです-5年後。C++17が現実のものになりつつあります。

完全な転送を備えた可変個引数テンプレートパラメータの出現により、作業が非常に簡単になりました。ostream<<とboost::format%の連鎖した狂気は省くことができます。以下の関数oprintfが請求書に記入します。進行中の作業。エラー処理などについては、お気軽にご連絡ください。

#include <iostream>
#include <string.h>
#include <stdio.h>
#include <string_view>

namespace dj {

    template<class Out, class... Args>
    Out& oprintf(Out &out, const std::string_view &fmt, Args&&... args) {
        const int sz = 512;
        char buffer[sz];
        int cx = snprintf(buffer, sz, fmt.data(), std::forward<Args>(args)...);

        if (cx >= 0 && cx < sz) { 
            return out.write(buffer, cx);
        } else if (cx > 0) {
            // Big output
            std::string buff2;
            buff2.resize(cx + 1);
            snprintf(buff2.data(), cx, fmt.data(), std::forward<Args>(args)...);
            return out.write(buff2.data(), cx);
        } else {
            // Throw?
            return out;
        }
    }
}

int main() {
    const double my_double = 42.0;
    dj::oprintf(std::cout, "%s %11.6lf\n", "My double ", my_double);
    return 0;
}
于 2017-12-22T20:32:09.727 に答える
0

すでにいくつかの素晴らしい答え。それらへの称賛!

これはそれらのいくつかに基づいています。で使用できる唯一の安全な型であるPOD型の型アサーションを追加しましたprintf()

#include <iostream>
#include <stdio.h>
#include <type_traits>

namespace fmt {
namespace detail {

template<typename T>
struct printf_impl
{
    const char* fmt;
    const T v;

    printf_impl(const char* fmt, const T& v) : fmt(fmt), v(v) {}
};

template<typename T>
inline typename std::enable_if<std::is_pod<T>::value, std::ostream& >::type
operator<<(std::ostream& os, const printf_impl<T>& p)
{
    char buf[40];
    ::snprintf(buf, sizeof(buf), p.fmt, p.v, 40);
    return os << buf;
}

} // namespace detail

template<typename T>
inline typename std::enable_if<std::is_pod<T>::value, detail::printf_impl<T> >::type
printf(const char* fmt, const T& v)
{
    return detail::printf_impl<T>(fmt, v);
}

} // namespace fmt

使用例は以下のとおりです。

std::cout << fmt::printf("%11.6f", my_double);

Coliruを試してみてください

于 2020-10-02T09:22:23.790 に答える