문자열 구분 기호 (표준 C ++)를 사용하여 C ++에서 문자열 구문 분석 (분할)

문자열 구분 기호 (표준 C ++)를 사용하여 C ++에서 문자열 구문 분석 (분할)

---

다음을 사용하여 C ++에서 문자열을 구문 분석하고 있습니다.

string parsed,input="text to be parsed";
stringstream input_stringstream(input);

if(getline(input_stringstream,parsed,' '))
{
     // do some processing.
}

단일 문자 구분 기호로 구문 분석하는 것이 좋습니다. 그러나 문자열을 구분 기호로 사용하려면 어떻게해야합니까?

예 : 분할하고 싶습니다 :

scott>=tiger

> =를 구분 기호로 사용하여 scott 및 tiger를 얻을 수 있습니다.

---

이 std::string::find()함수를 사용 하여 문자열 구분 기호의 위치를 ​​찾은 다음을 사용 std::string::substr()하여 토큰을 얻을 수 있습니다.

예:

std::string s = "scott>=tiger";
std::string delimiter = ">=";
std::string token = s.substr(0, s.find(delimiter)); // token is "scott"

• 이 find(const string& str, size_t pos = 0)함수는 str문자열에서 또는 npos문자열을 찾을 수없는 경우 의 위치를 ​​반환합니다 .

• 이 substr(size_t pos = 0, size_t n = npos)함수는 위치 pos와 길이 에서 시작하여 객체의 하위 문자열을 반환합니다 npos.

---

여러 구분 기호가있는 경우 하나의 토큰을 추출한 후 토큰을 제거하여 (구분 기호 포함) 후속 추출을 진행할 수 있습니다 (원래 문자열을 유지하려면을 사용하십시오 s = s.substr(pos + delimiter.length());).

s.erase(0, s.find(delimiter) + delimiter.length());

이렇게하면 각 토큰을 얻기 위해 쉽게 반복 할 수 있습니다.

완전한 예

std::string s = "scott>=tiger>=mushroom";
std::string delimiter = ">=";

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

산출:

scott
tiger
mushroom

---

이 방법은 std::string::find이전 하위 문자열 토큰의 시작과 끝을 기억하여 원래 문자열을 변경하지 않고 사용합니다 .

#include <iostream>
#include <string>

int main()
{
    std::string s = "scott>=tiger";
    std::string delim = ">=";

    auto start = 0U;
    auto end = s.find(delim);
    while (end != std::string::npos)
    {
        std::cout << s.substr(start, end - start) << std::endl;
        start = end + delim.length();
        end = s.find(delim, start);
    }

    std::cout << s.substr(start, end);
}

---

다음 함수를 사용하여 문자열을 분할 할 수 있습니다.

vector<string> split(const string& str, const string& delim)
{
    vector<string> tokens;
    size_t prev = 0, pos = 0;
    do
    {
        pos = str.find(delim, prev);
        if (pos == string::npos) pos = str.length();
        string token = str.substr(prev, pos-prev);
        if (!token.empty()) tokens.push_back(token);
        prev = pos + delim.length();
    }
    while (pos < str.length() && prev < str.length());
    return tokens;
}

---

문자열 구분 기호

문자열 구분 기호를 기준으로 문자열을 분할합니다 . "adsf-+qwret-+nvfkbdsj-+orthdfjgh-+dfjrleih"문자열 구분 기호를 기반으로 문자열 을 분할하는 "-+"등의 결과는{"adsf", "qwret", "nvfkbdsj", "orthdfjgh", "dfjrleih"}

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

using namespace std;

// for string delimiter
vector<string> split (string s, string delimiter) {
    size_t pos_start = 0, pos_end, delim_len = delimiter.length();
    string token;
    vector<string> res;

    while ((pos_end = s.find (delimiter, pos_start)) != string::npos) {
        token = s.substr (pos_start, pos_end - pos_start);
        pos_start = pos_end + delim_len;
        res.push_back (token);
    }

    res.push_back (s.substr (pos_start));
    return res;
}

