应用器与操纵器
操纵器:以某种方式作用于他的参数所表示的数据.
应用器: 重载一个运算符,他的操作数是一个可操作的值和一个作用于这个值的操纵器.
问题
在C++中我们可以通过重载operator<<来将指定的类型对象输出到输出流中,例如:std::cout << value;我们通过观察STL提供的std::endl发现,他可以将输出缓冲区清空.即:std::cout << std::endl;将会把cout的输出缓冲期清空,并且完成换行.假设我们也有一个清空缓冲区的函数flush,他将接收一个参数ostream&类型,并且返回一样的类型,则他的实现应该是:
ostream& flush(ostream& file) {
// do something
return file;
}
这样我们可以用这个flush函数来部分替代std::endl.但是我们还不能写std::cout << flush;只能flush(std::cout);
如何才能按照std::endl的方式书写呢?
一种解决方案
由于flush只是一个函数,他不能重载operator<<,所以我们就搞一个类型,然后让这个类型重载operator<<.
ostream& flush(ostream& file) {
// do something
return file;
}
class FLUSHTYPE{};
FLUSHTYPE FULSH;
ostream& operator<<(ostream& o, FLUSHTYPE f) {
return flush(o);
}
现在我们可以使用FLUSH这个对象进行
cout << x << FLUSH << y << FLUSH << z << FLUSH;
的操作了.
但是上面的解决方案仅仅是为了重载operator<<而引入了一个新的类型,而且我们还必须定义一个这个类型的对象才行.
让我们来看看使用函数指针能给我们带来什么方便的地方.
另一种解决方案
我们舍弃掉上面的FLUSHTYPE类型的定义,而是直接通过函数指针类型重载operator<<.
ostream& operator<<(ostream& o, ostream& (*f)(ostream&)) {
return (*f)(o);
}
由于flush函数是符合条件的参数,所以cout << flush;
上面的例子中flush就是操纵器,operator<<则是应用器.
多个参数
通过上面的例子我们发现操纵器和应用器看起来是很有用的工具.那么我们能不能把这两个概念扩充到所有的函数上呢?
假设我们希望提供一个函数,对于给定的数字可以转换为人可以读懂的16进制值.在打印的时候我们希望cout << to_hex(n);就可以了.
首先我们需要考虑to_hex(n)的返回值类型应该是什么?如果我们不想依赖任何string类库的情况下,我们应该返回的是一个char*.那么我们什么时候释放掉内存呢?
参考下面的方案:
- 先定义一个函数对象,这个函数对象重载
operator<<.
class long_fn_obj {
public:
long_fn_obj(ostream& (*f)(ostream&, long ) , long value): func(f), n(value) {}
ostream& operator<<(ostream& 0) {
return (*func)(o, n);
}
private:
ostream& (*func)(ostream& , long);
long n;
};
- 定义long_fn_obj需要的第一个参数的函数:
ostream& hexconv(ostream& o, long n) {
return o << to_hex(n);
}
这里因为我们一旦执行过to_hex(n)以后马上就输出到了ostream中,所以不存在内存分配释放的问题.
- 重载hexconv函数
long_fn_obj hexconv(long n){
retrun long_fn_obj( (ostream& (*)(ostream&, long )) hexconv, n); // 这里强制类型转换,使用第一个版本的重载.
}
现在则可以使用hexconv了:
cout << hexconv(m) << " " << hexconv(n);
简化
我们将上面实现的hexconv进行泛型化.
- 首先实现函数对象的模板类
template <class stype, class vtype>
class func_obj {
public:
func_obj(stype& (*f)(stype&, vtype), vtype v):fn(f), val(v) {}
stype& operator() (stype& o) {
return (*fn)(o, val);
}
private:
stype& (*fn)(stype&, vtype);
vtype val;
};
- 应用器模板:
template <class stype, class vtype>
stype& operator<<(stype& o, const func_obj<stype, vtype>& im) {
return im(o);
}
- 重写hexconv
func_obj<ostream, long> hexconv(long n) {
ostream& (*f)(ostream&, long) = hexconv; // 这里的hexconv是前面重载版本的第一个.
return func_obj<ostream, long>(f, n);
}
使用方式没有任何改变.
思考
如果采用C++11 的Functional提供的工具,我们是不是还可以扩展到任意多参数的场景?
采用template <class stype, class ...ArgsType>进行扩展.
func_obj的成员将变为
template <class stype, class ...ArgsType>
class func_obj {
private:
std::function<stype&(*)(stype&, ArgsType...)> f;
typedef std::tuple<typename std::decay<ArgsType>::type...> _Td;
_Td args;
};
构造函数和operator()的实现:
template <class stype, class ...ArgsType>
class func_obj {
public:
func_obj(stype& (*func)(stype&, ArgsType...), ArgsType... arg): f(func), args(arg...) {}
stype& operator() (stype& o) {
return f(o, std::forward(args));
}
private:
std::function<stype&(*)(stype&, ArgsType...)> f;
typedef std::tuple<typename std::decay<ArgsType>::type...> _Td;
_Td args;
};
llvm实现的std::endl
最后我们来看下标准库使用操纵器和应用器实现的std::endl
// 应用器:这个是定义在类basic_ostream中
inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
basic_ostream& operator<<(basic_ostream& (*__pf)(basic_ostream&))
{ return __pf(*this); }
// 操纵器
template <class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
basic_ostream<_CharT, _Traits>&
endl(basic_ostream<_CharT, _Traits>& __os)
{
__os.put(__os.widen('\n'));
__os.flush();
}
可以发现他的实现跟我们的实现基本上是一致的.
