C++ 您可以指定什么是'；std:：getline中没有分隔符吗？ 我想把任何不是字母字符的东西当作定界符。我该怎么做呢？

你不需要

getline

是用于简单作业的简单工具。如果您需要更复杂的东西，那么您需要使用更复杂的工具，比如RegEx之类的工具。

您不能。默认分隔符是

\n

：

while (std::getline (std::cin, str) // '\n' is implicit

对于其他分隔符，传递它们：

while (std::getline (std::cin, str, ' ') // splits at a single whitespace

但是，分隔符是char类型，因此只能使用一个“拆分字符”，而不能使用不匹配的字符

如果您的输入恰好位于容器（如

std:：string

）中，则可以使用

find_first_not_of

或

find_last_not_of

）

---

---

在你的另一个问题中，你确定你已经考虑了所有的答案吗？一种是使用

istream:：operator>（std:：istream&，）

，它将匹配一系列非空白字符。

使用

std:：getline（）

，你不能做你想做的事，但你可以自己做。下面是一个

getline

变量，让您指定一个谓词（函数、函子、lambda，如果是C++11），以指示字符是否是分隔符，以及允许您传入分隔符字符串的几个重载（类似于

strtok（）

）：

#包括
#包括
#包括
使用名称空间std；
模板
istream&getline_直到（istream&is，string&str，谓词pred）
{
bool-changed=false；
istream：：哨兵k（是，真的）；
if（bool（k））{
streambuf&rdbuf（*是.rdbuf（））；
str.erase（）；
istream:：traits_type:：int_type ch=rdbuf.sgetc（）；//获取下一个字符，但不移动流位置
对于（；；ch=rdbuf.sgetc（））{
如果（istream:：traits_type:：eof（）==ch）{
is.setstate（ios_base:：eofbit）；
打破
}
更改=正确；
rdbuf.sbumpc（）；//移动流位置以使用字符
if（pred（istream:：traits_type:：to_char_type（ch）））{
打破
}
str.append（1，istream:：traits_type:：to_char_type（ch））；
如果（str.size（）=str.max_size（））{
is.setstate（ios_base:：failbit）；
打破
}
}
如果（！已更改）{
is.setstate（ios_base:：failbit）；
}
}            
回报是；
}
//两个重载（以及一个谓词）允许
//传入包含一组分隔符的字符串
_delim_集合中的结构：一元函数
{
in_delim_集（char const*delim_集）：delims（delim_集）{}；
in_-delim_集（string const&delim_集）：delims（delim_集）{}；
布尔运算符（）（字符ch）{
return（delims.find（ch）！=string:：npos）；
};
私人：
细绳熟食；
};
istream&getline_直到（istream&is，string&str，char const*delim_集）
{
返回getline_直到（is，str，in_delim_set（delim_set））；
}
istream&getline_直到（istream&is、string&str、string const&delim_集）
{
返回getline_直到（is，str，in_delim_set（delim_set））；
}
//一个简单的谓词函子示例
结构是数字：一元函数
{
公众：
布尔运算符（）（字符c）常量{
返回（'0'
#include <functional>
#include <iostream>
#include <string>

using namespace std;

template <typename Predicate>
istream& getline_until( istream& is, string& str, Predicate pred)
{
    bool changed = false;
    istream::sentry k(is,true);

    if (bool(k)) {
        streambuf& rdbuf(*is.rdbuf());
        str.erase();

        istream::traits_type::int_type ch = rdbuf.sgetc(); // get next char, but don't move stream position
        for (;;ch = rdbuf.sgetc()) {
            if (istream::traits_type::eof() == ch) {
                is.setstate(ios_base::eofbit);
                break;
            }
            changed = true;
            rdbuf.sbumpc(); // move stream position to consume char
            if (pred(istream::traits_type::to_char_type(ch))) {
                break;
            }
            str.append(1,istream::traits_type::to_char_type(ch));
            if (str.size() == str.max_size()) {
                is.setstate(ios_base::failbit);
                break;
            }
        }

        if (!changed) {
            is.setstate(ios_base::failbit);
        }
    }            

    return is;
}

// a couple of overloads (along with a predicate) that allow you
// to pass in a string that contains a set of delimiter characters

struct in_delim_set : unary_function<char,bool>
{
    in_delim_set( char const* delim_set) : delims(delim_set) {};
    in_delim_set( string const& delim_set) : delims(delim_set) {};

    bool operator()(char ch) {
        return (delims.find(ch) != string::npos);
    };
private:
    string delims;

};

istream& getline_until( istream& is, string& str, char const* delim_set)
{
    return getline_until( is, str, in_delim_set(delim_set));
}

istream& getline_until( istream& is, string& str, string const& delim_set)
{
    return getline_until( is, str, in_delim_set(delim_set));
}

// a simple example predicate functor
struct is_digit : unary_function<char,bool>
{
    public:
        bool operator()(char c) const {
            return ('0' <= c) && (c <= '9');
        }
};


int main(int argc, char* argv[]) {
    string test;

    // treat anything that's not a digit as end-of-line
    while (getline_until( cin, test, not1(is_digit()))) {
        cout << test << endl;
    }

    return 0;
}