C++ c++；在std:：vector中存储逗号分隔int的最快方法是什么

我有一个逗号分隔的整数，我想把它们存储在

std:：vector

中。目前我正在手动操作。是否有任何内置功能可以实现上述功能

编辑： 我很匆忙，忘了详细说明 实际上，我有一个字符串（确切地说是Unicode字符串）包含CSV，例如“1,2,3,4,5”

---

现在我想把它们存储在

std:：vector

中，所以在上面的例子中，我的向量将有五个元素被推入其中。目前我是通过手动方式完成的，但是速度很慢，而且代码也很混乱

就我个人而言，我会创建一个结构，并让向量包含该结构的实例。 像这样：

struct示例struct
{
INTA；
int b；
INTC；
};
向量结构向量；

遗憾的是，STL不允许在分隔符上拆分字符串。你可以使用Boost来做它：（需要一个最近的C++编译器，比如MSVC 2010或GCC 4.5）< /P>

#包括
#包括
#包括
#包括
#包括
#包括
#包括
使用名称空间std；
int main（int argc，字符**argv）
{
字符串输入=“1,2,3,4”；
向量strs；
boost：：split（strs，input，boost：：是（“，”）中的任意一个）；
矢量结果；
转化(
strs.begin（）、strs.end（）、back_插入器（结果），
[]（const string&s）->int{return boost:：lexical_cast；}
);
for（自动i=result.begin（）；i！=result.end（）；+i）
cout这可能不是最有效的方法，但这里有一种使用TR1 regex功能的方法（我在本示例中也使用了C++0x lambda语法，但显然也可以不用它）：

#包括
#包括
#包括
#包括
#包括
#包括
std:：vector GetList（const std:：wstring和input）
{
std：：向量结果；
std:：wsregex_迭代器：：regex_type rex（L“（\\d+）（，|$）”；
std:：wsregex_迭代器it（input.begin（）、input.end（）、rex）；
std:：transform（it，std:：wsregex_iterator（），std:：back_inserter（result），
[]（const std:：wsregex_迭代器:：value_type&m）
{return std:：wcstol（m[1].str（）.c_str（），nullptr，10）；}）；
返回结果；
}
这个怎么样

#include <string>
#include <vector>
#include <functional>
#include <algorithm>
#include <iostream>

struct PickIntFunc
{
    PickIntFunc(std::vector<int>& vecInt): _vecInt(vecInt),_pBegin(0){}

    char operator () (const char& aChar)
    {
        if(aChar == ',' || aChar == 0)
        {
            _vecInt.push_back(atoi(std::string(_pBegin,&aChar).c_str()));
            _pBegin = 0;
        }
        else
        {
            if(_pBegin == 0)
            {
                _pBegin = &aChar;
            }
        }
        return aChar;
    }

    const char* _pBegin;
    std::vector<int>& _vecInt;
};


int _tmain(int argc, _TCHAR* argv[])
{
    std::vector<int> vecInt;

    char intStr[] = "1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20";

    std::for_each(intStr,intStr+sizeof(intStr),PickIntFunc(vecInt));

    // Now test it
    std::for_each(vecInt.begin(),vecInt.end(), [] (int i) { std::cout << i << std::endl;});

    return 0;
}

#包括
#包括
#包括
#包括
#包括
结构PickIntFunc
{
PickIntFunc（std:：vector&vecInt）：\u vecInt（vecInt），\u pBegin（0）{
char运算符（）（const char和aChar）
{
如果（aChar=='，'| | aChar==0）
{
_vecInt.push_back（atoi（std:：string（_pBegin，&aChar.c_str（））；
_pBegin=0；
}
其他的
{
如果（_pBegin==0）
{
_pBegin=&aChar；
}
}
返回aChar；
}
const char*_pBegin；
std：：vector&_vecInt；
};
int _tmain（int argc，_TCHAR*argv[]
{
向量向量；
char intStr[]=“1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20”；
std:：for_each（intStr、intStr+sizeof（intStr）、PickIntFunc（vecInt））；
//现在测试一下
std:：for_each（vecInt.begin（）、vecInt.end（）、[]（int i）{std:：cout快速脏选项是使用C字符串库strtok（）函数和atoi（）：

void拆分（char*string、std:：vector和intVec）
{
char*pNext=strtok（字符串，“，”）；
while（pNext！=NULL）
{
intVec.推回（atoi（pNext））；
pNext=strtok（NULL，“”，“”）；
}
}

根据需要插入您自己的输入数据验证

见：




以及宽字符串版本：




编辑：
请注意，
strtok（）
将修改原始字符串，因此如果需要，请传递一份副本。
为了简单起见，您可以使用纯STL来完成此操作（易于阅读，不需要复杂的lib），这将加快编码速度，但在执行速度方面不是最快的（尽管您可能可以稍微调整它，例如在向量中预先保留空间：

std::vector<int> GetValues(std::wstring s, wchar_t delim)
{
    std::vector<int> v;
    std::wstring i;
    std::wstringstream ss(s);
    while(std::getline(ss,i,delim))
    {
        std::wstringstream c(i);
        int x;
        c >> x;
        v.push_back(x);
    }

    return v;
}

std:：vector GetValues（std:：wstring s，wchar\t delim）
{
std：：向量v；
std：：wstring i；
std:：wstringstream ss（s）；
while（std：：getline（ss，i，delim））
{
std：：wstringstream c（i）；
int x；
c>>x；
v、 推回（x）；
}
返回v；
}

（无需转发（
&&&
）或atoi以保持代码的可移植性）。
尝试以下操作：

它将读取由任何字符（您选择）分隔的任何类型（可以用>>读取）。

注意：读取对象后，对象和分隔符之间只能有空格。因此，对于
ObjectSepReader
之类的内容，它将读取一个以“，”分隔的单词列表

这使得使用我们的标准算法变得简单：

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

int main()
{
    std::stringstream   data("1,2,3,4,5,6,7,8,9");
    std::vector<int>    vdata;

    // Read the data from a stream
    std::copy(std::istream_iterator<ObjectSepReader<int, ','> >(data),
              std::istream_iterator<ObjectSepReader<int, ','> >(),
              std::back_inserter(vdata)
             );

    // Copy data to output for testing
    std::copy(vdata.begin(), vdata.end(), std::ostream_iterator<int>(std::cout," "));
}

#包括
#包括
#包括
#包括
#包括
int main（）
{
std:：stringstream数据（“1,2,3,4,5,6,7,8,9”）；
std：：矢量数据；
//从流中读取数据
std:：copy（std:：istream_迭代器（数据），
std:：istream_迭代器（），
标准：背面插入器（vdata）
);
//将数据复制到输出以进行测试
std:：copy（vdata.begin（）、vdata.end（）、std:：ostream_迭代器（std:：cout，”）；
}

秘密班来让它工作

template<typename T,char S>
struct ObjectSepReader
{
    T value;
    operator T const&() const {return value;}
};
template<typename T,char S>
std::istream& operator>>(std::istream& stream, ObjectSepReader<T,S>& data)
{
    char        terminator;
    std::string line;

    std::getline(stream, line, S);
    std::stringstream  linestream(line + ':');

    if (!(linestream >> data.value >> terminator) || (linestream.tellg() != line.size()+1) || (terminator != ':'))
    {   stream.setstate(std::ios::badbit);
    }

    return stream;
}

模板
结构ObjectSepReader
{
T值；
运算符T常量&（）常量{返回值；}
};
模板
std:：istream&operator>>（std:：istream&stream、ObjectSepreder&data）
{
字符终止符；
std：：字符串行；
std:：getline（流、行、S）；
std:：stringstream linestream（line+'：'）；
如果（！（linestream>>data.value>>终止符）| |（linestream.tellg（）！=line.size（）+1）| |（终止符！='：'））
{stream.setstate（std:：ios:：badbit）；
}
回流；
}
编写一些代码来演示您的确切问题“您是否在
std:：vector
中存储整数和逗号？逗号分隔列表的来源是什么？流？字符串？您当前使用的方法是什么？@iammilind查看我的问题的“编辑”部分的信息@Donotalo查看“编辑”部分的信息在我的问题部分，我完全忘记了正则表达式库
void Split(char * string, std::vector<int>& intVec)
{
    char * pNext = strtok(string, ",");
    while (pNext != NULL)
    {
        intVec.push_back(atoi(pNext));
        pNext = strtok(NULL, ",");
    }
}

std::vector<int> GetValues(std::wstring s, wchar_t delim)
{
    std::vector<int> v;
    std::wstring i;
    std::wstringstream ss(s);
    while(std::getline(ss,i,delim))
    {
        std::wstringstream c(i);
        int x;
        c >> x;
        v.push_back(x);
    }

    return v;
}

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

int main()
{
    std::stringstream   data("1,2,3,4,5,6,7,8,9");
    std::vector<int>    vdata;

    // Read the data from a stream
    std::copy(std::istream_iterator<ObjectSepReader<int, ','> >(data),
              std::istream_iterator<ObjectSepReader<int, ','> >(),
              std::back_inserter(vdata)
             );

    // Copy data to output for testing
    std::copy(vdata.begin(), vdata.end(), std::ostream_iterator<int>(std::cout," "));
}

template<typename T,char S>
struct ObjectSepReader
{
    T value;
    operator T const&() const {return value;}
};
template<typename T,char S>
std::istream& operator>>(std::istream& stream, ObjectSepReader<T,S>& data)
{
    char        terminator;
    std::string line;

    std::getline(stream, line, S);
    std::stringstream  linestream(line + ':');

    if (!(linestream >> data.value >> terminator) || (linestream.tellg() != line.size()+1) || (terminator != ':'))
    {   stream.setstate(std::ios::badbit);
    }

    return stream;
}