3

使用启用了 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<<("3\n");

输出：

1 formatted 0002 3

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

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

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

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

有什么建议么？

编辑，2014 年 10 月 20 日：

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

4 回答 4

5

使用 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) << "3\n";
}

导致程序集（g++ 4.9.0 -std=c++1y -O3 针对 x64）：

.LC0:
    .string " formatted %04X "
.LC1:
    .string "3\n"
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

所以一切都正确内联；formatter生成的代码中没有 的痕迹。

于 2014-10-17T16:52:39.030 回答
3

类及其在此处看起来相关的三个扩展点：std::basic_ostreamoperator<<

  • “插入”一个接受并返回一个std::ios_base&.
  • “插入”一个接受并返回一个std::basic_ios<C, T>&.
  • “插入”一个接受并返回一个std::basic_ostream&.

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

您可以在 Cay Horstmann 的老文章Extending the iostream Library中找到有关如何实现这些操纵器的讨论。特别是，请查看第 3 节“操纵器”，了解如何从format()用作闭包的函数中返回一个对象，并operator<<()为该对象编写一个函数。

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

于 2014-10-17T16:38:21.833 回答
2

尝试以下操作：

OutStream out;
(out << 1).format(" formatted %04X ", 2) << "3\n";
于 2014-10-17T16:11:04.577 回答
1

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

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

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

于 2014-10-17T16:55:31.027 回答