Question

我的constructor包含可流式类型：

std::variant

使用带有-std = c ++ 1z的g ++ 7进行编译会返回编译时错误。

摘录：

std::variant<int, std::string> a, b;
a = 1;
b = "hi";
std::cout << a << b << std::endl;

似乎test.cpp: In function 'int main(int, char**)': test.cpp:10:13: error: no match for 'operator<<' (operand types are 'std::ostream {aka std::basic_ostream<char>}' and 'std::variant<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >') std::cout << a << b << std::endl; ~~~~~~~~~~^~~~无法传输。我怎样才能实现我可以直接将变量流式传输到输出流？

预期产出：

std::variant<int, std::string>

Answer 1

这也会嵌套变种。

template<class T>
struct streamer {
    const T& val;
};
template<class T> streamer(T) -> streamer<T>;

template<class T>
std::ostream& operator<<(std::ostream& os, streamer<T> s) {
    os << s.val;
    return os;
}

template<class... Ts>
std::ostream& operator<<(std::ostream& os, streamer<std::variant<Ts...>> sv) {
   std::visit([&os](const auto& v) { os << streamer{v}; }, sv.val);
   return os;
}

用作：

std::cout << streamer{a} << streamer{b} << '\n';

Answer 2

不确定这是一个好主意，但我想您可以为operator<<()定义std::variant。

为了好玩，我已经意识到你可以在下面的例子中看到的那个（我想可以简化一点）

#include <variant>
#include <iostream>

template <std::size_t I, typename T0, typename ... Ts>
std::enable_if_t<(I == 1U+sizeof...(Ts)), std::ostream &>
   streamV (std::ostream & s, std::variant<T0, Ts...> const &)
 { return s; }

template <std::size_t I, typename T0, typename ... Ts>
std::enable_if_t<(I < 1U+sizeof...(Ts)), std::ostream &>
   streamV (std::ostream & s, std::variant<T0, Ts...> const & v)
 { return I == v.index() ? s << std::get<I>(v) : streamV<I+1U>(s, v); }

template <typename T0, typename ... Ts>
std::ostream & operator<< (std::ostream & s, 
                           std::variant<T0, Ts...> const & v)
 { return streamV<0U>(s, v); }

int main ()
 {
   std::variant<int, std::string> a, b;
   a = 1;
   b = "hi";
   std::cout << a << b << std::endl;
}

- 编辑 -

另一种编写streamV()辅助函数的方法，不使用T0, Ts...类型但使用std::variant_size_v

template <std::size_t I, typename V>
std::enable_if_t<(I == std::variant_size_v<V>), std::ostream &>
   streamV (std::ostream & s, V const &)
 { return s; }

template <std::size_t I, typename V>
std::enable_if_t<(I < std::variant_size_v<V>), std::ostream &>
   streamV (std::ostream & s, V const & v)
 { return I == v.index() ? s << std::get<I>(v) : streamV<I+1U>(s, v); }

- 编辑2 -

正如T.C.所指出的那样。（谢谢！）我（仅streamV()）实现了std::visit()效率较低，效果较差且效果较差的版本。

使用std::visit()我的例子可以变得更简单

#include <variant>
#include <iostream>

template <typename T0, typename ... Ts>
std::ostream & operator<< (std::ostream & s,
                           std::variant<T0, Ts...> const & v)
 { std::visit([&](auto && arg){ s << arg;}, v); return s; }

int main ()
 {
   std::variant<int, std::string> a, b;
   a = 1;
   b = "hi";
   std::cout << a << b << std::endl;
}

我再说一遍：只是为了好玩，因为我认为在标准类型上定义operator<<()是一个好主意。

我建议T.C.的解决方案。将变量实例包含在特定类中的流中。

Answer 3

注意：以下示例摘自Igor Tandetnik关于问题本身的评论。

std::visit是标准库中的一个函数，可以用于此确切目的：

#include <variant>
#include <iostream>

int main() {
    std::variant<int, std::string> value = 42;

    std::visit([](const auto &elem) { std::cout << elem << '\n'; }, value);
}

上面的代码段实质上是一种奇特的书写方式：

#include <variant>
#include <iostream>

int main() {
    std::variant<int, std::string> value = 42;

    if(std::holds_alternative<int>(value)) {
      std::cout << std::get<int>(value) << '\n';
    } else {
      std::cout << std::get<std::string>(value) << '\n';
    }
}

Answer 4

我认为你必须使用std中的get函数来获取stremable类型而不是变体类型本身。

像这样的东西

std::cout << std::get<int>(a) << std::get<std::string>(b) << std::endl;

如何流式传输std :: variant＆lt; ...，...＆gt;

4 个答案: