स्ट्रिंग विश्लेषण

Question

यदि एक स्ट्रिंग में कई अनिवार्य तत्व शामिल हो सकते हैं, जैसे कि @, #, $,%।

उन्हें कैसे ढूंढें और उन्हें हटाएं?

मुझे पता है कि इसके लिए एक लूप पुनरावृत्ति की आवश्यकता है, लेकिन मुझे नहीं पता कि sth का प्रतिनिधित्व कैसे करें, जैसे @, #, $,%।

यदि आप मुझे एक कोड उदाहरण दे सकते हैं, तो मुझे वास्तव में सराहना की जाएगी।

Answer 1

सामान्य मानक सी ++ दृष्टिकोण erase/remove idiom होगा :

bool is_bad(char c) 
{ 
    if(c == '@' || c == '#' || c == '$' || c == '%') 
    return true; 
    else 
    return false; 
} 

int main(int argc, char **argv) 
{ 
    string str = "a #test #@string"; 
    str.erase(std::remove_if(str.begin(), str.end(), is_bad), str.end()); 
} 

यदि आपका कंपाइलर सु पोर्ट्स लैम्बडास (या यदि आप बूस्ट का उपयोग कर सकते हैं), इसे भी कम किया जा सकता है। उदाहरण का उपयोग करते हुए बढ़ावा :: लैम्ब्डा:

string str = "a #test #@string"; 
    str.erase(std::remove_if(str.begin(), str.end(), (_1 == '@' || _1 == '#' || _1 == '$' || _1 == '%')), str.end()); 

(! Yay दो पंक्तियों)

Answer 2

आप कल्पना प्राप्त करना चाहते हैं, वहाँ .. Boost.Regex अन्यथा आप strchr समारोह के साथ संयोजन में STL replace समारोह का उपयोग कर सकते है

Answer 3

एक चरित्र ++ एकल उद्धरण, उदा C/C का प्रतिनिधित्व करती है '@', '#', इत्यादि। (उन कुछ को छोड़कर जिन्हें बचने की आवश्यकता है)।

स्ट्रिंग में किसी वर्ण की खोज करने के लिए, strchr() का उपयोग करें।

http://www.cplusplus.com/reference/clibrary/cstring/strchr/

Answer 4

इस सी या सी ++ है: यहाँ एक नमूना कोड के लिए एक लिंक है? (आपने इसे दोनों तरीकों से टैग किया है।)

शुद्ध सी में, आपको चरित्र द्वारा चरित्र के माध्यम से लूप करना होगा और अवांछित लोगों को हटा देना होगा। - यह बदले में प्रत्येक चरित्र की जांच करता है और उन सब ऊपर shuffles अगर वहाँ एक आप नहीं चाहते है

char *buf; 
int len = strlen(buf); 
int i, j; 

for (i = 0; i < len; i++) 
{ 
    if (buf[i] == '@' || buf[i] == '#' || buf[i] == '$' /* etc */) 
    { 
     for (j = i; j < len; j++) 
     { 
      buf[j] = buf[j+1]; 
     } 
     i --; 
    } 
} 

यह बहुत ही कुशल नहीं है: उदाहरण के लिए। यह सुनिश्चित करने के लिए कि आप नया अगला चरित्र देखें, आपको बाद में इंडेक्स को कम करना होगा।

Answer 5

और अगर आप किसी कारण से, यह अपने आप को सी-शैली क्या करना है, कुछ इस तरह काम करेगा:

char* oldstr = ... something something dark side ... 

int oldstrlen = strlen(oldstr)+1; 
char* newstr = new char[oldstrlen]; // allocate memory for the new nicer string 
char* p = newstr; // get a pointer to the beginning of the new string 

for (int i=0; i<oldstrlen; i++) // iterate over the original string 
    if (oldstr[i] != '@' && oldstr[i] != '#' && etc....) // check that the current character is not a bad one 
     *p++ = oldstr[i]; // append it to the new string 
*p = 0; // dont forget the null-termination 

Answer 6

जनरल एल्गोरिथ्म:

1. एक स्ट्रिंग है वर्ण हैं बनाएँ आप शुद्ध होना चाहते हैं: "@ # $%"
2. विषय स्ट्रिंग पर चरित्र द्वारा इटरेट चरित्र।
3. यदि प्रत्येक वर्ण शुद्ध सेट में पाया जाता है तो खोजें।
4. यदि कोई चरित्र मेल खाता है, तो उसे छोड़ दें।
5. यदि कोई वर्ण मेल नहीं खाता है, तो इसे परिणाम स्ट्रिंग में संलग्न करें।

आप उपयोग कर रहे स्ट्रिंग पुस्तकालय पर निर्भर करता है, इस तरह के strchr के रूप में कार्य/तरीकों कि एक या एक से ऊपर के चरणों के और अधिक लागू,() कर रहे हैं या लगता है() करता है, तो एक चरित्र एक स्ट्रिंग में है निर्धारित करने के लिए।

