다음을 사용하여 C ++에서 문자열을 구문 분석하고 있습니다.
using namespace std;
string parsed,input="text to be parsed";
stringstream input_stringstream(input);
if (getline(input_stringstream,parsed,' '))
{
// do some processing.
}단일 문자 구분 기호로 구문 분석하는 것이 좋습니다. 그러나 문자열을 구분 기호로 사용하려면 어떻게해야합니까?
예 : 분할하고 싶습니다 :
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
mushroommushroom루프 외부의 출력, 즉s = mushroom
std::string token = s.substr(s.find(delimiter) + 1);하십시오. 길이가 +1 인 경우를 사용 하십시오.
이 방법은 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;
}split("abc","a")하지 않습니다. 벡터 또는 단일 문자열 "bc"을 반환합니다 ["", "bc"]. 요소 벡터를 반환하면 더 의미가 있다고 생각합니다 . str.split()파이썬에서 사용 delim하면 처음이나 끝에서 발견 된 경우 빈 문자열을 반환해야한다는 것이 직관적 이었습니다. 그러나 그것은 단지 제 의견입니다. 어쨌든, 난 그냥 언급해야한다고 생각
if (!token.empty()) @kyriakosSt에서 언급 한 문제와 연속 구분 기호와 관련된 다른 문제를 방지 하는 것이 좋습니다 .
if (!token.empty())를 해결하는 것으로는 충분하지 않습니다.
문자열 구분 기호를 기준으로 문자열을 분할합니다 . "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
vector<string>나는 그것이 복사 생성자를 호출 것 같아요.
이 코드는 텍스트에서 줄을 나누고 모든 사람을 벡터에 추가합니다.
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");vector<string> split(char *phrase, const string delimiter="\n")
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());
}strtok()문자열 대신 char 배열을 사용해야하므로 C 함수는 사용하지 않고 C ++ 만 사용하고 싶습니다 .
.c_str()싸고 쉽습니다.
여기에 내가 걸릴 것입니다. 에지 케이스를 처리하고 결과에서 빈 항목을 제거하기 위해 선택적 매개 변수를 사용합니다.
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]()문자열 (또는 단일 문자) 구분 기호에 완벽하게 작동해야합니다. 를 포함하는 것을 잊지 마십시오 #include <sstream>.
std::string input = "Alfa=,+Bravo=,+Charlie=,+Delta";
std::string delimiter = "=,+";
std::istringstream ss(input);
std::string token;
std::string::iterator it;
while(std::getline(ss, token, *(it = delimiter.begin()))) {
while(*(++it)) ss.get();
std::cout << token << " " << '\n';
}첫 번째 while 루프는 문자열 분리 문자의 첫 번째 문자를 사용하여 토큰을 추출합니다. 두 번째 while 루프는 나머지 구분 기호를 건너 뛰고 다음 토큰의 시작 부분에서 중지합니다.
사용 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';
}답변은 이미 있지만 선택 답변은 매우 비용이 많이 드는 지우기 기능을 사용합니다. 매우 큰 문자열 (MB)을 생각하십시오. 따라서 아래 기능을 사용합니다.
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;
}string.split()방식
이것은 문자열을 구분 기호로 나누고 잘린 문자열의 벡터를 반환하는 완전한 방법입니다.
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;
}while (true)코드에서는 일반적으로 이와 같은 것이 무섭습니다. 개인적으로 나는이를 다시 작성하는 것이 좋습니다 것 때문에에 비교가 있음 std::string::npos(또는 각각 검사에 대한이 mystring.size())가 만드는 while (true)오래된합니다.
문자열을 수정하지 않으려면 (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;
}#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> WSJCppCore::split(const std::string& sWhat, const std::string& sDelim) {
std::vector<std::string> vRet;
int nPos = 0;
int nLen = sWhat.length();
int nDelimLen = sDelim.length();
while (nPos < nLen) {
std::size_t nFoundPos = sWhat.find(sDelim, nPos);
if (nFoundPos != std::string::npos) {
std::string sToken = sWhat.substr(nPos, nFoundPos - nPos);
vRet.push_back(sToken);
nPos = nFoundPos + nDelimLen;
if (nFoundPos + nDelimLen == nLen) { // last delimiter
vRet.push_back("");
}
} else {
std::string sToken = sWhat.substr(nPos, nLen - nPos);
vRet.push_back(sToken);
break;
}
}
return vRet;
}단위 테스트 :
bool UnitTestSplit::run() {
bool bTestSuccess = true;
struct LTest {
LTest(
const std::string &sStr,
const std::string &sDelim,
const std::vector<std::string> &vExpectedVector
) {
this->sStr = sStr;
this->sDelim = sDelim;
this->vExpectedVector = vExpectedVector;
};
std::string sStr;
std::string sDelim;
std::vector<std::string> vExpectedVector;
};
std::vector<LTest> tests;
tests.push_back(LTest("1 2 3 4 5", " ", {"1", "2", "3", "4", "5"}));
tests.push_back(LTest("|1f|2п|3%^|44354|5kdasjfdre|2", "|", {"", "1f", "2п", "3%^", "44354", "5kdasjfdre", "2"}));
tests.push_back(LTest("|1f|2п|3%^|44354|5kdasjfdre|", "|", {"", "1f", "2п", "3%^", "44354", "5kdasjfdre", ""}));
tests.push_back(LTest("some1 => some2 => some3", "=>", {"some1 ", " some2 ", " some3"}));
tests.push_back(LTest("some1 => some2 => some3 =>", "=>", {"some1 ", " some2 ", " some3 ", ""}));
for (int i = 0; i < tests.size(); i++) {
LTest test = tests[i];
std::string sPrefix = "test" + std::to_string(i) + "(\"" + test.sStr + "\")";
std::vector<std::string> vSplitted = WSJCppCore::split(test.sStr, test.sDelim);
compareN(bTestSuccess, sPrefix + ": size", vSplitted.size(), test.vExpectedVector.size());
int nMin = std::min(vSplitted.size(), test.vExpectedVector.size());
for (int n = 0; n < nMin; n++) {
compareS(bTestSuccess, sPrefix + ", element: " + std::to_string(n), vSplitted[n], test.vExpectedVector[n]);
}
}
return bTestSuccess;
}std::vector<std::string> parse(std::string str,std::string delim){
std::vector<std::string> tokens;
char *str_c = strdup(str.c_str());
char* token = NULL;
token = strtok(str_c, delim.c_str());
while (token != NULL) {
tokens.push_back(std::string(token));
token = strtok(NULL, delim.c_str());
}
delete[] str_c;
return tokens;
}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;
}
size_t last = 0; size_t next = 0; while ((next = s.find(delimiter, last)) != string::npos) { cout << s.substr(last, next-last) << endl; last = next + 1; } cout << s.substr(last) << endl;