Question

使用启用了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编辑设置;由于主题匹配，我保留了设置，我的问题的找到解决方案也适用于Stl iostream。

Answer 1

使用C ++ 14 index_sequence（有a million different implementations on 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)...};
}

<强> DEMO

编译器应该能够轻松地内联formatter的操作并忽略临时对象。确实这个功能：

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

results in the assembly (g++ 4.9.0 -std=c++1y -O3 targeting 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的痕迹。

Answer 2

std::basic_ostream课程three extension points及其operator<<与std::ios_base&相关：

“插入”一个获取并返回std::basic_ios<C, T>&的函数。
“插入”一个获取并返回std::basic_ostream&的函数。
“插入”一个获取并返回std::function的函数。

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

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

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

Answer 3

尝试以下方法：

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

Answer 4

考虑使用GNU's autosprintf。它非常小。不，really。它本质上是vasprintf的包装器。所有autosprintf需求都是std::string实现和您通常的独立C头。这是header file和documentation。如何使用它的示例：

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

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

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

4 个答案: