如何通过流插入运算符调用成员函数

How can I call a member function via a stream insertion operator?

本文关键字：调用 成员 函数 运算符 插入 何通过      更新时间：2023-10-16

在启用C++11的情况下使用gcc 4.8，我有一个这样的类：

class OutStream {
public:
    OutStream& operator<<(const char* s);
    OutStream& operator<<(int n);
    OutStream& operator<<(unsigned int n);
    // ...
    OutStream& vformat(const char* fmt, __VALIST args);
    OutStream& format(const char* fmt, ...);
};

当我通过直接调用运算符来使用这个类时，它的工作方式与我预期的一样：

OutStream out;
out.operator<<(1).format(" formatted %04X ", 2).operator<<("3n");

输出：

1 formatted 0002 3

现在，我想得到相同的输出，但通过使用<<流式表示法，可能是这样的：

OutStream out;
out << 1 << format(" formatted %04X ", 2) << "3n";

当然，这不会编译，因为流式传输我的OutStream.format()方法没有这样的运算符。

可能有一种解决方案，其中format()是一个返回字符串的自由函数，但这需要首先将format()的所有输出写入缓冲区。我需要一个没有std::string或其他堆或缓冲区使用的解决方案——充其量是一个创建与直接调用运算符时几乎相同代码的解决方案。

有什么建议吗？

编辑，2014-10-20:

  • 为了更好地理解我的需求：我正在使用gcc-arm嵌入式gcc跨工具链进行裸金属嵌入式开发
  • 我需要将该解决方案应用于一些不同的嵌入式目标系统（大多数是Cortex-M0/M3/M4）。其中一些系统的资源非常有限（Ram&Flash），并且我的一部分目标系统必须在不使用任何堆的情况下运行
  • 由于某些原因，我没有使用Stl iostream。但是，iostream标签已通过seh edit设置；由于主题匹配，我会保持它的设置，并且为我的问题找到的解决方案也可能适用于Stl iostream

使用C++14 index_sequence（SO上有一百万种不同的实现）：

template <typename...Ts>
class formatter {
    const char* fmt_;
    std::tuple<Ts...> args_;
    template <std::size_t...Is>
    void expand(OutStream& os, std::index_sequence<Is...>) && {
        os.format(fmt_, std::get<Is>(std::move(args_))...);
    }
public:
    template <typename...Args>
    formatter(const char* fmt, Args&&...args) :
        fmt_{fmt}, args_{std::forward<Args>(args)...} {}
    friend OutStream& operator << (OutStream& os, formatter&& f) {
        std::move(f).expand(os, std::index_sequence_for<Ts...>{});
        return os;
    }
};
template <typename...Args>
formatter<Args&&...> format(const char* fmt, Args&&...args) {
    return {fmt, std::forward<Args>(args)...};
}

演示

编译器应该能够很容易地内联formatter的操作并消除临时对象。事实上，这个功能：

void test_foo() {
    OutStream out;
    out << 1 << format(" formatted %04X ", 2) << "3n";
}

结果在组装（g++4.9.0-std=c++1y-O3针对x64）：

.LC0:
    .string " formatted %04X "
.LC1:
    .string "3n"
test_foo():
    pushq   %rbx
    movl    $1, %esi
    subq    $16, %rsp
    leaq    15(%rsp), %rdi
    call    OutStream::operator<<(int)
    movl    $2, %edx
    movl    $.LC0, %esi
    movq    %rax, %rbx
    movq    %rax, %rdi
    xorl    %eax, %eax
    call    OutStream::format(char const*, ...)
    movq    %rbx, %rdi
    movl    $.LC1, %esi
    call    OutStream::operator<<(char const*)
    addq    $16, %rsp
    popq    %rbx
    ret

因此所有内容都被正确地内联；在所产生的代码中没有CCD_ 12的踪迹。

类std::basic_ostream及其operator<<有三个扩展点在这里看起来很相关：

  • "插入"一个接受并返回std::ios_base&的函数
  • "插入"一个接受并返回std::basic_ios<C, T>&的函数
  • "插入"一个接受并返回std::basic_ostream&的函数

不幸的是，这三个实例都在函数指针上操作，而不是在std::function实例上操作，这使得提供闭包变得更加困难。在您的情况下，您希望提供格式字符串——也许还有格式参数——一个la std::setw()。

您可以在Cay Horstmann的老文章《扩展iostream库》中找到关于如何实现这些操纵器的讨论。特别是，请参阅第3节"操纵器"，了解如何从用作闭包的format()函数返回对象，并为该对象编写operator<<()函数。

如果您想在闭包中捕获临时值，那么这样做将涉及一些额外的复制，并且您可能很难捕获可变参数列表。从一个简单的接口开始（可能只需要一个参数），确保它写入目标流，并从那里开始构建。

尝试以下操作：

OutStream out;
(out << 1).format(" formatted %04X ", 2) << "3n";

考虑使用GNU的autoprintf。它很小。不，真的。它本质上是vasprintf的包装。autoprintf所需要的只是一个std::string实现和您常用的独立C头。这是头文件和文档。如何使用它的示例：

OutStream out;
out << 1 << gnu::autosprintf(" formatted %04X ", 2) << "3n";

（实际上，如果你使用固定大小的字符串，你可以修改它来避免使用std::string。当然，仍然有一种假设是你已经实现了vasprintf和某种形式的堆分配。）

相关文章：