मेरे लिए यह अजीब लगता है कि हम सभी के साथ एसओ पर सचेत गति से गति करता है, किसी ने भी ऐसा संस्करण प्रस्तुत नहीं किया है जो परिसीमन के लिए संकलित समयबद्ध तालिका का उपयोग करता है (उदाहरण कार्यान्वयन आगे और नीचे)। एक लुक अप टेबल का उपयोग करते हुए और पुनरावृत्तियों को std :: regex को दक्षता में हरा देना चाहिए, यदि आपको regex को पीटने की आवश्यकता नहीं है, तो बस इसका उपयोग करें, इसका मानक C ++ 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