मैं निम्नलिखित का उपयोग करके 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 orthdfjgh 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 Qwer poui 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()चार * करने के लिए स्ट्रिंग से परिवर्तित करने के लिए, आप उपयोग कर सकते हैं substr और find_first_of को tokenize।
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()क्योंकि इसमें मुझे स्ट्रिंग के बजाय चार सरणी का उपयोग करने की आवश्यकता होगी।
.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';
}पहली बार जब लूप स्ट्रिंग सीमांकक के पहले चरित्र का उपयोग करके एक टोकन निकालता है। दूसरा जबकि लूप बाकी सीमांकक को छोड़ देता है और अगले टोकन की शुरुआत में रुक जाता है।
मैं उपयोग करूंगा 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';
}उत्तर पहले से ही मौजूद है, लेकिन चयनित-उत्तर इरेज़ फ़ंक्शन का उपयोग करता है जो बहुत महंगा है, कुछ बहुत बड़े स्ट्रिंग (एमबीएस में) के बारे में सोचें। इसलिए मैं नीचे फ़ंक्शन का उपयोग करता हूं।
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)अप्रचलित हो जाए।
यदि आप स्ट्रिंग को संशोधित नहीं करना चाहते हैं (विन्सेन्ज़ो पीआईआई द्वारा जवाब में) और पिछले टोकन को भी आउटपुट करना चाहते हैं, तो आप इस दृष्टिकोण का उपयोग करना चाह सकते हैं:
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;