精华内容
下载资源
问答
  • find_first_not_of()函数 查找当前string与指定的字符串中任意一个字符都不相符的字符,并返回该字符在字符串中第一次出现的位置。 size_t find_first_not_of ( const string& str, size_t pos = 0 ) const; ...

    find_first_not_of()函数

    查找当前string与指定的字符串中任意一个字符都不相符的字符,并返回该字符在字符串中第一次出现的位置。

    size_t find_first_not_of ( const string& str, size_t pos = 0 ) const;
    size_t find_first_not_of ( const char* str, size_t pos, size_t n ) const;
    size_t find_first_not_of ( const char* str, size_t pos = 0 ) const;
    size_t find_first_not_of ( char ch, size_t pos = 0 ) const;
    
    • 在字符串中查找第一个与str中的字符都不匹配的字符,返回它的位置。搜索从pos开始。如果没找到就返回string::nops
    • 在字符串中查找第一个与str中的字符都不匹配的字符,返回它的位置。搜索从pos开始,最多查找n个字符。如果没找到就返回string::nops
    • 在字符串中查找第一个与ch不匹配的字符,返回它的位置。搜索从pos开始。如果没找到就返回string::nops

    注:string::npos 表示string类中各种成员函数失败时返回的值,其值为-1。

    find_first_of()函数

    搜索字符串中属于任意一个str、s或c的字符,并返回字符串中第一个出现的位置。

    size_t find_first_of ( const string& str, size_t pos = 0 ) const;
    size_t find_first_of ( const char* s, size_t pos, size_t n ) const;
    size_t find_first_of ( const char* s, size_t pos = 0 ) const;
    size_t find_first_of ( char ch, size_t pos = 0 ) const;
    
    • 在字符串中查找第一个与str中的字符相匹配的字符,返回它的位置。搜索从pos开始。如果没找到就返回string::nops
    • 在字符串中查找第一个与str中的字符相匹配的字符,返回它的位置。搜索从pos开始,最多查找n个字符。如果没找到就返回string::nops
    • 在字符串中查找第一个与ch不匹配的字符,返回它的位置。搜索从pos开始。如果没找到就返回string::nops

    注意:以上这两个方法都是查找当前string与指定的字符串中任意一个字符都不相符的字符的位置地址,而不是返回的是与指定的字符串完全匹配的字符串的首地址,如果若要匹配整个字符串,请使用find()。

    应用Demo

    #include <iostream>
    #include <string>
    using namespace std;
    void find_first_not_of_test(void)
    {
        string str="0123456789abcdef";
        int index01=str.find_first_not_of("013");
        cout << index01 << endl;
        int index02=str.find_first_not_of("0123456789abcdef");
        cout << index02 << endl;
    }
    void find_first_of_test(void)
    {
        string str="0123456789abcdef";
        int index=str.find_first_of("456");
        cout << index << endl;
        int index02=str.find_first_of("zx2");
        cout << index02 << endl;
    }
    void find_test(void)
    {
        string str="0123456789abcdef";
        int index=str.find("abc");
        cout << index << endl;
        int index02=str.find("xyz");
        cout << index02 << endl;
    }
    int main() {
        std::cout << "find_first_not_of_test" << std::endl;
        find_first_not_of_test();
        std::cout << "find_first_of_test" << std::endl;
        find_first_of_test();
        std::cout << "find_test" << std::endl;
        find_test();
        return 0;
    }
    

    运行如下:

    find_first_not_of_test
    2
    -1
    find_first_of_test
    4
    2
    find_test
    10
    -1
    
    
    展开全文
  • 1 str.find(str1) size_t find (const string& str, size_t pos = 0) 说明:从pos(默认是0,即从头开始查找)开始查找,找到第一个和str1相匹配的子串,返回该子串的起始索引位置;如果没有找到则返回string::...

    1 str.find(str1)

    size_t find (const string& str, size_t pos = 0)

    说明:从pos(默认是0,即从头开始查找)开始查找,找到第一个和str1相匹配的子串,返回该子串的起始索引位置;如果没有找到则返回string::npos

    str1.find(str2);          //  从串str1中查找时str2,返回str2中首个字符在str1中的地址
    str1.find(str2, 5);       //   从str1的第5个字符开始查找str2
    str1.find("usage");      //   如果usage在str1中查找到,返回u在str1中的位置
    str1.find("o");          //   查找字符o并返回地址
    str1.find("of big", 2, 2); //   从str1中的第二个字符开始查找of big的前两个字符
    

    2 str.find_first_of(str1, pos)

    /**
    *  @brief  Find position of a character of string.
    *  @param __str  String containing characters to locate.
    *  @param __pos  Index of character to search from (default 0).
    *  @return  Index of first occurrence.
    *
    *  Starting from @a __pos, searches forward for one of the
    *  characters of @a __str within this string.  If found,
    *  returns the index where it was found.  If not found, returns
    *  npos.
    */
    size_type
    find_first_of(const basic_string& __str, size_type __pos = 0) const
    _GLIBCXX_NOEXCEPT
    { return this->find_first_of(__str.data(), __pos, __str.size()); }
    

    2.1 说明

    pos位置(默认是0,即从头开始查找)开始查找str1,从前往后,如果找到str1中的任何一个字符,则返回其在str中的索引值;如果没有找到,则返回string::npos

    2.2 使用

    程序:

    // string::find_first_of
    #include <iostream>       // std::cout
    #include <string>         // std::string
    #include <cstddef>        // std::size_t
    
    int main ()
    {
      std::string str ("Please, replace the vowels in this sentence by asterisks.");
      std::size_t found = str.find_first_of("aeiou");
      while (found!=std::string::npos)
      {
        str[found]='*';
        found=str.find_first_of("aeiou",found+1);
      }
    
      std::cout << str << '\n';
    
      return 0;
    }
    

    输出:

    Pl**s*, r*pl*c* th* v*w*ls *n th*s s*nt*nc* by *st*r*sks.
    

    3 str.find_last_of(str1, pos)

    /**
    *  @brief  Find last position of a character.
    *  @param __c  Character to locate.
    *  @param __pos  Index of character to search back from (default end).
    *  @return  Index of last occurrence.
    *
    *  Starting from @a __pos, searches backward for @a __c within
    *  this string.  If found, returns the index where it was
    *  found.  If not found, returns npos.
    *
    *  Note: equivalent to rfind(__c, __pos).
    */
    size_type
    find_last_of(_CharT __c, size_type __pos = npos) const _GLIBCXX_NOEXCEPT
    { return this->rfind(__c, __pos); }
    

    3.1 说明

    npos(默认是字符串最后一个,即从后向前查找)开始查找,如果找到str1中的任何一个字符,则返回其在str中的索引值;如果没有找到则返回string::npos

    3.2 使用

    程序:

    // string::find_last_of
    #include <iostream>       // std::cout
    #include <string>         // std::string
    #include <cstddef>         // std::size_t
    
    void SplitFilename (const std::string& str)
    {
      std::cout << "Splitting: " << str << '\n';
      std::size_t found = str.find_last_of("/\\");
      std::cout << " path: " << str.substr(0,found) << '\n';
      std::cout << " file: " << str.substr(found+1) << '\n';
    }
    
    int main ()
    {
      std::string str1 ("/usr/bin/man");
      std::string str2 ("c:\\windows\\winhelp.exe");
    
      SplitFilename (str1);
      SplitFilename (str2);
    
      return 0;
    }
    

    输出:

    Splitting: /usr/bin/man
    path: /usr/bin
    file: man
    Splitting: c:\\windows\\winhelp.exe
    path: c:\\windows
    file: winhelp.exe
    

    4 举例

    4.1 用例

    程序:

    #include<iostream>          
    using namespace std;        
                                
    int main(void)              
    {                           
        string s = "一蓑烟雨任平生。";
        int len = s.size();     
        int count = s.size() / string("一").size();
        cout << "len = " << len << ", count = " << count << endl;
        cout << "find:平: pos = " << s.find("平") << endl;
        cout << "find_first_of:平: pos = " << s.find_first_of("平") << endl;
        cout << "find_last_of:平: pos = " << s.find_last_of("平") << endl;
        int pos = s.find("平", 9);                                                                                                                          
        cout << "pos:" << pos << endl;
        cout << "。: pos = " << s.find("。") << endl;
        cout << "。: pos = " << s.find_last_of("。") << endl;
        return 0;               
    } 
    

    输出结果:

    len = 24, count = 8
    find:: pos = 15
    find_first_of:: pos = 15
    find_last_of:平: pos = 17
    pos:15: pos = 21: pos = 23
    

    总结:

    C++中一个中文字符(包括汉字和中文符号)在字符串中的长度是3。在一个字符串中查找中文字符的时候最好不要用find_last_of,因为用find_last_of返回的是这个中文字符串的最后一个pos,而不是第一个,极容易出错。

    如上述例子如果判断一句话是否是以句号结尾,如果用find_last_of进行查找会得到23而一个句号的长度是3,加起来会大于整个字符串的长度,主要原因还是容易忘记他是子串的最后一个pos,如果用find或者find_first_of,出错概率较低。

    4.2 leetcode 345题:反转字符串中的元音字母

    class Solution {
    public:
        string reverseVowels(string s) {
            int left=0,right=s.size()-1;
            while(left<right)
            {
                left=s.find_first_of("aeiouAEIOU",left);
                right=s.find_last_of("aeiouAEIOU",right);
                if(left<right)
                {
                    swap(s[left++],s[right--]);
                }
            }
            return s;
        }
    };
    
    输入:hello
    返回:holle
    

    6 参考资料

    https://www.cnblogs.com/zh20130424/p/11099932.html

    https://blog.csdn.net/weixin_38285131/article/details/83051882

    http://www.cplusplus.com/reference/string/string/find/

    http://www.cplusplus.com/reference/string/string/find_first_of/

    http://www.cplusplus.com/reference/string/string/find_last_of/

    展开全文
  • C++string中find_first_of()函数和find_last_of()函数 1、find_first_of()函数 正向查找在原字符串中第一个与指定字符串中的某个字符匹配的字符,返回它的位置。若查找失败,则返回npos。(npos定义为保证大于任何...

    C++string中find_first_of()函数和find_last_of()函数

    1、find_first_of()函数

    正向查找在原字符串中第一个与指定字符串(或字符)中的某个字符匹配的字符,返回它的位置。若查找失败,则返回npos。(npos定义为保证大于任何有效下标的值。)

    • string str=“abcdefab”;
    • cout<<str.find_first_of(“hce”)<<endl;//待查串hce第一个出现在原串str中的字符是c,返回str中c的下标2,故结果为2。第二个参数为0,默认从原串下标为0开始正向查。
    • cout<<str.find_first_of(“ab”,1)<<endl;//从下标为1开始查,待查串ab第一个出现在原串str中的字符是b,返回b的下标,结果为1。

    2、find_last_of()函数

    逆向查找在原字符串中最后一个与指定字符串(或字符)中的某个字符匹配的字符,返回它的位置。若查找失败,则返回npos。(npos定义为保证大于任何有效下标的值。)

    • string str=“abcdefab”;
    • cout<<str.find_last_of(“wab”)<<endl;//原串最后一个字符首先与待查子串的每一个字符一一比较,一旦有相同的就输出原串该字符的下标.。结果为b的下标7。第二个参数为0,默认为npos。
    • cout<<str.find_last_of(“wab”,5)<<endl;//从原串中下标为5开始逆向查找,首先f与待查子串每一字符比较,若有相同的就输出该字符在原串的下标。若一个都没有,就依次逆向比较,即e再与待查子串一一比较,直到原串的b与待查子串中的b相同,然后输出该b在原串的下标1。

    代码:

    #include<iostream>
    using namespace std;
    int main()
    {
        string str="abcdefab";
        cout<<str.find_first_of('a')<<endl;//第二个参数为0,默认从下标为0开始查找。
        cout<<str.find_first_of("hce")<<endl;//待查串hce第一个出现在原串str中的字符是c,返回str中c的下标2,故结果为2。
        cout<<str.find_first_of("ab",1)<<endl;//从下标为1开始查,待查串ab第一个出现在原串str中的字符是b,返回b的下标,结果为1。
        cout<<str.find_first_of('h')<<endl;//原串没有待查字符h,故查不到,返回npos。
        cout<<str.find_first_of("hw")<<endl;//待查子串任一字符在原串中都找不到,故查不到,返回npos。
        cout<<str.find_last_of("wab")<<endl;//原串最后一个字符首先与待查子串的每一个字符一一比较,一旦有相同的就输出原串该字符的下标.。结果为b的下标7。
        cout<<str.find_last_of("wab",5)<<endl;
        //从原串中下标为5开始逆向查找,首先f与待查子串每一字符比较,若有相同的就输出该字符在原串的下标。
        //若一个都没有,就依次逆向比较,即e再与待查子串一一比较,直到原串的b与待查子串中的b相同,然后输出该b在原串的下标1。
        cout<<str.find_last_of("fab",5)<<endl;//输出f在原串的下标5。
        cout<<str.find_last_of("fab",7)<<endl;//输出b在原串的下标7。
        cout<<str.find_last_of("hwk")<<endl;//原串没有待查子串的任何字符,故返回npos。
        return 0;
    }
    //有效的下标应该在0~len-1范围内。len=str.size();
    
    

    运行结果:
    在这里插入图片描述
    find()和rfind()可以说是完全匹配查询。find_first_of()和find_last_of()可以说是部分匹配。 但它们的返回值都是原串某字符的下标,是无符号整数类型。如果待查为字符串的话,前者可以说是字符串与字符串的比较,后者可以说是字符与字符的比较。需要好好体会。

    相关链接:C++string中find_first_not_of()函数和find_last_not_of()函数
    相关链接:C++string中find()和rfind()函数

    永远相信美好🎈

    展开全文
  • find_first_of() 算法可以在第一个序列中搜索第二个序列在第一个序列中第一次出现的任何元序列被搜索的范围由输入迭代器指定,但用于确定搜索序列的迭代器至少是正向迭代器。用 == 运算符来比较这两个序列中的元素,...

    find_first_of() 算法可以在第一个序列中搜索第二个序列在第一个序列中第一次出现的任何元序列被搜索的范围由输入迭代器指定,但用于确定搜索序列的迭代器至少是正向迭代器。用 == 运算符来比较这两个序列中的元素,所以如果序列中是类类型的对象,这个类必须实现 operator==()。下面是一个使用 find_first_of() 的示例:

    string text {"The world of searching"};
    string vowels {"aeiou"};
    auto iter = std::find_first_of (std::begin (text), std:: end (text), std::begin (vowels),std::end(vowels));
    if(iter != std::end(text))
        std::cout << "We found '" << *iter << "'." << std::endl; //We found 'e'.

    这段代码会在 text 中查找第一次出现的 vowels 中的任意字符。在这个示例中,返回的迭代器指向“The”的第三个字母。可以用循环来查找 text 中所有匹配 vowels 中字符的字符:

    为了展示我们可以这样做,这里使用了 for 循环。第一个循环控制表达式以 text 的开始迭代器为初值定义了 iter。第二个循环控制表达式调用 find_first_of(),在 [iter,std::end(text))  这段范围内搜索第一次出现的 vowel 中的字符。

    find_first_of() 返回的迭代器保存在 iter 中,然后它被用来和 text 的结束迭代器进行比较。如果 iter 现在是 text 的结束迭代器,循环结束。如果 iter 不是 text 的结束迭代器,循环体会将这个字符附加到 iter 指向的 found 字符串上,然后自增 iter,使它指向下一个字符。这个字符会作为下一次搜索的开始位置。这段代码产生的输出为:

    string found {}; // Records characters that are found
    for(auto iter = std::begin(text);(iter = std::find_first_of (iter,std::end (text),std::begin(vowels),std::end(vowels)))!= std::end(text);)
            found += *(iter++);
    std::cout << "The characters \"" << found << "\" were found in text." << std::endl;

    另一个版本的 find_first_of() 可以让我们在第二个序列中搜索指定范围内的,可以使第 5 个参数指定的二元谓词返回 true 的元素。这个序列中的元素不必是同种类型。当这个 == 运算符不支持所有这些元素的比较时,就可以用这个版本的算法来定义相等比较,但也可以用其他的方式来定义。例如:

    std::vector<long> numbers{64L, 46L, -65L, -128L, 121L, 17L, 35L, 9L, 91L, 5L};
    int factors[] {7, 11, 13};
    auto iter = std::find_first_of(std::begin(numbers),std::end(numbers),std::begin(factors), std::end(factors),[](long v, long d) { return v % d == 0; });// Predicate - true for a match
    if (iter != std::end (numbers))
        std::cout << *iter << " was found." << std::endl;

    这个谓词是一个 lambda 表达式,当第一个参数可以被第二个参数整除时,它返回 true。

    所以这段代码会找到 -65,因为这是 numbers 中第一个可以被 factors 数组中的元素 13 整除的元素。断言中的参数类型可以和序列元素的类型不同,只要每个序列中的元素可以隐式转换为参数所对应的类型。在这里,factors 中的元素可以隐式转换为 long 类型。

    当然,可以用循环来查找所有使谓词返回 true 的元素:

    std::vector<long> numbers {64L, 46L, -65L, -128L, 121L, 17L, 35L, 9L, 91L, 5L};
    int factors[] {7, 11, 13};
    std::vector<long> results;  // Stores elements found
    auto iter = std::begin (numbers);
    while ((iter = std:: find_first_of (iter, std::end (numbers),std::begin(factors), std::end(factors),[](long v, long d) { return v % d == 0; }))!= std::end(numbers))
        results.push_back(*iter++);
    std::cout << results.size() <<" values were found:\n";
    std::copy(std::begin(results), std::end(results),std::ostream_iterator < long > {std::cout," " });
    std::cout << std::endl;

    这段代码可以找出 numbers 中所有以 factors 中的一个元素为因子的元素。while 循环会持续进行,只要 find_first_of() 返回的迭代器不是 numbers 的结束迭代器。iter 变量开始时指向 numbers 的第一个元素,然后会用它来保存被找到元素的迭代器,先前的值被覆盖。在循环体中,iter 指向的元素会被保存到 result 容器中,然后 iter 自增指向下一个元素。当循环结束时,results 包含的是找到的所有元素,然后用 copy() 算法输出它们。

    展开全文
  • auto s=a.find_first_of('5');//结果为 s=4; auto s=a.find_first_of('5',5); //没有查找到 s=string::npos; //如果查找某一个字符,与find()函数类似 2.在字符串中查找子串 //此时与find()函数不同,find()函...
  • C++字符串findfind_first_offind_last_of

    千次阅读 2018-10-14 22:27:36
    1.find 说明:查找字符串str1首字符在另一个字符串str中出现的位置,但是str1必须为其子字符串 str1.find(str2); // 从串str1中查找时str2,返回str2中首个字符在str1中的地址 str1.find(str2,5); // 从str...
  • C++ STL 中查找某些元素的第一次出现位置: find_first_of() 方法应用实例。
  • 在leedcode上刷题遇见了一个问题,错误的使用字符串函数find_last_of(),随查阅资料整理了这个三个函数的使用。 find()函数: 语法: size_type find( const basic_string &amp;str, size_type index ); ...
  • C++ Primer 学习中。。。   简单记录下我的学习过程...find_first_of //找第一个符合条件的位置 find_last_of  //找最后一个符合条件的位置 #include #include #include #include #include using namespace
  • C++ find_first_of

    千次阅读 2018-09-03 15:28:43
    之前用C++的字符串查找函数,错用了 find_first_of 等四个函数。实际的 find_first_of函数的作用是:在一个字符串中进行查找,返回值是第一个与指定字符串中任何字符匹配的字符位置;如果没有找到匹配的内容,就返回...
  • 这两个方法都是查找与()中指定的字符串中任意一个字符都不相符的字符的位置地址,而不是返回的是与()中制定的字符串完全匹配的字符串的首地址 find_first_not_of()语法: size_type find_first_not_of( const ...
  • string中findfind_first_of函数用法总结

    千次阅读 2017-07-11 09:26:19
    一:find 函数原型: size_t find ( const string& str, size_t pos = 0 ) const; size_t find ( const char* s, size_t pos, size_t n ) const; size_t find ( const char* s, size_t pos = 0 ) const; ...
  • 今天遇到个bug,原来是在查找子串时调用了find_first_of,导致字符串替换出现问题。 现将findfind_first_of的区别与几种使用形式介绍如下 find是查找子串,而find_first_of类似于模式匹配,只要与其中的一个...
  • string.find( )函数 判断 “abcdef” 中是否包含 “bcd”,使用如下语句: string a = "abcdef"; string b = "bcad"; string::size_type pos = a.find(b); //定义一个标志 if (pos != string::...
  • 一:find()函数用法详解  函数原型:  size_t find(const string &str, size_t pos = 0) const  size_t find (const char *s, size_t pos, size_t n) const  size_t find (const char *s, size_t pos =
  • string 的find函数使用时,会忽略的地方。
  • C++ string类:find()和find_first_of()

    千次阅读 2016-04-13 09:34:09
    find()和find_first_of() 容易搞混的两个函数,给出所有重载函数: int find(char c, int pos = 0) const;//从pos开始查找字符c在当前字符串的位置 int find(const char *s, int pos = 0) const;//从pos开始查找字符...
  • CString中find_first_offind_last_of()函数

    千次阅读 2016-05-05 18:11:32
    find_first_of(char c,int start=0),其中start可以省略,默认情况下下标为0的开始,查找第一个出现字符c的位置,返回其下标值,如果没找到,则返回-1, find_last_of(char c),同理,查找最后出现的字符c的位置,...
  • C++填坑之std::string::find_first_of

    千次阅读 2016-08-17 20:32:56
    C++使用之std::string::find_first_of
  • find_first_of : 如果在一个字符串P中查找另一个字符串T,如果T中含有P中的任何字符,则返回位置。 find_first_not_of: 从T找到第一个不含有P串字符的位置: 去除前导0:  #include&lt;bits/stdc++.h...
  • 1. 截取子串 s.substr(pos, n) //截取s中从pos开始(包括0)的n个字符的子串,并返回 s.substr(pos) //截取s中从从pos开始(包括0)到末尾的所有字符的子串,并返回 2. 替换子串 ...s.find(s1) ...
  • C++string中find_first_not_of()函数和find_last_not_of()函数 C++string中find_first_not_of()函数和find_last_not_of()函数 在学习这两个函数之前建议先学C++string中find_first_of()函数和find_last_of()函数...
  • find_first_of()和 find_last_of()

    万次阅读 2012-02-23 11:50:23
    string 类提供字符串处理函数,利用这些...1.函数find_first_of()和 find_last_of() 执行简单的模式匹配  例如:在字符串中查找单个字符c。 函数find_first_of() 查找在字符串中第1个出现的字符c,而函数find_last
  • find_first_of() //查找在字符串中第一个与子串中的某个字符匹配的字符,返回它的位置,如果没找到就返回string::npos find_first_not_of() //返回在字符串中首次出现的不匹配子串任何字符的首字符索引, 从index...
  • C++ string::find_first_of

    2013-10-06 12:07:27
    size_type find_first_of( const basic_string &str, size_type index = 0 );  size_type find_first_of( const char *str, size_type index = 0 );  size_type find_first_of( const char *str, size_type
  • find_first_not_of()与find_first_of()功能正好相反。不懂得可以先看我写的find_first_of()函数功能详解 find_firat_of()函数是在字符串中查找子串出现过的任意字符,也可以所字符串与子串都有的字符。 find_first_...
  • string类成员函数find/find_first_of用法详解

    万次阅读 多人点赞 2013-01-12 22:16:24
    一:find 函数原型: size_t find ( const string& str, size_t pos = 0 ) const; size_t find ( const char* s, size_t pos, size_t n ) const; size_t find ( const char* s, size_t pos = 0 ) const; size_t...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 382,502
精华内容 153,000
关键字:

find_first_of