int main() {
    string str = "adsf-+qwret-+nvfkbdsj-+orthdfjgh-+dfjrleih";
    string delimiter = "-+";
    vector<string> v = split (str, delimiter);

    for (auto i : v) cout << i << endl;

    return 0;
}

산출

adsf
qwret
nvfkbdsj
정형 외과
dfjrleih

단일 문자 분리 문자

문자 분리 문자를 기준으로 문자열을 분할하십시오. "adsf+qwer+poui+fdgh"구분 기호 로 문자열 을 분할하는 등의 "+"출력{"adsf", "qwer", "poui", "fdg"h}

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

using namespace std;

vector<string> split (const string &s, char delim) {
    vector<string> result;
    stringstream ss (s);
    string item;

    while (getline (ss, item, delim)) {
        result.push_back (item);
    }

    return result;
}

int main() {
    string str = "adsf+qwer+poui+fdgh";
    vector<string> v = split (str, '+');

    for (auto i : v) cout << i << endl;

    return 0;
}

산출

adsf
쿼터
푸이
fdgh

---

strtok을 사용하면 여러 문자를 구분 기호로 전달할 수 있습니다. "> ="를 전달하면 예제 문자열이 올바르게 분리됩니다 (> 및 =가 개별 구분 기호로 계산 되더라도).

c_str()문자열을 char *로 변환하는 데 사용하지 않으려 는 경우 substr 및 find_first_of 를 사용 하여 토큰화할 수 있습니다.

string token, mystring("scott>=tiger");
while(token != mystring){
  token = mystring.substr(0,mystring.find_first_of(">="));
  mystring = mystring.substr(mystring.find_first_of(">=") + 1);
  printf("%s ",token.c_str());
}

---

이 코드는 텍스트에서 줄을 나누고 모든 사람을 벡터에 추가합니다.

vector<string> split(char *phrase, string delimiter){
    vector<string> list;
    string s = string(phrase);
    size_t pos = 0;
    string token;
    while ((pos = s.find(delimiter)) != string::npos) {
        token = s.substr(0, pos);
        list.push_back(token);
        s.erase(0, pos + delimiter.length());
    }
    list.push_back(s);
    return list;
}

전화 :

vector<string> listFilesMax = split(buffer, "\n");

---

여기에 내가 걸릴 것입니다. 에지 케이스를 처리하고 결과에서 빈 항목을 제거하기 위해 선택적 매개 변수를 사용합니다.

bool endsWith(const std::string& s, const std::string& suffix)
{
    return s.size() >= suffix.size() &&
           s.substr(s.size() - suffix.size()) == suffix;
}

std::vector<std::string> split(const std::string& s, const std::string& delimiter, const bool& removeEmptyEntries = false)
{
    std::vector<std::string> tokens;

    for (size_t start = 0, end; start < s.length(); start = end + delimiter.length())
    {
         size_t position = s.find(delimiter, start);
         end = position != string::npos ? position : s.length();

         std::string token = s.substr(start, end - start);
         if (!removeEmptyEntries || !token.empty())
         {
             tokens.push_back(token);
         }
    }

    if (!removeEmptyEntries &&
        (s.empty() || endsWith(s, delimiter)))
    {
        tokens.push_back("");
    }

    return tokens;
}

예

split("a-b-c", "-"); // [3]("a","b","c")

split("a--c", "-"); // [3]("a","","c")

split("-b-", "-"); // [3]("","b","")

split("--c--", "-"); // [5]("","","c","","")

split("--c--", "-", true); // [1]("c")

split("a", "-"); // [1]("a")

split("", "-"); // [1]("")

split("", "-", true); // [0]()

---

사용 boost::tokenizer합니다. 적절한 토크 나이저 기능을 만드는 방법을 설명하는 설명서는 다음과 같습니다. http://www.boost.org/doc/libs/1_52_0/libs/tokenizer/tokenizerfunction.htm

귀하의 경우에 적합한 것이 있습니다.

