如何通过分隔符将字符串拆分为数组?

时间:2009-05-20 20:48:22

标签: c++ function string

我是编程新手。我一直在尝试用C ++编写一个函数,它将字符串的内容分解为给定参数的字符串数组,例如:

string str = "___this_ is__ th_e str__ing we__ will use__";

应返回字符串数组:

cout << stringArray[0]; // 'this'
cout << stringArray[1]; // ' is'
cout << stringArray[2]; // ' th'
cout << stringArray[3]; // 'e str'
cout << stringArray[4]; // 'ing we'
cout << stringArray[5]; // ' will use'

我可以很好地对字符串进行标记,但对我来说最难的部分是如何在为当前字符串toke分配字符串之前指定stringArray中的元素数量,以及如何从函数中返回stringArray。

有人会告诉我如何编写这个函数吗?

Edit1:我不一定需要将结果放在字符串数组中的任何容器中,我可以将其作为带有某种索引的常规变量调用。

13 个答案:

答案 0 :(得分:11)

这是我第一次尝试使用向量和字符串:

vector<string> explode(const string& str, const char& ch) {
    string next;
    vector<string> result;

    // For each character in the string
    for (string::const_iterator it = str.begin(); it != str.end(); it++) {
        // If we've hit the terminal character
        if (*it == ch) {
            // If we have some characters accumulated
            if (!next.empty()) {
                // Add them to the result vector
                result.push_back(next);
                next.clear();
            }
        } else {
            // Accumulate the next character into the sequence
            next += *it;
        }
    }
    if (!next.empty())
         result.push_back(next);
    return result;
}

希望这能让你对如何解决这个问题有所了解。在您的示例字符串上,它使用以下测试代码返回正确的结果:

int main (int, char const **) {
    std::string blah = "___this_ is__ th_e str__ing we__ will use__";
    std::vector<std::string> result = explode(blah, '_');

    for (size_t i = 0; i < result.size(); i++) {
        cout << "\"" << result[i] << "\"" << endl;
    }
    return 0;
}

答案 1 :(得分:9)

使用STL(抱歉没有编译器未经测试)

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

int main()
{
    std::vector<std::string>   result;

    std::string str = "___this_ is__ th_e str__ing we__ will use__";

    std::stringstream  data(str);

    std::string line;
    while(std::getline(data,line,'_'))
    {
        result.push_back(line); // Note: You may get a couple of blank lines
                                // When multiple underscores are beside each other.
    }
}

//或定义一个标记

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

struct Token: public std::string  // Yes I know this is nasty.
{                                 // But it is just to demosntrate the principle.    
};

std::istream& operator>>(std::istream& s,Token& t)
{
    std::getline(s,t,'_');

    // *** 
    // Remove extra '_' characters from the stream.
    char c;
    while(s && ((c = s.get()) != '_')) {/*Do Nothing*/}
    if (s)
    {
        s.unget(); // Put back the last char as it is not '_'
    }
    return s;
}

int main()
{   
    std::vector<std::string>   result;

    std::string str = "___this_ is__ th_e str__ing we__ will use__";

    std::stringstream  data(str);

    std::copy(std::istream_iterator<Token>(data),
              std::istream_iterator<Token>()
              std::back_inserter(result)
             );
}

答案 2 :(得分:3)

它对我有用:

#include <iostream>
#include <vector>
#include <string>

using namespace std;

vector<string> explode( const string &delimiter, const string &explodeme);

int main(int argc, char *argv[])
{
    string str = "I have a lovely bunch of cocoa nuts";
    cout<<str<<endl;
    vector<string> v = explode(" ", str);
    for(int i=0; i<v.size(); i++)
        cout <<i << " ["<< v[i] <<"] " <<endl;
}

vector<string> explode( const string &delimiter, const string &str)
{
    vector<string> arr;

    int strleng = str.length();
    int delleng = delimiter.length();
    if (delleng==0)
        return arr;//no change

    int i=0;
    int k=0;
    while( i<strleng )
    {
        int j=0;
        while (i+j<strleng && j<delleng && str[i+j]==delimiter[j])
            j++;
        if (j==delleng)//found delimiter
        {
            arr.push_back(  str.substr(k, i-k) );
            i+=delleng;
            k=i;
        }
        else
        {
            i++;
        }
    }
    arr.push_back(  str.substr(k, i-k) );
    return arr;
}

来源: http://www.zedwood.com/article/106/cpp-explode-function

答案 3 :(得分:1)

