दिलचस्प पोस्ट
आयरेपोर्ट में स्टैक्ड बार चार्ट में सलाखों के लिए अलग-अलग रंग कैसे सेट करें? Google मुखपृष्ठ एक iframe में लोड नहीं करेगा एक छवि का विशिष्ट भाग धुंधला (आयताकार, परिपत्र)? पायथन में वर्तमान सीपीयू और रैम उपयोग कैसे प्राप्त करें? जावा में समवर्ती हैशमैप और हैशटेबल IOS 5 पर document.ontouchmove और स्क्रॉलिंग विस्तारित वर्ग के भीतर से 'इस' कीवर्ड को एक्सटेंशन विधि को कॉल करने की आवश्यकता क्यों है? सॉकेट.आईओ – मैं जुड़ा सॉकेट / क्लाइंट की एक सूची कैसे प्राप्त करूं? एंड्रॉइड में यूएसबी डिबगिंग कैसे सक्षम करें? क्या कस्टम तत्व वैध HTML5 हैं? TortoiseGit से सहेजे गए क्रेडेंशियल निकालें एंड्रॉइड एनडीके: एंड्रॉइडस्ट्यूडियो में * .so फाइलें कैसे शामिल हैं I हास्केल में बड़े पैमाने पर डिजाइन? SQL: चर के आधार पर डायनामिक स्तंभ नाम चुनें टंकिनर मेनू में फ्रेम के बीच स्विच करना

ढूँढें अगर स्ट्रिंग सी ++ में अन्य स्ट्रिंग के साथ समाप्त हो जाती है

मुझे कैसे पता लगा सकता है कि स्ट्रिंग सी ++ में किसी अन्य स्ट्रिंग के साथ समाप्त हो जाती है?

वेब के समाधान से एकत्रित समाधान "ढूँढें अगर स्ट्रिंग सी ++ में अन्य स्ट्रिंग के साथ समाप्त हो जाती है"

बस std::string::compare के साथ अंतिम एन वर्णों की std::string::compare :

 #include <iostream> bool hasEnding (std::string const &fullString, std::string const &ending) { if (fullString.length() >= ending.length()) { return (0 == fullString.compare (fullString.length() - ending.length(), ending.length(), ending)); } else { return false; } } int main () { std::string test1 = "binary"; std::string test2 = "unary"; std::string test3 = "tertiary"; std::string test4 = "ry"; std::string ending = "nary"; std::cout << hasEnding (test1, ending) << std::endl; std::cout << hasEnding (test2, ending) << std::endl; std::cout << hasEnding (test3, ending) << std::endl; std::cout << hasEnding (test4, ending) << std::endl; return 0; } 

इस फ़ंक्शन का उपयोग करें:

 inline bool ends_with(std::string const & value, std::string const & ending) { if (ending.size() > value.size()) return false; return std::equal(ending.rbegin(), ending.rend(), value.rbegin()); } 

