C++ 字符串流到向量<；int>；

我想知道从

std:：stringstream

写入

vector

的最佳方式是什么

下面是

stringstream

中的示例：

“31#00 532 53 803 33 534 23 37”

以下是我得到的：

int buffer = 0;
vector<int> analogueReadings;
stringstream output;

 while(output >> buffer)
     analogueReadings.push_back(buffer);

int buffer=0；
向量类比阅读；
串流输出；
while（输出>>缓冲区）
模拟读取。推回（缓冲区）；

然而，似乎发生的是，它首先读取，然后到达

#00

，并返回

0

，因为它不是一个数字

理想情况下，我想要的是，它得到一个

#

，然后跳过所有字符，直到下一个空格。这是可能的旗帜或什么

---

谢谢。

您需要测试是否有号码。使用下面的答案：

进入

在我的系统上。请注意，77也丢失了

#包括
#include <iostream>
#include <sstream>
#include <vector>

int main ( int, char ** )
{
    std::istringstream reader("31 #00 532 53 803 33 534 23 37");
    std::vector<int> numbers;
    do
    {
        // read as many numbers as possible.
        for (int number; reader >> number;) {
            numbers.push_back(number);
        }
        // consume and discard token from stream.
        if (reader.fail())
        {
            reader.clear();
            std::string token;
            reader >> token;
        }
    }
    while (!reader.eof());

    for (std::size_t i=0; i < numbers.size(); ++i) {
        std::cout << numbers[i] << std::endl;
    }
}

#包括
#包括
int main（int，char**）
{
std:：istringstream阅读器（“31#00 532 53 803 33 534 23 37”）；
std：：向量数；
做
{
//读尽可能多的数字。
用于（整数编号；读卡器>>编号；）{
数字。推回（数字）；
}
//从流中消费和丢弃令牌。
if（reader.fail（））
{
reader.clear（）；
字符串标记；
读卡器>>令牌；
}
}
而（！reader.eof（））；
对于（std:：size_t i=0；i
#include <iostream>
#include <vector>
#include <iterator>
#include <algorithm>
#include <sstream>

using namespace std;

class IntegerFiller
{
    vector<int> &m_vec;
public:
    IntegerFiller(vector<int> &vec): m_vec(vec) {}

    void operator()(const std::string &str)
    {
        stringstream ss(str);
        int n;
        ss >> n;
        if ( !ss.fail() )
            m_vec.push_back(n);
    }
};

int main()
{
    vector<int> numbers;
    IntegerFiller filler(numbers);
    for_each(istream_iterator<string>(cin), istream_iterator<string>(), filler);
    copy(numbers.begin(), numbers.end(), ostream_iterator<int>(cout, " "));
    return 0;
}

#包括
#包括
#包括
#包括
#包括
使用名称空间std；
类整数填充器
{
向量&m_向量；
公众：
整数filler（vector&vec）：m_-vec（vec）{}
void运算符（）（常量std:：string和str）
{
stringstream ss（str）；
int n；
ss>>n；
如果（！ss.fail（））
向量推回（n）；
}
};
int main（）
{
向量数；
整数填充器（数字）；
对于每个（istream_迭代器（cin），istream_迭代器（），filler）；
复制（numbers.begin（）、numbers.end（）、ostream_迭代器（cout，“”）；
返回0；
}
我认为最好的方法是

#include <string>
#include <sstream>
#include <vector>

using namespace std;   

int main()
{   
  string numbers = "23,24,27,28";   
  vector<int> integers;   
  stringstream s(numbers);   
  char ch;   
  int a;   
  while(s>>a>>ch) integers.push_back(a);   //s >> reads int char pair 
  s>>a;                                    // reads the last int
  integers.push_back(a); 

  for(int i = 0; i < integers.size(); i++) cout << integers[i] << "\n";
}

#包括
#包括
#包括
使用名称空间std；
int main（）
{   
字符串编号=“23,24,27,28”；
向量整数；
串（编号）；
char ch；
INTA；
while（s>>a>>ch）整数。向后推（a）；/s>>读取整数字符对
s> >a；//读取最后一个int
整数。推回（a）；
对于（int i=0；iint
类型为
buffer
的
output>>buffer
表达式已经在测试它是否是一个数字。诀窍在于OP的循环条件测试是不明确的：它不区分流的结束和读取数字的失败。顺便说一句，这是一个糟糕的算法。在常见情况下（令牌是一个数字），令牌的字符被处理3次：一次将令牌读入字符串，一次执行“是一个数字”测试，然后一次解析数字。我相信如果stringstream中的第一项是NAN，那么while循环将不会再次运行。我想这就是为什么AndréCaron使用DO-while循环的原因。我的方法适用于所有以10为基数的整数的情况，忽略任何其他内容。另请参见编辑说明。我不理解在这种情况下NAN的含义，因为我们处理的是字符串和整数，而不是浮点数。如果第一项不是整数，它会被忽略。如果您不想一次读取整个序列，可以删除外部的do while循环。在这种情况下，您可以读取由非数字标记分隔的数字序列。运行代码。它会打印31、532、53、803、33、534、23、37。No 0 is inserted.Merci André。我喜欢你的算法。我不知道失败的比特和东西。谢谢你的时间。+1。这是一种方法。但前提是你能很好地解释例如0x2A为0，55bla为55。否则请看我的答案或类似的东西。还要注意，在转换为示例25 1000000000 77 0 0由于不受控制的溢出。在我的系统上，结果是25 0 0（请注意，77也丢失）。
#include <iostream>
#include <sstream>
#include <vector>

int main ( int, char ** )
{
    std::istringstream reader("31 #00 532 53 803 33 534 23 37");
    std::vector<int> numbers;
    do
    {
        // read as many numbers as possible.
        for (int number; reader >> number;) {
            numbers.push_back(number);
        }
        // consume and discard token from stream.
        if (reader.fail())
        {
            reader.clear();
            std::string token;
            reader >> token;
        }
    }
    while (!reader.eof());

    for (std::size_t i=0; i < numbers.size(); ++i) {
        std::cout << numbers[i] << std::endl;
    }
}

#include <iostream>
#include <vector>
#include <iterator>
#include <algorithm>
#include <sstream>

using namespace std;

class IntegerFiller
{
    vector<int> &m_vec;
public:
    IntegerFiller(vector<int> &vec): m_vec(vec) {}

    void operator()(const std::string &str)
    {
        stringstream ss(str);
        int n;
        ss >> n;
        if ( !ss.fail() )
            m_vec.push_back(n);
    }
};

int main()
{
    vector<int> numbers;
    IntegerFiller filler(numbers);
    for_each(istream_iterator<string>(cin), istream_iterator<string>(), filler);
    copy(numbers.begin(), numbers.end(), ostream_iterator<int>(cout, " "));
    return 0;
}

#include <string>
#include <sstream>
#include <vector>

using namespace std;   

int main()
{   
  string numbers = "23,24,27,28";   
  vector<int> integers;   
  stringstream s(numbers);   
  char ch;   
  int a;   
  while(s>>a>>ch) integers.push_back(a);   //s >> reads int char pair 
  s>>a;                                    // reads the last int
  integers.push_back(a); 

  for(int i = 0; i < integers.size(); i++) cout << integers[i] << "\n";
}