C++ 標准庫之iomanip

 

istream & istream::get(char *, int, char = '\n');
istream & istream::getline(char *, int, char = '\n');
作用: 從文本中提取指定個數的字符串, 並在串數組末尾添加一個空字符.
區別: get() 不從流中提取終止字符, 終止字符仍在輸入流中. getline() 從流中提取終止字符, 但終止字符被丟棄.

 

C++ 語言下
頭文件：#include <iomanip>
說明：是I/O流控制頭文件,就像C里面的格式化輸出一樣

 

編號	方法和描述
1	setiosflags - 它用於設置格式標志。
2	resetiosflags - 用於重置格式標志。
3	setbase - 它用於設置basefield標志。
4	setfill - 它用於設置填充字符
5	setprecision - 它用於設置小數精度。
6	setw - 它用於設置字段寬度。
7	get_money - 它用於獲得貨幣值。
8	put_money - 它用來設置計算貨幣的值。
9	get_time - 它用於獲取日期和時間。
10	put_time - 它用於放置（或設置）日期和時間。

 

控   制   符	作           用
dec	設置整數為十進制
hex	設置整數為十六進制
oct	設置整數為八進制
setbase(n)	設置整數為n進制(n=8,10,16)
setfill(n)	設置字符填充，c可以是字符常或字符變量
setprecision(n)	設置浮點數的有效數字為n位
setw(n)	設置字段寬度為n位
setiosflags(ios::fixed)	設置浮點數以固定的小數位數顯示
setiosflags(ios::scientific)	設置浮點數以科學計數法表示
setiosflags(ios::left)	輸出左對齊
setiosflags(ios::right)	輸出右對齊
setiosflags(ios::skipws)	忽略前導空格
setiosflags(ios::uppercase)	在以科學計數法輸出E與十六進制輸出X以大寫輸出，否則小寫。
setiosflags(ios::showpos)	輸出正數時顯示"+"號
setiosflags(ios::showpoint)	強制顯示小數點
resetiosflags()	終止已經設置的輸出格式狀態，在括號中應指定內容

 

在此需要說一下，有效位數默認是6位，即setprecision(6)，即小數點前面和小數點后面加起來的位數為6個有效數字（注意會四舍五入）。
另外，科學計數法輸出E與十六進制輸出默認是以小寫的，要換成大寫需添加uppercase
而setw(n)設置寬度，若是實際寬度大於被設置的，則setw函數此時失效。

 

#include <iostream>
#include <iomanip>
#include <fstream>

int main()
{
    // 前綴0表示八進制 前綴0x表示十六進制 不帶前綴表示十進制
    int a = 123;
    double pi = 22.0/7.0;

    // setbase(n) 設置整數為n進制(n=8,10,16)
    // oct 八進制 dec 十進制 hex 十六進制
    // setiosflags(ios::showbase) 顯示進制的前綴
    // 數值默認十進制顯示輸出
    std::cout << a << std::endl;
    std::cout << "oct: " << std::showbase << std::setbase(8) << a << " " << std::oct << a << std::endl;
    std::cout << "dec: " << std::showbase << std::setbase(10) << a << " " << std::dec << a << std::endl;
    std::cout << "hex: " << std::showbase << std::setbase(16) << a << " " << std::hex << a << std::endl;

    // setprecision(n) 設置浮點數的有效數字為n位
    // 有效位數默認是6位，即setprecision(6)，即小數點前面和小數點后面加起來的位數為6個有效數字（注意會四舍五入）
    std::cout << pi << std::endl;
    std::cout << std::setprecision(12) << pi << std::endl;

    // setfill(n) 設置字符填充，c可以是字符常或字符變量
    // setw(n) 設置字段寬度為n位, 若是實際寬度大於被設置的，則setw函數此時失效, 只針對其后的第一個輸出項有效
    // setiosflags(ios::left) 輸出左對齊
    // setiosflags(ios::right) 輸出右對齊 默認右對齊
    std::cout << std::setfill('*') << std::setw(20) << std::setprecision(12) << pi << std::endl;
    std::cout << std::setfill('*') << std::setw(20) << std::setprecision(12) << std::right << pi << std::endl;
    std::cout << std::setfill('*') << std::setw(20) << std::setprecision(12) << std::left << pi << std::endl;

    // setiosflags(ios::fixed) 設置浮點數以固定的小數位數顯示
    std::cout << std::fixed << std::setprecision(12) << pi << std::endl;

    // setiosflags(ios::scientific)  設置浮點數以科學計數法表示 科學計數法輸出E與十六進制輸出默認是以小寫的，要換成大寫需添加uppercase
    std::cout << std::scientific << std::setprecision(12) << pi << std::endl;
    std::cout << std::scientific << std::uppercase << std::setprecision(12) << pi << std::endl;

    // resetiosflags() 終止已經設置的輸出格式狀態，在括號中應指定內容
    std::cout << std::setiosflags(std::ios::scientific) << std::setprecision(12) << pi << "   " << std::resetiosflags(std::ios::scientific) << pi << std::endl;

    system("pause");
    return 0;
}

 

運行結果：

 

 msvc 11.0 Visual Studio 2012  中iomanip頭文件內容：

// iomanip standard header
#pragma once
#ifndef _IOMANIP_
#define _IOMANIP_
#ifndef RC_INVOKED
#include <istream>

#include <type_traits>

#include <xlocmon>
#include <xloctime>

 #pragma pack(push,_CRT_PACKING)
 #pragma warning(push,3)
 #pragma push_macro("new")
 #undef new

_STD_BEGIN
        // TEMPLATE STRUCT _Fillobj
template<class _Elem>
    struct _Fillobj
    {    // store fill character
    _Fillobj(_Elem _Ch)
        : _Fill(_Ch)
        {    // construct from fill character
        }

    _Elem _Fill;    // the fill character
    };

        // TEMPLATE FUNCTION setfill
template<class _Elem> inline
    _Fillobj<_Elem> setfill(_Elem _Ch)
    {    // return a _Fillobj manipulator
    return (_Fillobj<_Elem>(_Ch));
    }

template<class _Elem,
    class _Traits,
    class _Elem2> inline
    basic_istream<_Elem, _Traits>&
        operator>>(basic_istream<_Elem, _Traits>& _Istr,
            const _Fillobj<_Elem2>& _Manip)
    {    // set fill character in input stream
    static_assert((is_same<_Elem, _Elem2>::value),
        "wrong character type for setfill");

    _Istr.fill(_Manip._Fill);
    return (_Istr);
    }

template<class _Elem,
    class _Traits,
    class _Elem2> inline
    basic_ostream<_Elem, _Traits>&
        operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
            const _Fillobj<_Elem2>& _Manip)
    {    // set fill character in output stream
    static_assert((is_same<_Elem, _Elem2>::value),
        "wrong character type for setfill");

    _Ostr.fill(_Manip._Fill);
    return (_Ostr);
    }

 #if _HAS_CPP0X
        // TEMPLATE STRUCT _Monobj
template<class _Money>
    struct _Monobj
    {    // store reference to monetary amount
    _Monobj(_Money& _Val_arg, bool _Intl_arg)
        : _Val(_Val_arg), _Intl(_Intl_arg)
        {    // construct from monetary amount reference and int'l flag
        }

    _Money& _Val;    // the monetary amount reference
    bool _Intl;        // international flag

    private:
        _Monobj& operator=(const _Monobj&);
    };

        // TEMPLATE FUNCTION get_money
template<class _Money> inline
    _Monobj<_Money> get_money(_Money& _Val_arg,
        bool _Intl_arg = false)
    {    // return a _Monobj manipulator
    return (_Monobj<_Money>(_Val_arg, _Intl_arg));
    }

template<class _Elem,
    class _Traits,
    class _Money> inline
    basic_istream<_Elem, _Traits>&
        operator>>(basic_istream<_Elem, _Traits>& _Istr,
            const _Monobj<_Money>& _Manip)
    {    // get monetary amount from input stream
    typedef basic_istream<_Elem, _Traits> _Myis;
    typedef istreambuf_iterator<_Elem, _Traits> _Iter;
    typedef money_get<_Elem, _Iter> _Mymget;

    ios_base::iostate _State = ios_base::goodbit;
    const typename _Myis::sentry _Ok(_Istr);

    if (_Ok)
        {    // state okay, extract monetary amount
        const _Mymget& _Mget_fac = _USE(_Istr.getloc(), _Mymget);
        _TRY_IO_BEGIN
        _Mget_fac.get(_Iter(_Istr.rdbuf()), _Iter(0), _Manip._Intl,
            _Istr, _State, _Manip._Val);
        _CATCH_IO_(_Istr)
        }

    _Istr.setstate(_State);
    return (_Istr);
    }

        // TEMPLATE FUNCTION put_money
template<class _Money> inline
    _Monobj<const _Money>
        put_money(const _Money& _Val_arg,
            bool _Intl_arg = false)
    {    // return a _Monobj manipulator
    return (_Monobj<const _Money>(_Val_arg, _Intl_arg));
    }

