将std:：unique_ptr与std:：istream一起使用？ 我正在编写C++程序，它可以从文件中输入（传递给它作为命令行ARG），从STD::CIN或STD:：它工作正常，并使用std:：istream*进行管理。我被告知这很糟糕，处理原始指针，所以我决定将其包装在std:：unique_ptr（即std:：unique_ptr）中。问题是它无法编译。就我从错误中可以看出，std:：istream已经保护自己不被用于分配内存。我试过用谷歌搜索它，但我不认为以前有人发布过这样的问题（因为我只看到了只涉及std:：unique\u ptr的问题）。有人知道如何做到这一点吗 edit: errors: In file included from /usr/include/c++/4.8/iostream:40:0, from /home/dtscode/Desktop/SLang/src/main.cpp:1: /usr/include/c++/4.8/istream: In function ‘int main(int, char**)’: /usr/include/c++/4.8/istream:606:7: error: ‘std::basic_istream<_CharT, _Traits>::basic_istream() [with _CharT = char; _Traits = std::char_traits<char>]’ is protected basic_istream() ^ compilation terminated due to -Wfatal-errors. make[2]: *** [CMakeFiles/slang.dir/src/main.cpp.o] Error 1 make[1]: *** [CMakeFiles/slang.dir/all] Error 2 make: *** [all] Error 2 edit:errors:在/usr/include/c++/4.8/iostream:40:0中包含的文件中， from/home/dtscode/Desktop/SLang/src/main.cpp:1: /usr/include/c++/4.8/istream:在函数“int main（int，char**）”中： /usr/include/c++/4.8/istream:606:7:错误：“std:：basic_istream:：basic_istream（）[with _CharT=char；_Traits=std:：char_Traits]”受保护 基本流 ^ 编译因-Wfatal错误而终止。 make[2]：***[CMakeFiles/slang.dir/src/main.cpp.o]错误1 生成[1]：***[CMakeFiles/slang.dir/all]错误2 make:**[全部]错误2

响应这一行：std:：unique_ptr Stream（新std:：istream（））

我也尝试过它，没有调用istreams构造函数，也没有在unique_ptrs构造函数中使用任何东西

编辑2：

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

#include <lexer.hpp>

