c++ - 将字符传递给运算符重载的自定义流操纵器

Question

我正在摆弄shift/io流运算符重载，我想知道是否有一种方法可以将附加参数传递给函数，同时仍然为更简单的语法定义默认值？

考虑这个简单的例子:

#include <vector>
#include <iostream>

inline std::ostream& operator<<(std::ostream& ostream, const std::vector< int >& data) {
    ostream << data[0];
    for (int idx = 1; idx < data.size(); idx++) {
        ostream << "," << data[idx];   // pass ',' as argument?
    }
    return ostream;
}

我希望将分隔符 , 传递给函数，例如也许通过流修饰符:

std::cout << std::vector<int>(3, 15) << std::endl;   // 15,15,15
std::cout << delimiter(;) << std::vector<int>(3,15) << std::endl;  // 15;15;15

我编写了一个简单的类来执行此操作，但生成的语法不是很干净(需要强制首先调用成员运算符重载):

#include <string>
#include <vector>
#include <iostream>
#include <sstream>

class formatted{
 public:
    explicit formatted(const std::string& sequence = ",") : delimiter(sequence) { }

    template < typename T >
    std::string operator<<(const T& src) const {
        std::stringstream out;
        if (src.size()) {
            out << src[0];
            for (int i = 1; i < src.size(); i++) {
                out << delimiter << src[i];
            }
        }
        return out.str();
    }

 protected:
    std::string delimiter;
};


template < typename T >
inline std::ostream& operator<<(std::ostream& ostream, const std::vector< T >& data) {
    ostream << (formatted() << data);
    return ostream;
}



int main(int argc, char const *argv[]) {
    std::vector< int > data(10, 5);

    std::cout << data << std::endl;  // 5,5,5...5,5
    std::cout << (formatted("/") << data) << std::endl;  // 5/5/5...5/5

    return 0;
}

有没有一种方法可以简化这个过程，而不需要辅助类，或者通过使用传统的流操纵器？

Answer 1

当前设计的微小改进

您正在做的事情是可能的，并且不能进一步简化。如果您想坚持当前的实现，我建议修复以下问题:

整个字符串的不必要拷贝

使用

return std::move(out).str();

防止复制 stringstream 中的整个字符串最后(C++20 起)。

有符号/无符号比较

for (int i = 1; i < data.size(); ...)

导致有符号和无符号之间的比较，从而导致编译器发出足够警告级别的警告。 喜欢std::size_t i .

无约束流插入运算符

operator<<(const T&)

不受约束，可以接受任何类型，即使它仅适用于 vector 。 偏好:

operator<<(const std::vector<T>&)

使用std::string而不是std::string_view

const std::string& sequence = ","

导致创建不必要的字符串，可能涉及堆分配，即使我们使用字符串文字，例如 "," 。 通常我们会更喜欢 std::string_view ，但在这里，您将此序列存储在类中。这可能会产生问题，因为 std::string_view对字符串没有所有权，因此在使用 View 之前字符串的生命周期可能会过期。 这个问题是您的设计所固有的，无法轻易解决。

另类设计

调用formatted流操纵器是不准确的，因为流操纵器是接受并返回 basic_ios 的函数。 (或派生类型)。您的formatted type 只是某种具有 << 运算符重载的类型，但你也可以这样做:

std::cout << vector_to_string(data, "/");

哪里"/"默认为 ","如果没有提供参数。 问题是我们仍然没有使用流来输出字符，但我们首先必须创建一个字符串，将 vector 内容写入其中，然后将字符串写入流中。

相反，我们可以创建一个接受流作为其第一个参数并直接写入的函数。 优点包括:

• 正在删除#include <sstream> ，可能只包括 <iosfwd>
• 性能提升
• 可能没有堆分配
• 没有不必要的字符串复制(C++20 之前)
• 整体较短的代码

这种设计作为常规函数在标准库中也有先例。一个典型的例子是 std::getline带有签名:

template < class CharT, ...>
std::basic_istream<CharT, ...>& getline( std::basic_istream<CharT, ...>& input,
                                         std::basic_string<CharT, ...>& str,
                                         CharT delim );

通过这种设计，我们可以创建更加简洁的代码，这也解决了以下问题:

• 无法使用std::string_view
• 必须使用std::string存储整个打印 vector

#include <string>
#include <vector>
#include <iostream>

template < typename T >
std::ostream& print(std::ostream& ostream,
                    const std::vector< T >& data,
                    std::string_view delimiter = ",")
{
    if (not data.empty()) {
        ostream << data.front();
        for (std::size_t i = 1; i < data.size(); i++) {
            ostream << delimiter << data[i];
        }
    }
    return ostream;
}


int main(int argc, char const *argv[])
{
    std::vector< int > data(10, 5);

    print(std::cout, data) << std::endl;
    print(std::cout, data, "/") << std::endl;
}

任何范围的进一步概括

我们可以概括此代码，以便它适用于提供输入迭代器的任何范围，而不仅仅是 std::vector 。 这意味着我们可以将它用于诸如 std::array 之类的类型。 , std::string , std::vector , std::list等

template <typename Range>
std::ostream& print(std::ostream& ostream,
                    const Range& range,
                    std::string_view delimiter = ",")
{
    auto begin = range.begin();
    auto end = range.end();

    if (begin != end) {
        ostream << *begin;
        while (++begin != end) {
            ostream << delimiter << *begin;
        }
    }
    return ostream;
}