c++ - 为什么禁止构建istream？

Question

这是一些代码:

#include <iostream>
#include <vector>
#include <string>
#include <fstream>
#include <istream>
#include <ostream>

class A {
    int *m;
    std::istream in;
    A(int *m, std::string file): m{m}, in{std::ifstream{file}} { foo(); }
public:
    A(int *m): m{m}, in{std::cin} { foo(); }
    void foo() {}
};

int main() {
    return 0;
}

当我尝试执行 g++ -std=c++14 main.cc 时，我最终得到的是:

$ g++ -std=c++14 main.cc
main.cc: In constructor ‘A::A(int*, std::__cxx11::string)’:
main.cc:11:62: error: ‘std::basic_istream<_CharT, _Traits>::basic_istream(std::basic_istream<_CharT, _Traits>&&) [with _CharT = char; _Traits = std::char_traits<char>]’ is protected within this context
     A(int *m, std::string file): m{m}, in{std::ifstream{file}} { foo(); }
                                                              ^
In file included from /usr/include/c++/7/iostream:40:0,
                 from main.cc:1:
/usr/include/c++/7/istream:613:7: note: declared protected here
       basic_istream(basic_istream&& __rhs)
       ^~~~~~~~~~~~~
main.cc: In constructor ‘A::A(int*)’:
main.cc:13:33: error: ‘std::basic_istream<_CharT, _Traits>::basic_istream(const std::basic_istream<_CharT, _Traits>&) [with _CharT = char; _Traits = std::char_traits<char>]’ is protected within this context
     A(int *m): m{m}, in{std::cin} { foo(); }
                                 ^
In file included from /usr/include/c++/7/iostream:40:0,
                 from main.cc:1:
/usr/include/c++/7/istream:611:7: note: declared protected here
       basic_istream(const basic_istream&) = delete;
       ^~~~~~~~~~~~~
main.cc:13:33: error: use of deleted function ‘std::basic_istream<_CharT, _Traits>::basic_istream(const std::basic_istream<_CharT, _Traits>&) [with _CharT = char; _Traits = std::char_traits<char>]’
     A(int *m): m{m}, in{std::cin} { foo(); }
                                 ^
In file included from /usr/include/c++/7/iostream:40:0,
                 from main.cc:1:
/usr/include/c++/7/istream:611:7: note: declared here
       basic_istream(const basic_istream&) = delete;
       ^~~~~~~~~~~~~

我知道不可能对 istream 进行任何类型的赋值，但我至少认为我可以构造一个，就像 ifstream 和其他。我在这里做错了什么？

编辑:即使将 in 作为引用也会导致:

main.cc: In constructor ‘A::A(int*, std::__cxx11::string)’:
main.cc:11:62: error: cannot bind non-const lvalue reference of type ‘std::istream& {aka std::basic_istream<char>&}’ to an rvalue of type ‘std::basic_istream<char>’
     A(int *m, std::string file): m{m}, in{std::ifstream{file}} { foo(); }
                                                              ^

这是为什么？

Answer 1

你需要决定是否A应该拥有流。

如果它确实拥有流，那么您不能传递它 std::cin你需要存储 ifstream直接或unique_ptr<istream>而不是 istream ，因为您希望允许派生类型，例如 ifstream .

如果它是非拥有的，那么你不能在构造函数中创建实例。相反，调用者需要创建并拥有流并将对它的引用传递给您的构造函数。为此，您应该保存引用 istream&而不是 istream或 std::reference_wrapper<istream>如果你想允许对类或原始(非拥有)指针进行赋值 istream* .

如果您希望两者都允许，您可以创建一个仅采用引用的基类，然后您可以创建一个派生类来另外构造和拥有该流。然后，无论何时需要，您都可以构造派生类或基类类型，具体取决于它是否应该拥有。

class A {
    std::istream& in;
public:
    A() : A(std::cin) { }
    A(std::istream& in): in(in) { }
};

class B : public A {
    std::ifstream ifs;
public:
    B(std::string file) : A(ifs), ifs(file) { }
};

也许您想通过给定 A 使类多态化虚拟析构函数和虚拟成员函数，以防您想使用具有运行时多态性的这两个类。

或者，您可以为一个拥有和一个非拥有版本的类模板化。或者你可以使用 std::variant作为成员，可以保存拥有或非拥有类型。哪种解决方案最适合您的情况，取决于您打算如何使用该类。