我可以使std::ostream对象以十六进制形式输出整数

std::cout << std::hex << 0xabc; //prints `abc`, not the base-10 representation

是否有适用于所有基地的通用机械手?就像是
std::cout << std::base(4) << 20; //I want this to output 110

如果有一个,那么我没有其他问题了。
如果没有,那我可以写一个吗?是否不需要我访问std::ostream的私有(private)实现详细信息?

请注意,我知道我可以编写一个接受数字并将其转换为字符串的函数,该字符串以任何基数表示该数字。或者,我可以使用已经存在的一种。我问的是自定义流操纵器-它们可能吗?

提前致谢

最佳答案

您可以执行以下操作。我已经对代码进行了注释,以解释每个部分的功能,但本质上是这样的:

  • 创建一个“操纵器”结构,使用 xalloc iword 在流中存储一些数据。
  • 创建一个自定义 num_put 构面,该构面将查找您的操纵器并应用操纵。

  • 这是代码...

    编辑:请注意,我不确定我在这里是否正确处理了std::ios_base::internal标志-因为我实际上不知道其用途。

    编辑2:我了解了std::ios_base::internal的用途,并更新了代码以对其进行处理。

    编辑3:添加了对std::locacle::global的调用,以显示默认情况下如何使所有标准流类支持新的流操纵器,而不必对它们进行imbue
    #include <algorithm>
    #include <cassert>
    #include <climits>
    #include <iomanip>
    #include <iostream>
    #include <locale>
    
    namespace StreamManip {
    
    // Define a base manipulator type, its what the built in stream manipulators
    // do when they take parameters, only they return an opaque type.
    struct BaseManip
    {
        int mBase;
    
        BaseManip(int base) : mBase(base)
        {
            assert(base >= 2);
            assert(base <= 36);
        }
    
        static int getIWord()
        {
            // call xalloc once to get an index at which we can store data for this
            // manipulator.
            static int iw = std::ios_base::xalloc();
            return iw;
        }
    
        void apply(std::ostream& os) const
        {
            // store the base value in the manipulator.
            os.iword(getIWord()) = mBase;
        }
    };
    
    // We need this so we can apply our custom stream manipulator to the stream.
    std::ostream& operator<<(std::ostream& os, const BaseManip& bm)
    {
        bm.apply(os);
        return os;
    }
    
    // convience function, so we can do std::cout << base(16) << 100;
    BaseManip base(int b)
    {
        return BaseManip(b);
    }
    
    // A custom number output facet.  These are used by the std::locale code in
    // streams.  The num_put facet handles the output of numberic values as characters
    // in the stream.  Here we create one that knows about our custom manipulator.
    struct BaseNumPut : std::num_put<char>
    {
        // These absVal functions are needed as std::abs doesnt support
        // unsigned types, but the templated doPutHelper works on signed and
        // unsigned types.
        unsigned long int absVal(unsigned long int a) const
        {
            return a;
        }
    
        unsigned long long int absVal(unsigned long long int a) const
        {
            return a;
        }
    
        template <class NumType>
        NumType absVal(NumType a) const
        {
            return std::abs(a);
        }
    
        template <class NumType>
        iter_type doPutHelper(iter_type out, std::ios_base& str, char_type fill, NumType val) const
        {
            // Read the value stored in our xalloc location.
            const int base = str.iword(BaseManip::getIWord());
    
            // we only want this manipulator to affect the next numeric value, so
            // reset its value.
            str.iword(BaseManip::getIWord()) = 0;
    
            // normal number output, use the built in putter.
            if (base == 0 || base == 10)
            {
                return std::num_put<char>::do_put(out, str, fill, val);
            }
    
            // We want to conver the base, so do it and output.
            // Base conversion code lifted from Nawaz's answer
    
            int digits[CHAR_BIT * sizeof(NumType)];
            int i = 0;
            NumType tempVal = absVal(val);
    
            while (tempVal != 0)
            {
                digits[i++] = tempVal % base;
                tempVal /= base;
            }
    
            // Get the format flags.
            const std::ios_base::fmtflags flags = str.flags();
    
            // Add the padding if needs by (i.e. they have used std::setw).
            // Only applies if we are right aligned, or none specified.
            if (flags & std::ios_base::right ||
                !(flags & std::ios_base::internal || flags & std::ios_base::left))
            {
                std::fill_n(out, str.width() - i, fill);
            }
    
            if (val < 0)
            {
                *out++ = '-';
            }
    
            // Handle the internal adjustment flag.
            if (flags & std::ios_base::internal)
            {
                std::fill_n(out, str.width() - i, fill);
            }
    
            char digitCharLc[] = "0123456789abcdefghijklmnopqrstuvwxyz";
            char digitCharUc[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    
            const char *digitChar = (str.flags() & std::ios_base::uppercase)
                ? digitCharUc
                : digitCharLc;
    
            while (i)
            {
                // out is an iterator that accepts characters
                *out++ = digitChar[digits[--i]];
            }
    
            // Add the padding if needs by (i.e. they have used std::setw).
            // Only applies if we are left aligned.
            if (str.flags() & std::ios_base::left)
            {
                std::fill_n(out, str.width() - i, fill);
            }
    
            // clear the width
            str.width(0);
    
            return out;
        }
    
        // Overrides for the virtual do_put member functions.
    
        iter_type do_put(iter_type out, std::ios_base& str, char_type fill, long val) const
        {
            return doPutHelper(out, str, fill, val);
        }
    
        iter_type do_put(iter_type out, std::ios_base& str, char_type fill, unsigned long val) const
        {
            return doPutHelper(out, str, fill, val);
        }
    };
    
    } // namespace StreamManip
    
    int main()
    {
        // Create a local the uses our custom num_put
        std::locale myLocale(std::locale(), new StreamManip::BaseNumPut());
    
        // Set our locacle to the global one used by default in all streams created
        // from here on in.  Any streams created in this app will now support the
        // StreamManip::base modifier.
        std::locale::global(myLocale);
    
        // imbue std::cout, so it uses are custom local.
        std::cout.imbue(myLocale);
        std::cerr.imbue(myLocale);
    
        // Output some stuff.
        std::cout << std::setw(50) << StreamManip::base(2) << std::internal << -255 << std::endl;
        std::cout << StreamManip::base(4) << 255 << std::endl;
        std::cout << StreamManip::base(8) << 255 << std::endl;
        std::cout << StreamManip::base(10) << 255 << std::endl;
        std::cout << std::uppercase << StreamManip::base(16) << 255 << std::endl;
    
        return 0;
    }
    

    关于c++ - 自定义流操纵器,用于以任意基数流式传输整数,我们在Stack Overflow上找到一个类似的问题:https://stackoverflow.com/questions/6478745/

    10-13 06:29