template<class _Elem,
    class _Traits,
    class _Money> inline
    basic_ostream<_Elem, _Traits>&
        operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
            const _Monobj<_Money>& _Manip)
    {    // put monetary amount to output stream
    typedef basic_ostream<_Elem, _Traits> _Myos;
    typedef ostreambuf_iterator<_Elem, _Traits> _Iter;
    typedef money_put<_Elem, _Iter> _Mymput;

    ios_base::iostate _State = ios_base::goodbit;
    const typename _Myos::sentry _Ok(_Ostr);

    if (_Ok)
        {    // state okay, insert monetary amount
        const _Mymput& _Mput_fac = _USE(_Ostr.getloc(), _Mymput);
        _TRY_IO_BEGIN
        if (_Mput_fac.put(_Iter(_Ostr.rdbuf()), _Manip._Intl,
            _Ostr, _Ostr.fill(), _Manip._Val).failed())
                _State |= ios_base::badbit;
        _CATCH_IO_(_Ostr)
        }

    _Ostr.setstate(_State);
    return (_Ostr);
    }

        // TEMPLATE STRUCT _Timeobj
template<class _Elem>
    struct _Timeobj
    {    // store reference to tm object and format
    _Timeobj(struct tm *_Tptr_arg, const _Elem *_Fmt_arg)
        : _Tptr(_Tptr_arg), _Fmtfirst(_Fmt_arg)
        {    // construct from tm pointer and format pointer
        for (_Fmtlast = _Fmtfirst; *_Fmtlast != 0; ++_Fmtlast)
            ;    // find end of format string
        }

    struct tm *_Tptr;    // the tm struct pointer
    const _Elem *_Fmtfirst;    // format string start
    const _Elem *_Fmtlast;    // format string end
    };

        // TEMPLATE FUNCTION get_time
template<class _Elem> inline
    _Timeobj<_Elem>
        get_time(struct tm *_Tptr_arg, const _Elem *_Fmt_arg)
    {    // return a _Timeobj manipulator
    return (_Timeobj<_Elem>(_Tptr_arg, _Fmt_arg));
    }

template<class _Elem,
    class _Traits,
    class _Elem2> inline
    basic_istream<_Elem, _Traits>&
        operator>>(basic_istream<_Elem, _Traits>& _Istr,
            const _Timeobj<_Elem2>& _Manip)
    {    // get time information from input stream
    typedef basic_istream<_Elem, _Traits> _Myis;
    typedef istreambuf_iterator<_Elem, _Traits> _Iter;
    typedef time_get<_Elem2, _Iter> _Mytget;

    static_assert((is_same<_Elem, _Elem2>::value),
        "wrong character type for get_time");

    ios_base::iostate _State = ios_base::goodbit;
    const typename _Myis::sentry _Ok(_Istr);

    if (_Ok)
        {    // state okay, extract time amounts
        const _Mytget& _Tget_fac = _USE(_Istr.getloc(), _Mytget);
        _TRY_IO_BEGIN
        _Tget_fac.get(_Iter(_Istr.rdbuf()), _Iter(0), _Istr, _State,
            _Manip._Tptr, _Manip._Fmtfirst, _Manip._Fmtlast);
        _CATCH_IO_(_Istr)
        }

    _Istr.setstate(_State);
    return (_Istr);
    }

        // TEMPLATE FUNCTION put_time
template<class _Elem> inline
    _Timeobj<_Elem>
        put_time(struct tm *_Tptr_arg, const _Elem *_Fmt_arg)
    {    // return a _Timeobj manipulator
    return (_Timeobj<_Elem>(_Tptr_arg, _Fmt_arg));
    }

template<class _Elem,
    class _Traits,
    class _Elem2> inline
    basic_ostream<_Elem, _Traits>&
        operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
            const _Timeobj<_Elem2>& _Manip)
    {    // put time information to output stream
    typedef basic_ostream<_Elem, _Traits> _Myos;
    typedef ostreambuf_iterator<_Elem, _Traits> _Iter;
    typedef time_put<_Elem2, _Iter> _Mytput;

    static_assert((is_same<_Elem, _Elem2>::value),
        "wrong character type for put_time");

    ios_base::iostate _State = ios_base::goodbit;
    const typename _Myos::sentry _Ok(_Ostr);

    if (_Ok)
        {    // state okay, insert monetary amount
        const _Mytput& _Tput_fac = _USE(_Ostr.getloc(), _Mytput);
        _TRY_IO_BEGIN
        if (_Tput_fac.put(_Iter(_Ostr.rdbuf()), _Ostr, _Ostr.fill(),
            _Manip._Tptr, _Manip._Fmtfirst, _Manip._Fmtlast).failed())
            _State |= ios_base::badbit;
        _CATCH_IO_(_Ostr)
        }

    _Ostr.setstate(_State);
    return (_Ostr);
    }
 #endif /* _HAS_CPP0X */

        // TEMPLATE STRUCT _Smanip
