আমার কাছে বেআইনি বলে মনে হচ্ছে যে আমরা সকলেই এখানে গতিশীল সচেতন নার্দের সাথে SO তে প্রত্যেকেই এমন সংস্করণ উপস্থাপন করতে পারি নি যা ডিলিমিটারের জন্য একটি সংকলন সময় উত্পন্ন লুক আপ টেবিল ব্যবহার করে (উদাহরণস্বরূপ আরও নীচে বাস্তবায়ন করা)। সন্ধানী টেবিল এবং পুনরুক্তি ব্যবহারকারীর দক্ষতাতে স্টাড :: রেজেক্সকে পরাজিত করা উচিত, যদি আপনার রেজেক্সকে বীট করার প্রয়োজন না হয় তবে কেবল এটি ব্যবহার করুন, এর মানটি সি ++ 11 এবং সুপার নমনীয়।
কেউ কেউ ইতিমধ্যে রেগেক্সের পরামর্শ দিয়েছেন তবে এখানে নুবসের জন্য একটি প্যাকেজড উদাহরণ যা ওপি প্রত্যাশা করে ঠিক এমনটি করা উচিত:
std::vector<std::string> split(std::string::const_iterator it, std::string::const_iterator end, std::regex e = std::regex{"\\w+"}){
std::smatch m{};
std::vector<std::string> ret{};
while (std::regex_search (it,end,m,e)) {
ret.emplace_back(m.str());
std::advance(it, m.position() + m.length()); //next start position = match position + match length
}
return ret;
}
std::vector<std::string> split(const std::string &s, std::regex e = std::regex{"\\w+"}){ //comfort version calls flexible version
return split(s.cbegin(), s.cend(), std::move(e));
}
int main ()
{
std::string str {"Some people, excluding those present, have been compile time constants - since puberty."};
auto v = split(str);
for(const auto&s:v){
std::cout << s << std::endl;
}
std::cout << "crazy version:" << std::endl;
v = split(str, std::regex{"[^e]+"}); //using e as delim shows flexibility
for(const auto&s:v){
std::cout << s << std::endl;
}
return 0;
}
আমাদের যদি দ্রুত হতে হবে এবং সমস্ত চরিত্র 8 টি বিট হতে হবে এমন প্রতিবন্ধকতাটি স্বীকার করতে হবে তবে আমরা রূপক ব্যবহার করে সংকলনের সময় টেবিল তৈরি করতে পারি:
template<bool...> struct BoolSequence{}; //just here to hold bools
template<char...> struct CharSequence{}; //just here to hold chars
template<typename T, char C> struct Contains; //generic
template<char First, char... Cs, char Match> //not first specialization
struct Contains<CharSequence<First, Cs...>,Match> :
Contains<CharSequence<Cs...>, Match>{}; //strip first and increase index
template<char First, char... Cs> //is first specialization
struct Contains<CharSequence<First, Cs...>,First>: std::true_type {};
template<char Match> //not found specialization
struct Contains<CharSequence<>,Match>: std::false_type{};
template<int I, typename T, typename U>
struct MakeSequence; //generic
template<int I, bool... Bs, typename U>
struct MakeSequence<I,BoolSequence<Bs...>, U>: //not last
MakeSequence<I-1, BoolSequence<Contains<U,I-1>::value,Bs...>, U>{};
template<bool... Bs, typename U>
struct MakeSequence<0,BoolSequence<Bs...>,U>{ //last
using Type = BoolSequence<Bs...>;
};
template<typename T> struct BoolASCIITable;
template<bool... Bs> struct BoolASCIITable<BoolSequence<Bs...>>{
/* could be made constexpr but not yet supported by MSVC */
static bool isDelim(const char c){
static const bool table[256] = {Bs...};
return table[static_cast<int>(c)];
}
};
using Delims = CharSequence<'.',',',' ',':','\n'>; //list your custom delimiters here
using Table = BoolASCIITable<typename MakeSequence<256,BoolSequence<>,Delims>::Type>;
এটির জায়গায় getNextTokenফাংশন তৈরি করা সহজ:
template<typename T_It>
std::pair<T_It,T_It> getNextToken(T_It begin,T_It end){
begin = std::find_if(begin,end,std::not1(Table{})); //find first non delim or end
auto second = std::find_if(begin,end,Table{}); //find first delim or end
return std::make_pair(begin,second);
}
এটি ব্যবহার করাও সহজ:
int main() {
std::string s{"Some people, excluding those present, have been compile time constants - since puberty."};
auto it = std::begin(s);
auto end = std::end(s);
while(it != std::end(s)){
auto token = getNextToken(it,end);
std::cout << std::string(token.first,token.second) << std::endl;
it = token.second;
}
return 0;
}
এখানে একটি সরাসরি উদাহরণ: http://ideone.com/GKtkLQ