নিম্নলিখিতটি ব্যবহার করে আমি সি ++ তে একটি স্ট্রিং পার্স করছি:
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()স্ট্রিং থেকে চর * তে রূপান্তর করতে ব্যবহার করতে না চান , আপনি টোকেনাইজ করতে সাবস্ট্রাস্ট এবং সন্ধান_প্রথম_টি ব্যবহার করতে পারেন ।
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()সস্তা এবং সহজ।
এই আমার গ্রহণ এখানে। এটি প্রান্তের কেসগুলি পরিচালনা করে এবং ফলাফলগুলি থেকে খালি প্রবেশগুলি সরানোর জন্য একটি anচ্ছিক পরামিতি নেয়।
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। : এখানে ডকুমেন্টেশন ব্যাখ্যা কিভাবে একটি উপযুক্ত 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()পদ্ধতিটির প্রতিলিপি তৈরি করে ))
এটি একটি সম্পূর্ণ পদ্ধতি যা কোনও ডিলিমিটারের উপর স্ট্রিং বিভক্ত হয় এবং কাটা আপ স্ট্রিংগুলির একটি ভেক্টরকে প্রদান করে।
এটি রায়ওয়াক ওয়ার্ক থেকে উত্তর থেকে অভিযোজিত। তবে, তার পরীক্ষা: 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;
}PS: বিভাজনের পরে স্ট্রিংগুলির দৈর্ঘ্য সমান হলে কেবল কাজ করে
ফাংশন:
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;