Answer 7

चरित्रकर्ता ऑपरेटर का उपयोग करें, यानी a'a' होगा। आपने यह नहीं कहा है कि क्या आप सी ++ तारों का उपयोग कर रहे हैं (जिस स्थिति में आप ढूंढें और विधियों को प्रतिस्थापित कर सकते हैं) या सी स्ट्रिंग्स, इस मामले में आप इस तरह कुछ उपयोग करेंगे (यह किसी भी तरह से सबसे अच्छा तरीका नहीं है, लेकिन यह एक आसान तरीका है जिस तरह से):

void RemoveChar(char* szString, char c) 
{ 
    while(*szString != '\0') 
    { 
     if(*szString == c) 
      memcpy(szString,szString+1,strlen(szString+1)+1); 

     szString++; 
    } 
} 

Answer 8

आप बार-बार एक पाश का उपयोग करें और कॉल कर सकते हैं find_last_of (http://www.cplusplus.com/reference/string/string/find_last_of/) अंतिम वर्ण है कि आप, की जगह खाली साथ बदलें, और फिर स्ट्रिंग में पीछे की ओर काम कर जारी रखना चाहते हैं खोजने के लिए।

#include <string> 
#include <algorithm> 
#include <iostream> 
struct OneOf { 
     std::string chars; 
     OneOf(const std::string& s) : chars(s) {} 
     bool operator()(char c) const { 
       return chars.find_first_of(c) != std::string::npos; 
     } 
}; 
int main() 
{ 
    std::string s = "string with @, #, $, %"; 
    s.erase(remove_if(s.begin(), s.end(), OneOf("@#$%")), s.end()); 
    std::cout << s << '\n'; 
} 

और हाँ, को बढ़ावा देने के लिए कुछ साफ तरीके इसे कम लिखने के लिए, उदाहरण के लिए boost::erase_all_regex

#include <string> 
#include <iostream> 
#include <boost/algorithm/string/regex.hpp> 
int main() 
{ 
    std::string s = "string with @, #, $, %"; 
    erase_all_regex(s, boost::regex("[@#$%]")); 
    std::cout << s << '\n'; 
} 

Answer 9

कुछ का उपयोग कर की तरह इस करना होगा प्रदान करता है:

Answer 10

मैं इस के लिए लगता है कि मैं का उपयोग करेंगे std::remove_copy_if:

#include <string> 
#include <algorithm> 
#include <iostream> 

struct bad_char { 
    bool operator()(char ch) { 
     return ch == '@' || ch == '#' || ch == '$' || ch == '%'; 
    } 
}; 

int main() { 
    std::string in("This@is#a$string%with@extra#stuff$to%ignore"); 
    std::string out; 
    std::remove_copy_if(in.begin(), in.end(), std::back_inserter(out), bad_char()); 
    std::cout << out << "\n"; 
    return 0; 
} 

परिणाम:

Thisisastringwithextrastufftoignore 

चूंकि इन अवांछित वर्ण वाले डेटा सामान्य रूप से किसी प्रकार की फ़ाइल से आते हैं, यह भी विचारशील है ng उनसे छुटकारा पाएं जब आप अवांछित डेटा को स्ट्रिंग में पढ़ने के बजाय फ़ाइल से डेटा पढ़ते हैं, और तब इसे फ़िल्टर कर रहे हैं। ऐसा करने के लिए, आप एक पहलू है कि सफेद स्थान के रूप में अवांछित पात्रों में वर्गीकृत किया बना सकते हैं:

struct filter: std::ctype<char> 
{ 
    filter(): std::ctype<char>(get_table()) {} 

    static std::ctype_base::mask const* get_table() 
    { 
     static std::vector<std::ctype_base::mask> 
      rc(std::ctype<char>::table_size,std::ctype_base::mask()); 

     rc['@'] = std::ctype_base::space; 
     rc['#'] = std::ctype_base::space; 
     rc['$'] = std::ctype_base::space; 
     rc['%'] = std::ctype_base::space; 
     return &rc[0]; 
    } 
}; 

इस का उपयोग करने के लिए, आप एक स्थान इस पहलू का उपयोग कर के साथ इनपुट धारा रंगना, और उसके बाद सामान्य रूप से पढ़ें। चूंकि आप एक स्ट्रिंग के बारे में बात कर रहे हैं

int main() { 
    std::istringstream in("This@is#a$string%with@extra#stuff$to%ignore"); 
    in.imbue(std::locale(std::locale(), new filter)); 

    std::copy(std::istream_iterator<char>(in), 
     std::istream_iterator<char>(), 
     std::ostream_iterator<char>(std::cout)); 

    return 0; 
}