template<class _Arg>
    struct _Smanip
    {    // store function pointer and argument value
    _Smanip(void (__cdecl *_Left)(ios_base&, _Arg), _Arg _Val)
        : _Pfun(_Left), _Manarg(_Val)
        {    // construct from function pointer and argument value
        }

    void (__cdecl *_Pfun)(ios_base&, _Arg);    // the function pointer
    _Arg _Manarg;    // the argument value
    };

template<class _Elem,
    class _Traits,
    class _Arg> inline
    basic_istream<_Elem, _Traits>& operator>>(
        basic_istream<_Elem, _Traits>& _Istr, const _Smanip<_Arg>& _Manip)
    {    // extract by calling function with input stream and argument
    (*_Manip._Pfun)(_Istr, _Manip._Manarg);
    return (_Istr);
    }

template<class _Elem,
    class _Traits,
    class _Arg> inline
    basic_ostream<_Elem, _Traits>& operator<<(
        basic_ostream<_Elem, _Traits>& _Ostr, const _Smanip<_Arg>& _Manip)
    {    // insert by calling function with output stream and argument
    (*_Manip._Pfun)(_Ostr, _Manip._Manarg);
    return (_Ostr);
    }

        // INSTANTIATIONS
_MRTIMP2 _Smanip<ios_base::fmtflags> __cdecl resetiosflags(ios_base::fmtflags);
_MRTIMP2 _Smanip<ios_base::fmtflags> __cdecl setiosflags(ios_base::fmtflags);
_MRTIMP2 _Smanip<int> __cdecl setbase(int);
_MRTIMP2 _Smanip<streamsize> __cdecl setprecision(streamsize);
_MRTIMP2 _Smanip<streamsize> __cdecl setw(streamsize);
_STD_END
 #pragma pop_macro("new")
 #pragma warning(pop)
 #pragma pack(pop)
#endif /* RC_INVOKED */
#endif /* _IOMANIP_ */

/*
 * Copyright (c) 1992-2012 by P.J. Plauger.  ALL RIGHTS RESERVED.
 * Consult your license regarding permissions and restrictions.
V6.00:0009 */

 

 

如何確定VS編譯器版本

_MSC_VER是MSVC編譯器的內置宏，定義了編譯器的版本，_MSC_VER 值對應版本關系
MSVC++ 11.0 _MSC_VER = 1700 (Visual Studio 2012)
MSVC++ 10.0 _MSC_VER = 1600 (Visual Studio 2010)
MSVC++ 9.0 _MSC_VER = 1500 (Visual Studio 2008)
MSVC++ 8.0 _MSC_VER = 1400 (Visual Studio 2005)
MSVC++ 7.1 _MSC_VER = 1310 (Visual Studio 2003)
MSVC++ 7.0 _MSC_VER = 1300 (Visual Studio 2002)
MSVC++ 6.0 _MSC_VER = 1200
MSVC++ 5.0 _MSC_VER = 1100

example：
#if (_MSC_VER == 1300) //vc7
#import "acax16ENU.tlb" no_implementation raw_interfaces_only named_guids
#elif (_MSC_VER == 1200) //vc6
#import "acad.tlb" no_implementation raw_interfaces_only named_guids
#elif (_MSC_VER == 1400) //vc8
#import "acax17ENU.tlb" no_implementation raw_interfaces_only named_guids
#elif (_MSC_VER == 1500) //vc9
#import "acax18ENU.tlb" no_implementation raw_interfaces_only named_guids
#endif

在程序中加入_MSC_VER宏可以根據編譯器版本讓編譯器選擇性地編譯一段程序。例如一個版本編譯器產生的lib文件可能不能被另一個版
本的編譯器調用，那么在開發應用程序的時候，在該程序的lib調用庫中放入多個版本編譯器產生的lib文件。在程序中加入_MSC_VER宏
，編譯器就能夠在調用的時根據其版本自動選擇可以鏈接的lib庫版本，如下所示。
#if _MSC_VER >= 1400 // for vc8, or vc9
#ifdef _DEBUG
#pragma comment( lib, "SomeLib-vc8-d.lib" )
#else if
#pragma comment( lib, "SomeLib-vc8-r.lib" )
#endif
#else if _MSC_VER >= 1310 // for vc71
#ifdef _DEBUG
#pragma comment( lib, "SomeLib-vc71-d.lib" )
#else if
#pragma comment( lib, "SomeLib-vc71-r.lib" )
#endif
#else if _MSC_VER >=1200 // for vc6
#ifdef _DEBUG
#pragma comment( lib, "SomeLib-vc6-d.lib" )
#else if
#pragma comment( lib, "SomeLib-vc6-r.lib" )
#endif
#endif