如何解决自定义流操纵器,用于以任意基数流式传输整数
| 我可以使一个“ 0”对象以十六进制输出整数std::cout << std::hex << 0xabc; //prints `abc`,not the base-10 representation
是否有适用于所有基地的通用机械手?就像是
std::cout << std::base(4) << 20; //I want this to output 110
如果有一个,那么我没有其他问题了。
如果没有,那我可以写一个吗?是否不需要我访问“ 0”的私有实现详细信息?
请注意,我知道我可以编写一个接受数字并将其转换为字符串的函数,该字符串以任何基数表示该数字。或者,我可以使用已经存在的一种。我问的是自定义流操纵器-它们可能吗?
提前致谢
解决方法
您可以执行以下操作。我已对代码进行了注释,以解释每个部分的功能,但本质上是这样的:
创建一个\“ manipulator \”结构,使用
xalloc
和iword
在流中存储一些数据。
创建一个自定义num_put
构面,该构面将查找您的操纵器并应用操纵。
这是代码...
编辑:请注意,我不确定我在这里是否正确处理了std::ios_base::internal
标志-因为我实际上不知道其用途。
编辑2:我找出ѭ7的含义,并更新了代码来处理。
编辑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,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,fill);
}
// clear the width
str.width(0);
return out;
}
// Overrides for the virtual do_put member functions.
iter_type do_put(iter_type out,long val) const
{
return doPutHelper(out,val);
}
iter_type do_put(iter_type out,unsigned long val) const
{
return doPutHelper(out,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;
}
, 定制操纵器确实是可能的。例如,请参阅此问题。我对通用基础不熟悉。
, 您确实有两个独立的问题。我想您正在询问的那个问题完全可以解决。不幸的是,另一个则不是这样。
在流中分配和使用一些空间来保持某些流状态是可以预见的问题。流具有几个成员(xalloc
,iword
,pword
),这些成员使您可以在流中的数组中分配位置,并在其中读取/写入数据。这样,流操纵器本身是完全可能的。您基本上会使用ѭ4来在流的数组中分配一个点来保存当前基数,插入运算符在转换数字时将使用该点。
我看不到解决方案的问题相当简单:标准库已经提供了一个ѭ16来将ѭ17插入流中,并且它显然不知道您的假设数据为转换奠定了基础。您不能重载它,因为它需要与现有签名完全相同的签名,因此您的重载将是模棱两可的。
int
,short
等的重载是成员函数的重载。我想,如果您想做的足够厉害,可以使用模板重载operator<<
。如果我没记错的话,那将比库提供的非模板函数的精确匹配更好。您仍然会违反规则,但是如果将这样的模板放在命名空间std中,则至少有一定机会可以使用它。
, 我试图编写代码,但它有一些限制。正如其他人(尤其是@Jerry)所指出的那样,它不是流操纵器,因此根本不可能。
这是我的代码:
struct base
{
mutable std::ostream *_out;
int _value;
base(int value=10) : _value(value) {}
template<typename T>
const base& operator << (const T & data) const
{
*_out << data;
return *this;
}
const base& operator << (const int & data) const
{
switch(_value)
{
case 2:
case 4:
case 8: return print(data);
case 16: *_out << std::hex << data; break;
default: *_out << data;
}
return *this;
}
const base & print(int data) const
{
int digits[CHAR_BIT * sizeof(int)],i = 0;
while(data)
{
digits[i++] = data % _value;
data /= _value;
}
while(i) *_out << digits[--i] ;
return *this;
}
friend const base& operator <<(std::ostream& out,const base& b)
{
b._out = &out;
return b;
}
};
这是测试代码:
int main() {
std::cout << base(2) << 255 <<\",\" << 54 << \",\" << 20<< \"\\n\";
std::cout << base(4) << 255 <<\",\" << 20<< \"\\n\";
std::cout << base(8) << 255 <<\",\" << 20<< \"\\n\";
std::cout << base(16) << 255 <<\",\" << 20<< \"\\n\";
}
输出:
11111111,110110,10100
3333,312,110
377,66,24
ff,36,14
在线演示:http://www.ideone.com/BWhW5
局限性:
基本不能更改两次。所以这将是一个错误:
std::cout << base(4) << 879 << base(8) << 9878 ; //error
使用ѭ25after后不能使用其他机械手:
std::cout << base(4) << 879 << std::hex << 9878 ; //error
std::cout << std::hex << 879 << base(8) << 9878 ; //ok
使用base
后不能使用std::endl
:
std::cout << base(4) << 879 << std::endl ; //error
//that is why I used \"\\n\" in the test code.
, 我不认为任意流都可以使用语法(使用操纵器,@ gigantt链接了显示一些替代性非操纵器解决方案的答案)。标准操纵器仅设置在流内部实现的选项。
OTOH,您当然可以使以下语法起作用:
std::cout << base(4,20);
其中“ 25”是提供流插入运算符的对象(无需返回临时“ 32”)。
版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 dio@foxmail.com 举报,一经查实,本站将立刻删除。