应用器、操纵器和函数对象

应用器与操纵器

操纵器:以某种方式作用于他的参数所表示的数据.
应用器: 重载一个运算符,他的操作数是一个可操作的值和一个作用于这个值的操纵器.

问题

在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 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 
stype& operator<<(stype& o, const func_obj& im) {
    return im(o);
}

重写hexconv

func_obj hexconv(long n) {
    ostream& (*f)(ostream&, long) = hexconv; // 这里的hexconv是前面重载版本的第一个.
    return func_obj(f, n);
}

使用方式没有任何改变.

思考

如果采用C++11 的Functional提供的工具,我们是不是还可以扩展到任意多参数的场景?
采用template 进行扩展.
func_obj的成员将变为

template 
class func_obj {
private:
    std::function f;
    typedef std::tuple::type...> _Td;
    _Td args;
};

构造函数和operator()的实现:

template 
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 f;
    typedef std::tuple::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 
inline _LIBCPP_INLINE_VISIBILITY
basic_ostream<_CharT, _Traits>&
endl(basic_ostream<_CharT, _Traits>& __os)
{
    __os.put(__os.widen('\n'));
    __os.flush();
}

可以发现他的实现跟我们的实现基本上是一致的.