为什么禁止构建 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，因为您希望允许派生类型，例如@987654326 @。

如果它是非拥有的，那么你不能在构造函数中创建实例。相反，调用者需要创建和拥有流并将对它的引用传递给您的构造函数。为此，您应该保存引用 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 作为成员，它可以保存拥有或非拥有类型。哪种解决方案最适合您，取决于您打算如何使用该类。