2

我在玩 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;
}

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

4

2 回答 2

2

当前设计的小改进

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

整个字符串的不必要副本

利用

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

stringstream以防止在末尾复制整个字符串（C++20 起）。

有符号/无符号比较

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

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

无约束的流插入运算符

operator<<(const T&)

不受约束并且可以接受任何类型，即使它仅适用于向量。更喜欢：

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

使用std::string代替std::string_view

const std::string& sequence = ","

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

另类设计

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

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

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

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

  • 下降#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
  • 必须使用 astd::string来存储整个打印的矢量
#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;
}
于 2021-11-27T13:21:40.577 回答
1

一些操作输入/输出的功能

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

std::string Delimiter=" ";

template <typename T>
inline std::ostream& operator<<(std::ostream& ostream, const std::vector<T>& v) {
    if (!v.empty()) {
        std::ostream_iterator<T> ost(ostream, Delimiter.data());

        if (v.size() > 1)
            std::copy(begin(v), end(v) - 1, ost);
        ostream << v.back();
    }

    return ostream;
}


int main() {
    std::cout << std::vector<int>(3, 15) << std::endl;
    Delimiter = "!";
    std::cout << std::vector<int>(5, 15) << std::endl;
    return 0;
}

当然Delimiter变量不是很漂亮但是....输出

15 15 15
15!15!15!15!15
于 2021-11-27T13:55:20.800 回答