如果你坚持让stringArray数组与std::vector<>相反(这是正确的做法),你必须要么:

  1. 两次通过(一次计数,你看)
  2. 自己实施动态数组。
  3. 使用向量更容易vector::push_back()将新内容添加到最后。所以:

    vector* explode(string s){
      vector<string> *v = new vector<string>
      //...
      // in a loop
        v->push_back(string_fragment);
      //...
      return v;
    }
    

    毕竟不需要为了完整性而留下来。

    要返回使用char **的字符串数组。

    char ** explode(const char *in){
      ...
    
    }
    

    BTW--调用函数如何知道返回数组中有多少元素?你也必须解决这个问题。使用std::vector<>除非受到外力的限制......

答案 4 :(得分:1)

您可以使用字符串(std::vector<std::string>)的向量,使用push_back将每个标记附加到它,然后从tokenize函数返回它。

答案 5 :(得分:1)

使用std :: vector作为动态数组并将其作为结果返回。

答案 6 :(得分:1)

也许您应该使用列表而不是数组。这样你就不需要提前了解元素的数量。您也可以考虑使用STL容器。

答案 7 :(得分:0)

这是我的熟化代码(完整)。对于有相同需求的人来说,这可能是有用的。

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
using namespace std;

int main(){
        std::string s = "scott:tiger:mushroom";
        std::string delimiter = ":";

        std::vector<std::string> outputArr;
        size_t pos = 0;
        std::string token;
        while ((pos = s.find(delimiter)) != std::string::npos) {
            token = s.substr(0, pos);
            s.erase(0, pos + delimiter.length());
            outputArr.push_back(token);
        }
        outputArr.push_back(s);

        // Printing Array to see the results
        std::cout<<"====================================================================================\n";
        for ( int i=0;i<outputArr.size();i++){
                std::cout<<outputArr[i]<<"\n";
        }
        std::cout<<"====================================================================================\n";
}

干杯!!

答案 8 :(得分:0)

# turn a string into a deque based on a delimiter string
bool tolist(deque<string>& list,string basis,const string& cutter) {
    bool found = false;
    if (!cutter.empty()) {
        while (!basis.empty() ) {
            string::size_type pos = basis.find(cutter);
            if (pos != string::npos) {
                found = true;
                list.push_back(basis.substr(0, pos)); //pos says 2
                basis = basis.substr(pos+cutter.size(),string::npos);
            } else {
                list.push_back(basis);
                basis.clear();
            }
        }
    }
    return found;
}

答案 9 :(得分:0)

这对我有用:

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

using namespace std;

vector<string> split(string str, char delimiter) {
  vector<string> internal;
  stringstream ss(str); // Turn the string into a stream.
  string tok;

  while(getline(ss, tok, delimiter)) {
    internal.push_back(tok);
  }

  return internal;
}

int main(int argc, char **argv) {
  string myCSV = "one,two,three,four";
  vector<string> sep = split(myCSV, ',');

  // If using C++11 (which I recommend)
  /* for(string t : sep)
   *  cout << t << endl;
   */

  for(int i = 0; i < sep.size(); ++i)
    cout << sep[i] << endl;
}

来源:http://code.runnable.com/VHb0hWMZp-ws1gAr/splitting-a-string-into-a-vector-for-c%2B%2B

答案 10 :(得分:0)

以下代码:

template <typename OutputIterator>
int explode(const string &s, const char c, OutputIterator output) {
    stringstream  data(s);
    string line;
    int i=0;
    while(std::getline(data,line,c)) { *output++ = line; i++; }
    return i;
}

int main(...) {
  string test="H:AMBV4:2:182.45:182.45:182.45:182.45:182.41:32:17700:3229365:201008121711:0";
  cout << test << endl; 
  vector<string> event;
**This is the main call**
  int evts = explode(test,':', back_inserter(event));
  for (int k=0; k<evts; k++) 
    cout << event[k] << "~";
  cout << endl;
}

<强>输出

H:AMBV4:2:182.45:182.45:182.45:182.45:182.41:32:17700:3229365:201008121711:0
H~AMBV4~2~182.45~182.45~182.45~182.45~182.41~32~17700~3229365~201008121711~0~

答案 11 :(得分:0)

等到您的数据结构类,然后使用链表对其进行编码。如果它是用于家庭作业,你可能只需启动阵列就可以逃脱。

答案 12 :(得分:0)

我认为我写了一个更简单的解决方案。

std::vector<std::string> explode(const std::string& string, const char delimiter) {

std::vector<std::string> result;
unsigned int start = 0, pos = 0;

while (pos != string.length()) {
    if (string.at(pos) == delimiter || pos + 1 == string.length()) {
        unsigned int size = (pos - start) + ((pos + 1) == string.length() ? 1 : 0);
        if (size != 0) { // Make this 'if' as a option? like a parameter with removeEmptyString?
            result.push_back(string.substr(start, size));
        }
        start = pos + 1;
    }
    pos++;
}

return std::move(result);

}