struct my_tokenizer_func
{
    template<typename It>
    bool operator()(It& next, It end, std::string & tok)
    {
        if (next == end)
            return false;
        char const * del = ">=";
        auto pos = std::search(next, end, del, del + 2);
        tok.assign(next, pos);
        next = pos;
        if (next != end)
            std::advance(next, 2);
        return true;
    }

    void reset() {}
};

int main()
{
    std::string to_be_parsed = "1) one>=2) two>=3) three>=4) four";
    for (auto i : boost::tokenizer<my_tokenizer_func>(to_be_parsed))
        std::cout << i << '\n';
}

---

이것은 문자열을 구분 기호로 나누고 잘린 문자열의 벡터를 반환하는 완전한 방법입니다.

ryanbwork의 답변을 채택한 것입니다. 그러나 그의 검사 : if(token != mystring)문자열에 반복되는 요소가 있으면 잘못된 결과를 제공합니다. 이것이 그 문제에 대한 나의 해결책입니다.

vector<string> Split(string mystring, string delimiter)
{
    vector<string> subStringList;
    string token;
    while (true)
    {
        size_t findfirst = mystring.find_first_of(delimiter);
        if (findfirst == string::npos) //find_first_of returns npos if it couldn't find the delimiter anymore
        {
            subStringList.push_back(mystring); //push back the final piece of mystring
            return subStringList;
        }
        token = mystring.substr(0, mystring.find_first_of(delimiter));
        mystring = mystring.substr(mystring.find_first_of(delimiter) + 1);
        subStringList.push_back(token);
    }
    return subStringList;
}

---

문자열을 수정하지 않으려면 (Vincenzo Pii의 답변에서 와 같이) 마지막 토큰도 출력하려면 다음 방법을 사용하십시오.

inline std::vector<std::string> splitString( const std::string &s, const std::string &delimiter ){
    std::vector<std::string> ret;
    size_t start = 0;
    size_t end = 0;
    size_t len = 0;
    std::string token;
    do{ end = s.find(delimiter,start); 
        len = end - start;
        token = s.substr(start, len);
        ret.emplace_back( token );
        start += len + delimiter.length();
        std::cout << token << std::endl;
    }while ( end != std::string::npos );
    return ret;
}

---

답변은 이미 있지만 선택 답변은 매우 비용이 많이 드는 지우기 기능을 사용합니다. 따라서 아래 기능을 사용합니다.

vector<string> split(const string& i_str, const string& i_delim)
{
    vector<string> result;

    size_t found = i_str.find(i_delim);
    size_t startIndex = 0;

    while(found != string::npos)
    {
        string temp(i_str.begin()+startIndex, i_str.begin()+found);
        result.push_back(temp);
        startIndex = found + i_delim.size();
        found = i_str.find(i_delim, startIndex);
    }
    if(startIndex != i_str.size())
        result.push_back(string(i_str.begin()+startIndex, i_str.end()));
    return result;      
}

---

#include<iostream>
#include<algorithm>
using namespace std;

int split_count(string str,char delimit){
return count(str.begin(),str.end(),delimit);
}

void split(string str,char delimit,string res[]){
int a=0,i=0;
while(a<str.size()){
res[i]=str.substr(a,str.find(delimit));
a+=res[i].size()+1;
i++;
}
}

int main(){

string a="abc.xyz.mno.def";
int x=split_count(a,'.')+1;
string res[x];
split(a,'.',res);

for(int i=0;i<x;i++)
cout<<res[i]<<endl;
  return 0;
}

추신 : 분할 후 문자열의 길이가 동일한 경우에만 작동

---

std::vector<std::string> split(const std::string& s, char c) {
  std::vector<std::string> v;
  unsigned int ii = 0;
  unsigned int j = s.find(c);
  while (j < s.length()) {
    v.push_back(s.substr(i, j - i));
    i = ++j;
    j = s.find(c, j);
    if (j >= s.length()) {
      v.push_back(s.substr(i, s,length()));
      break;
    }
  }
  return v;
}

참고 URL : https://stackoverflow.com/questions/14265581/parse-split-a-string-in-c-using-string-delimiter-standard-c