boost::algorithm::ends_with (देखें http://www.boost.org/doc/libs/1_34_0/doc/html/boost/algorithm/ends_with.html ):

 #include <boost/algorithm/string/predicate.hpp> // works with const char* assert(boost::algorithm::ends_with("mystring", "ing")); // also works with std::string std::string haystack("mystring"); std::string needle("ing"); assert(boost::algorithm::ends_with(haystack, needle)); std::string haystack2("ng"); assert(! boost::algorithm::ends_with(haystack2, needle)); 

मुझे सी ++ के लिए सवाल है, लेकिन अगर किसी को इसके लिए एक अच्छा राजभाषा सी फ़ंक्शन की जरूरत है:

/* returns 1 iff str ends with suffix */ int str_ends_with(const char * str, const char * suffix) { if( str == NULL || suffix == NULL ) return 0; size_t str_len = strlen(str); size_t suffix_len = strlen(suffix); if(suffix_len > str_len) return 0; return 0 == strncmp( str + str_len - suffix_len, suffix, suffix_len ); }
/* returns 1 iff str ends with suffix */ int str_ends_with(const char * str, const char * suffix) { if( str == NULL || suffix == NULL ) return 0; size_t str_len = strlen(str); size_t suffix_len = strlen(suffix); if(suffix_len > str_len) return 0; return 0 == strncmp( str + str_len - suffix_len, suffix, suffix_len ); } 

std::mismatch विधि इस उद्देश्य की पूर्ति कर सकती है जब पिछली बार दोनों तारों के अंत से पुनरावृति करने के लिए प्रयोग किया जाता है:

 const string sNoFruit = "ThisOneEndsOnNothingMuchFruitLike"; const string sOrange = "ThisOneEndsOnOrange"; const string sPattern = "Orange"; assert( mismatch( sPattern.rbegin(), sPattern.rend(), sNoFruit.rbegin() ) .first != sPattern.rend() ); assert( mismatch( sPattern.rbegin(), sPattern.rend(), sOrange.rbegin() ) .first == sPattern.rend() ); 

एक स्ट्रिंग होने दें और स्ट्रिंग जो आप के लिए दिखते हैं। एक के आखिरी एन वर्णों को प्राप्त करने के लिए a.substr का प्रयोग करें और उनको बी की तुलना करें (जहां n की लंबाई b )

या std::equal ( <algorithm> ) का उपयोग करें

उदाहरण के लिए:

 bool EndsWith(const string& a, const string& b) { if (b.size() > a.size()) return false; return std::equal(a.begin() + a.size() - b.size(), a.end(), b.begin()); } 

मेरी राय में सबसे सरल, सी + + समाधान है:

 bool endsWith(const string& s, const string& suffix) { return s.rfind(suffix) == (s.size()-suffix.size()); } 

बहुत अजीब उत्तर rfind साथ ये सब rfind नहीं हैं बढ़ावा / एल्गोरिथ्म / स्ट्रिंग का उपयोग करना ठीक है, लेकिन मैं बढ़ावा देने से दूर रहना पसंद करता हूं। std::equal अच्छा है, लेकिन मैं कुछ स्ट्रिंग की तरह ही रखूंगा:

 #include <string> static bool endsWith(const std::string& str, const std::string& suffix) { return str.size() >= suffix.size() && 0 == str.compare(str.size()-suffix.size(), suffix.size(), suffix); } static bool startsWith(const std::string& str, const std::string& prefix) { return str.size() >= prefix.size() && 0 == str.compare(0, prefix.size(), prefix); } 

और कुछ अतिरिक्त सहायक ओवरलोड:

 static bool endsWith(const std::string& str, const char* suffix, unsigned suffixLen) { return str.size() >= suffixLen && 0 == str.compare(str.size()-suffixLen, suffixLen, suffix, suffixLen); } static bool endsWith(const std::string& str, const char* suffix) { return endsWith(str, suffix, std::string::traits_type::length(suffix)); } static bool startsWith(const std::string& str, const char* prefix, unsigned prefixLen) { return str.size() >= prefixLen && 0 == str.compare(0, prefixLen, prefix, prefixLen); } static bool startsWith(const std::string& str, const char* prefix) { return startsWith(str, prefix, std::string::traits_type::length(prefix)); } 

आईएमओ, सी ++ स्ट्रिंग स्पष्ट रूप से बेकार हैं, और असली दुनिया कोड में उपयोग किए जाने के लिए नहीं किए गए थे।

आप स्ट्रिंग :: आरएफआईडी का उपयोग कर सकते हैं

टिप्पणियों के आधार पर पूर्ण उदाहरण:

 bool EndsWith(string &str, string& key) { size_t keylen = key.length(); size_t strlen = str.length(); if(keylen =< strlen) return string::npos != str.rfind(key,strlen - keylen, keylen); else return false; } 

Grzegorz Bazior प्रतिक्रिया के बारे में मैंने इस क्रियान्वयन का इस्तेमाल किया है, लेकिन मूल एक में बग है (अगर मैं ".." के साथ ".so") की तुलना करता है तो सही है। मैं संशोधित फ़ंक्शन का प्रस्ताव:

 bool endsWith(const string& s, const string& suffix) { return s.size() >= suffix.size() && s.rfind(suffix) == (s.size()-suffix.size()); } 

ऊपर की तरह ही, यहाँ मेरा समाधान है

  template<typename TString> inline bool starts_with(const TString& str, const TString& start) { if (start.size() > str.size()) return false; return str.compare(0, start.size(), start) == 0; } template<typename TString> inline bool ends_with(const TString& str, const TString& end) { if (end.size() > str.size()) return false; return std::equal(end.rbegin(), end.rend(), str.rbegin()); } 

जांचें कि क्या str का प्रत्यय है , नीचे का उपयोग कर:

 /* Check string is end with extension/suffix */ int strEndWith(char* str, const char* suffix) { size_t strLen = strlen(str); size_t suffixLen = strlen(suffix); if (suffixLen <= strLen) { return strncmp(str + strLen - suffixLen, suffix, suffixLen) == 0; } return 0; } 

मैंने सोचा कि यह एक कच्चा समाधान पोस्ट करने के लिए समझ में आता है जो किसी भी पुस्तकालय कार्य का उपयोग नहीं करता है …

 // Checks whether `str' ends with `suffix' bool endsWith(const std::string& str, const std::string& suffix) { if (&suffix == &str) return true; // str and suffix are the same string if (suffix.length() > str.length()) return false; size_t delta = str.length() - suffix.length(); for (size_t i = 0; i < suffix.length(); ++i) { if (suffix[i] != str[delta + i]) return false; } return true; } 

एक सरल std::tolower हम इस मामले को असंवेदनशील बना सकते हैं

 // Checks whether `str' ends with `suffix' ignoring case bool endsWithIgnoreCase(const std::string& str, const std::string& suffix) { if (&suffix == &str) return true; // str and suffix are the same string if (suffix.length() > str.length()) return false; size_t delta = str.length() - suffix.length(); for (size_t i = 0; i < suffix.length(); ++i) { if (std::tolower(suffix[i]) != std::tolower(str[delta + i])) return false; } return true; } 

अगर आप मेरे जैसे हैं और सी + + शुद्धवाद में नहीं हैं, तो यहां एक पुरानी स्कोल हाइब्रिड है कुछ फायदे होते हैं जब स्ट्रिंग मुट्ठी भर के पात्रों से अधिक होते हैं, क्योंकि अधिकांश memcmp कार्यान्वयन मशीन के शब्दों की तुलना करते समय संभव होते हैं।

आपको चरित्र सेट के नियंत्रण में होना चाहिए। उदाहरण के लिए, यदि इस दृष्टिकोण का उपयोग यूटीएफ -8 या वॉचर प्रकार के साथ किया जाता है, तो कुछ नुकसान है क्योंकि यह चरित्र मैपिंग का समर्थन नहीं करेगा – जैसे, जब दो या दो से अधिक अक्षर तर्कसंगत समान होते हैं

 bool starts_with(std::string const & value, std::string const & prefix) { size_t valueSize = value.size(); size_t prefixSize = prefix.size(); if (prefixSize > valueSize) { return false; } return memcmp(value.data(), prefix.data(), prefixSize) == 0; } bool ends_with(std::string const & value, std::string const & suffix) { size_t valueSize = value.size(); size_t suffixSize = suffix.size(); if (suffixSize > valueSize) { return false; } const char * valuePtr = value.data() + valueSize - suffixSize; return memcmp(valuePtr, suffix.data(), suffixSize) == 0; }