int main(int argc, char *argv[]) {
    std::unique_ptr<std::istream> Stream(new std::istream());
    std::vector<std::string> Arguments(argv, argv + argc);

    switch(argc) {
        case 1:
            Stream = &std::cin;
            break;

        case 2:
            Stream = new std::ifstream(Arguments[1]);
            break;

        case 3:
            if(Arguments[1] == "-c") {
                Stream = new std::istringstream(Arguments[2]);
                break;
            }

        default:
            std::cerr<<"error: invalid arguments."<< std::endl;
            return 0;
    }

    Token::Lexeme CurrentToken = Token::Start;

    while(*Stream) {
        CurrentToken = getToken(Stream);
        lex_debug();
    }

    if(Stream != &std::cin) {
        delete Stream;
    }

    return 0;
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
int main（int argc，char*argv[]）{
std:：unique_ptr流（新std:：istream（））；
向量参数（argv，argv+argc）；
开关（argc）{
案例1：
流=&std:：cin；
打破
案例2：
Stream=newstd:：ifstream（参数[1]）；
打破
案例3：
if（参数[1]=“-c”）{
Stream=new std:：istringstream（参数[2]）；
打破
}
违约：
我想说这是一个非常糟糕的代码。为什么不这样做呢：

void process_input(std::istream & is);

int main(int argc, char * argv[]) {
    if (argc == 1) {
        process_input(std::cin);
    } else if (argc == 2) {
        std::ifstream is(argv[1], "rb");
        process_input(is);
    } else if (argc == 3 && strcmp(argv[1], "-c") == 0) {
        std::istringstream is(argv[2]);
        process_input(is);
    } else {
        std::cerr << "Unrecognized invocation.\n";
        return EXIT_FAILURE;
    }
}

#include <iostream>
#include <fstream>
#include <istream>
#include <sstream>
#include <vector>

int main(int argc, char *argv[])
{
    std::vector<std::string> args(argv, argv + argc);

    std::ifstream ifs(argc == 2 ? args[1]:"");
    std::istringstream iss(argc == 3 ? args[2]:"");

    std::istream& is = argc == 2 ? ifs : argc == 3 && args[1] == "-c" ? iss : std::cin;

    while(is)
    {
        // process stream
    }
}

无效流程输入（标准：：istream&is）；
int main（int argc，char*argv[]）{
如果（argc==1）{
过程输入（标准：：cin）；
}else if（argc==2）{
std:：ifstream是（argv[1]，“rb”）；
过程输入（is）；
}else if（argc==3&&strcmp（argv[1]，“-c”）==0）{
std:：istringstream是（argv[2]）；
过程输入（is）；
}否则{
我想说这是一个非常糟糕的代码。为什么不这样做呢：

void process_input(std::istream & is);

int main(int argc, char * argv[]) {
    if (argc == 1) {
        process_input(std::cin);
    } else if (argc == 2) {
        std::ifstream is(argv[1], "rb");
        process_input(is);
    } else if (argc == 3 && strcmp(argv[1], "-c") == 0) {
        std::istringstream is(argv[2]);
        process_input(is);
    } else {
        std::cerr << "Unrecognized invocation.\n";
        return EXIT_FAILURE;
    }
}

#include <iostream>
#include <fstream>
#include <istream>
#include <sstream>
#include <vector>

int main(int argc, char *argv[])
{
    std::vector<std::string> args(argv, argv + argc);

    std::ifstream ifs(argc == 2 ? args[1]:"");
    std::istringstream iss(argc == 3 ? args[2]:"");

    std::istream& is = argc == 2 ? ifs : argc == 3 && args[1] == "-c" ? iss : std::cin;

    while(is)
    {
        // process stream
    }
}

无效流程输入（标准：：istream&is）；
int main（int argc，char*argv[]）{
如果（argc==1）{
过程输入（标准：：cin）；
}else if（argc==2）{
std:：ifstream是（argv[1]，“rb”）；
过程输入（is）；
}else if（argc==3&&strcmp（argv[1]，“-c”）==0）{
std:：istringstream是（argv[2]）；
过程输入（is）；
}否则{
我经常这样选择流：

void process_input(std::istream & is);

int main(int argc, char * argv[]) {
    if (argc == 1) {
        process_input(std::cin);
    } else if (argc == 2) {
        std::ifstream is(argv[1], "rb");
        process_input(is);
    } else if (argc == 3 && strcmp(argv[1], "-c") == 0) {
        std::istringstream is(argv[2]);
        process_input(is);
    } else {
        std::cerr << "Unrecognized invocation.\n";
        return EXIT_FAILURE;
    }
}

#include <iostream>
#include <fstream>
#include <istream>
#include <sstream>
#include <vector>

int main(int argc, char *argv[])
{
    std::vector<std::string> args(argv, argv + argc);

    std::ifstream ifs(argc == 2 ? args[1]:"");
    std::istringstream iss(argc == 3 ? args[2]:"");

    std::istream& is = argc == 2 ? ifs : argc == 3 && args[1] == "-c" ? iss : std::cin;

    while(is)
    {
        // process stream
    }
}

#包括
#包括
#包括
#包括
#包括
int main（int argc，char*argv[]）
{
标准：：向量args（argv，argv+argc）；
std:：ifstream ifs（argc==2？args[1]：“”）；
std:：istringstream-iss（argc==3？args[2]：“”）；
std:：istream&is=argc==2？如果：argc==3&&args[1]==“-c”？iss:std:：cin；
while（is）
{
//工艺流程
}
}

这就是我避免使用指针的原因。
我经常这样选择流：

void process_input(std::istream & is);

int main(int argc, char * argv[]) {
    if (argc == 1) {
        process_input(std::cin);
    } else if (argc == 2) {
        std::ifstream is(argv[1], "rb");
        process_input(is);
    } else if (argc == 3 && strcmp(argv[1], "-c") == 0) {
        std::istringstream is(argv[2]);
        process_input(is);
    } else {
        std::cerr << "Unrecognized invocation.\n";
        return EXIT_FAILURE;
    }
}

#include <iostream>
#include <fstream>
#include <istream>
#include <sstream>
#include <vector>

int main(int argc, char *argv[])
{
    std::vector<std::string> args(argv, argv + argc);

    std::ifstream ifs(argc == 2 ? args[1]:"");
    std::istringstream iss(argc == 3 ? args[2]:"");

    std::istream& is = argc == 2 ? ifs : argc == 3 && args[1] == "-c" ? iss : std::cin;

    while(is)
    {
        // process stream
    }
}

#包括
#包括
#包括
#包括
#包括
int main（int argc，char*argv[]）
{
标准：：向量args（argv，argv+argc）；
std:：ifstream ifs（argc==2？args[1]：“”）；
std:：istringstream-iss（argc==3？args[2]：“”）；
std:：istream&is=argc==2？如果：argc==3&&args[1]==“-c”？iss:std:：cin；
while（is）
{
//工艺流程
}
}

这就是我避免使用指针的方法。
您显示的错误是由于std:：istream构造函数调用引起的，它是一个基类，无法实例化。即使代码确实编译过，std:：unique\u ptr也是一个拥有指针，因此尝试删除std:：cin时会出现问题。您想要一个非拥有指针，所以它是原始指针还是std:：弱\u ptr是正确的

编辑：如果可能的话，我建议改用引用。
您显示的错误是由于std:：istream构造函数调用引起的，它是一个基类，无法实例化。即使代码确实编译过，std:：unique\u ptr也是一个拥有指针，因此尝试删除std:：cin时会出现问题。您想要一个非拥有指针，因此原始指针或std:：weak_ptr正确

编辑：如果可能的话，我建议改用引用。
“有人告诉我，处理原始指针很糟糕。”--你问过为什么吗？给出了什么理由？是的。他们说处理原始指针和使用stl解决方案是危险的。你应该要求他们更具体一些。无论如何，你的用例是使用原始指针的一个很好的理由的完美例子。也就是说，作为一个非所有权的、可重新分配的引用。如果你不需要重新分配它，你可以我会使用引用，但代码会有点复杂，因为引用必须在创建时绑定。为什么你需要
istream*
为什么不直接使用
std:：istream
@Ben:因为他试图使用运行时多态性。“有人告诉我这很糟糕，处理原始指针”--你问过为什么吗？给出了什么理由？是的。他们说处理原始指针和使用stl解决方案是危险的。你应该要求他们更具体一些。无论如何，你的用例是使用原始指针的一个很好的理由的完美例子。也就是说，作为一个非所有权的、可重新分配的引用。如果你不需要重新分配它，你可以我会使用一个引用，但是代码会有点复杂，因为引用必须在创建时绑定。为什么你需要
istream*
为什么不直接使用
std:：istream
@Ben:因为他正在尝试