Cpp中string使用

1. 创建和初始化

#include 
//C语言风格字符串头文件：
#include  或 #include <string.h>

字符串的构造函数创建一个新字符串，包括: 
以length为长度的ch的拷贝（即length个ch）
以str为初值 (长度任意), 
以index为索引开始的子串，长度为length, 或者 
以从start到end的元素为初值. 
  string();
  string( size_type length, char ch );
  string( const char *str );
  string( const char *str, size_type length );
  string( string &str, size_type index, size_type length );
  string( input_iterator start, input_iterator end );

    string str1(5,'c');	//以length为长度的ch的拷贝（即length个ch）
    cout << str1 << endl;   // ccccc

    string str2( "abcde" );	//以str为初值 (长度任意),
    cout << str2 << endl;   //abcde

	string str2 = ("ILoveYou");
    string str3( str2, 1, 4 );	//str2串的下标1~4 -> "Love"
    cout << str3 << endl;	//Love

	string str4 = "123456";
	cout << str4 << endl;	//123456

	string str5;
	str5 = "654321";
	cout << str5 << endl;	//654321

	string str6 = str5;
	string str7(str5);
	cout << str6 << endl;	//654321
	cout << str7 << endl;	//654321

2. 操作符

== > < >= <= != + += []
可以用 ==, >, <, >=, <=, and !=比较字符串,
可以用 + 或者 += 操作符连接两个字符串, 
并且可以用[]获取特定的字符.

3. string和char*的区别

string str = "123456";	//长度为6
char array[] = "123456";	//长度为6+1 = 7(含一个\0)
cout << str.length() <<endl;
cout << str.size() << endl;
//不能使用printf直接打印string 如：
//printf("%s",str);
printf("%s\n",str.data());
printf("%s\n",str.c_str());

4. 相关操作

4.1 append 添加文本

append() 函数可以完成以下工作: 
在字符串的末尾添加str, 
在字符串的末尾添加str的子串,子串以index索引开始，长度为len 
在字符串的末尾添加str中的num个字符, 
在字符串的末尾添加num个字符ch, 
在字符串的末尾添加以迭代器start和end表示的字符序列. 

  basic_string &append( const basic_string &str );
  basic_string &append( const char *str );
  basic_string &append( const basic_string &str, size_type index, size_type len );
  basic_string &append( const char *str, size_type num );
  basic_string &append( size_type num, char ch );
  basic_string &append( input_iterator start, input_iterator end );

	//在字符串的末尾添加str, 
    string str1 = "string01_";
    string str2 = "string02_";
    cout<<str1<<endl;   //string01_
    cout<<str2<<endl;   //string02_
    char array[] = "array01_";
    cout<<array<<endl;  //array01_
    cout<<str1.append(str2)<<endl;  //string01_string02_
    cout<<str1<<endl;   //string01_string02_
    cout<<str1.append(array)<<endl; //string01_string02_array01_
    cout<<str1.append(array).append(str2)<<endl;
    //string01_string02_array01_array01_string02_
    cout<<str1<<endl;
    //string01_string02_array01_array01_string02_

	//在字符串的末尾添加str的子串,子串以index索引开始，长度为len 
	//在字符串的末尾添加str中的num个字符, 
	string str1 = "123456";
    string str2 = "ABCDEF";
    char array[] = "abcdef";
    str1.append(str2,0,3);  //下标0~3
    cout<<str1<<endl;   // 123456ABC
    str2.append(array,3);   //前三个字符
    cout<<str2<<endl;   //ABCDEFabc
    
    //在字符串的末尾添加num个字符ch, 
    string str = "Hello World";
    str.append(2,'!');
    cout << str << endl;	// Hello World!!

4.2 assign赋值

用str为字符串赋值, 
用str的开始num个字符为字符串赋值, 
用str的子串为字符串赋值,子串以index索引开始，长度为len 
用num个字符ch为字符串赋值. 

  basic_string &assign( const basic_string &str );
  basic_string &assign( const char *str );
  basic_string &assign( const char *str, size_type num );
  basic_string &assign( const basic_string &str, size_type index, size_type len );
  basic_string &assign( size_type num, char ch );

    string str1,str2 = "ABCDEFG";
    str1.assign(str2);
    cout << str1 <<endl;    // ABCDEFG
    str1.assign(str2,0,4);//从0索引开始的4个字符
    cout << str1 << endl;   // ABCD
    char array[] = "1234567890";
    str1.assign(array);
    cout << str1 << endl;   // 1234567890
    str1.assign(array,5);   //前5个字符
    cout << str1 << endl;   // 12345
    str1.assign(5,'#');
    cout << str1 << endl;   // #####

4.3 at

  reference at( size_type index );
  at() 函数返回一个引用，指向在index位置的字符. 
  如果index不在字符串范围内, at() 将报告"out of range"错误，并抛出out_of_range异常。

    string text = "1234567";
    cout << text.at(2) << endl; // 3
    cout << text[2] << endl;    // 3

4.4 begin()

 iterator begin();
 begin() 函数返回一个迭代器,指向字符串的第一个元素.

4.5 end()

  iterator end();
  end() 函数返回一个迭代器，指向字符串的末尾。
  (最后一个字符的下一个位置).

    string str = "1234567890";
    for(string::iterator it = str.begin();it!=str.end();++it)
        cout << *it << " ";

4.6 c_str

 const char *c_str();
 c_str() 函数返回一个指向正规C字符串的指针, 内容与本字符串相同. 

    string str = "ABC";
    printf("%s\n",str.c_str()); // ABC

4.7 capacity容量

 size_type capacity();
 capacity() 函数返回在重新申请更多的空间前字符串可以容纳的字符数. 
 这个数字至少与 size()一样大.

    string str = "";
    cout << str.capacity() << endl;

4.8 compare比较

比较自己和str, 
比较自己的子串和str,子串以index索引开始，长度为length 
比较自己的子串和str的子串，其中index2和length2引用str，index和length引用自己 
比较自己的子串和str的子串，其中str的子串以索引0开始，长度为length2，自己的子串以index开始，长度为length 

compare()函数以多种方式比较本字符串和str,返回：

返回值 情况 
小于零 this < str 
零 this == str 
大于零 this > str 

  int compare( const basic_string &str );
  int compare( const char *str );
  int compare( size_type index, size_type length, const basic_string &str );
  int compare( size_type index, size_type length, const basic_string &str, size_type index2,
  size_type length2 );
  int compare( size_type index, size_type length, const char *str, size_type length2 );

    string str1 = "1234567";
    string str2 = "1239";
    cout << str1.compare(str2) << endl; // -1 str1 < str2
    cout << str1.compare(1,1,str2) << endl; // 1 str1中"2">"1239"
    cout << str1.compare(0,3,str2,0,3) << endl; // 0 "123" = "123"
    cout << str1.compare(0,3,str2.c_str(),3) << endl;   // 0

4.9 copy拷贝

 size_type copy( char *str, size_type num, size_type index );
 copy() 函数拷贝自己的num个字符到str中（从索引index开始）。返回值是拷贝的字符数

4.10 data

  const char *data();
  data() 函数返回指向自己的第一个字符的指针.
  与c_str()类似。

4.11 empty

 bool empty();
 如果字符串为空则empty()返回真(true)，否则返回假(false).

    string str = "";
    cout << str.empty() << endl;  // 1

4.12 erase删除

删除pos指向的字符, 返回指向下一个字符的迭代器, 
删除从start到end的所有字符, 返回一个迭代器,指向被删除的最后一个字符的下一个位置 
删除从index索引开始的num个字符, 返回*this. 
参数index 和 num 有默认值, 
这意味着erase()可以这样调用：只带有index以删除index后的所有字符，
或者不带有任何参数以删除所有字符. 

  iterator erase( iterator pos );
  iterator erase( iterator start, iterator end );
  basic_string &erase( size_type index = 0, size_type num = npos );

    string str = "ABCRDE";
    str.erase(3);
    cout << str << endl; // ABC
    str.erase();
    cout << str << endl; // ""
    str = "123456";
    str.erase(0,3);
    cout <<str << endl;  // 456

4.13 find查找

返回str在字符串中第一次出现的位置（从index开始查找）。如果没找到则返回string::npos, 
返回str在字符串中第一次出现的位置（从index开始查找，长度为length）。如果没找到就返回string::npos, 
返回字符ch在字符串中第一次出现的位置（从index开始查找）。如果没找到就返回string::npos 

static constexpr auto npos{static_cast(-1)};

  size_type find( const basic_string &str, size_type index );
  size_type find( const char *str, size_type index );
  size_type find( const char *str, size_type index, size_type length );
  size_type find( char ch, size_type index );

    auto f = [](int loc){
        if(loc != string ::npos)
            cout << loc << endl;
        else
            cout << "not find" << endl;
    };
    string str = "ABCCDEF";
    unsigned int loc = str.find("AC",0);
    f(loc); // not find
    loc = str.find("AB",2);
    f(loc); // not find
    loc = str.find('C',0);
    f(loc); // 2
    loc = str.find('C',3);
    f(loc); // 3
    loc = str.find('C',4);
    f(loc); // not find

4.14 find_first_of

查找在字符串中第一个与str中的某个字符匹配的字符，返回它的位置。
搜索从index开始，如果没找到就返回string::npos 

查找在字符串中第一个与str中的某个字符匹配的字符，返回它的位置。
搜索从index开始，最多搜索num个字符。如果没找到就返回string::npos， 

查找在字符串中第一个与ch匹配的字符，返回它的位置。搜索从index开始。 

  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 index, size_type num );
  size_type find_first_of( char ch, size_type index = 0 );

    auto f = [](int loc){
        if(loc != string ::npos)
            cout << loc << endl;
        else
            cout << "not find" << endl;
    };
    string str1 = "ABCCDEF";
    string str2 = "HSSSKDPE";
    f(str1.find_first_of(str2,0));   // 4
    f(str1.find_first_of(str2.c_str(),0,4));//最大搜索str2中前4个字符
    f(str1.find_first_of('C',0));   // 2

4.15 find_first_not_of

在字符串中查找第一个与str中的字符都不匹配的字符，返回它的位置。
搜索从index开始。如果没找到就返回string::nops 

在字符串中查找第一个与str中的字符都不匹配的字符，返回它的位置。
搜索从index开始，最多查找num个字符。如果没找到就返回string::nops 

在字符串中查找第一个与ch不匹配的字符，返回它的位置。搜索从index开始。如果没找到就返回string::nops 

  size_type find_first_not_of( const basic_string &str, size_type index = 0 );
  size_type find_first_not_of( const char *str, size_type index = 0 );
  size_type find_first_not_of( const char *str, size_type index, size_type num );
  size_type find_first_not_of( char ch, size_type index = 0 );

    auto f = [](int loc){
        if(loc != string ::npos)
            cout << loc << endl;
        else
            cout << "not find" << endl;
    };
    string str1 = "ABCCDEF";
    string str2 = "HDMBKADPE";
    f(str1.find_first_not_of(str2,0));// 2
    //从str1下标0开始搜索，最大搜素str2中的4个字符
    f(str1.find_first_not_of(str2.c_str(),0,4));   // 0
    f(str1.find_first_not_of('C',2));   // 4

4.16 find_last_of

在字符串中查找最后一个与str中的某个字符匹配的字符，返回它的位置。
搜索从index开始。如果没找到就返回string::nops 

在字符串中查找最后一个与str中的某个字符匹配的字符，返回它的位置。
搜索从index开始，最多搜索num个字符。如果没找到就返回string::nops 

在字符串中查找最后一个与ch匹配的字符，返回它的位置。搜索从index开始。如果没找到就返回string::nops 

  size_type find_last_of( const basic_string &str, size_type index = npos );
  size_type find_last_of( const char *str, size_type index = npos );
  size_type find_last_of( const char *str, size_type index, size_type num );
  size_type find_last_of( char ch, size_type index = npos );

4.17 find _last_not_of

在字符串中查找最后一个与str中的字符都不匹配的字符，返回它的位置。
搜索从index开始。如果没找到就返回string::nops 

在字符串中查找最后一个与str中的字符都不匹配的字符，返回它的位置。
搜索从index开始，最多查找num个字符如果没找到就返回string::nops 

在字符串中查找最后一个与ch不匹配的字符，返回它的位置。搜索从index开始。如果没找到就返回string::nops 

  size_type find_last_not_of( const basic_string &str, size_type index = npos );
  size_type find_last_not_of( const char *str, size_type index = npos);
  size_type find_last_not_of( const char *str, size_type index, size_type num );
  size_type find_last_not_of( char ch, size_type index = npos );

4.18 get_allocator

 allocator_type get_allocator();
 get_allocator() 函数返回本字符串的配置器.

4.19 insert插入

在迭代器i表示的位置前面插入一个字符ch, 
在字符串的位置index插入字符串str, 
在字符串的位置index插入字符串str的子串(从index2开始，长num个字符), 
在字符串的位置index插入字符串str的num个字符, 
在字符串的位置index插入num个字符ch的拷贝, 
在迭代器i表示的位置前面插入num个字符ch的拷贝, 
在迭代器i表示的位置前面插入一段字符，从start开始，以end结束. 

  iterator insert( iterator i, const char &ch );
  basic_string &insert( size_type index, const basic_string &str );
  basic_string &insert( size_type index, const char *str );
  basic_string &insert( size_type index1, const basic_string &str, size_type index2, size_type num );
  basic_string &insert( size_type index, const char *str, size_type num );
  basic_string &insert( size_type index, size_type num, char ch );
  void insert( iterator i, size_type num, const char &ch );
  void insert( iterator i, iterator start, iterator end );

    string str1 = "ABCDEFG";
    str1.insert(str1.begin(),'@');
    cout << str1 << endl;  // @ABCDEFG
    string str2 = "__";
    str1.insert(3,str2); //在str1下标3的位置插入
    cout << str1 << endl;// @AB__CDEFG
    string str3 = "AB123CD";
    str1.insert(3,str3,2,3);
    cout << str1 << endl;// @AB123__CDEFG
    str1.insert(0,5,'#');
    cout << str1 << endl;// #####@AB123__CDEFG
    str1.insert(str1.end(),4,'>');
    cout << str1 << endl;// #####@AB123__CDEFG>>>>
    str1.insert(str1.end(),str3.begin(),str3.end());
    cout << str1 << endl;// #####@AB123__CDEFG>>>>AB123CD

4.20 length长度

 size_type length();
 length() 函数返回字符串的长度. 
 这个数字应该和size()返回的数字相同.

4.21 size

size_type size();
size() 函数返回字符串中现在拥有的字符数。

    string str1 = "ABCDEFG";
    cout << str1.length() << endl;  // 7
    cout << str1.size() << endl;    // 7

4.22 max_size

size_type max_size();
max_size() 函数返回字符串能保存的最大字符数。

    string str;
    cout << str.max_size() << endl;
    // 1073741820

4.23 rbeign

  const reverse_iterator rbegin();
  rbegin()函数返回一个逆向迭代器，指向字符串的最后一个字符。

4.24 rend

 const reverse_iterator rend();
 rend()函数返回一个逆向迭代器，指向字符串的开头（第一个字符的前一个位置）。

4.25 replace替换

用str中的num个字符替换本字符串中的字符,从index开始 
用str中的num2个字符（从index2开始）替换本字符串中的字符，从index1开始，最多num1个字符 
用str中的num个字符（从index开始）替换本字符串中的字符 
用str中的num2个字符（从index2开始）替换本字符串中的字符，从index1开始，num1个字符 
用num2个ch字符替换本字符串中的字符，从index开始 
用str中的字符替换本字符串中的字符,迭代器start和end指示范围 
用str中的num个字符替换本字符串中的内容,迭代器start和end指示范围， 
用num个ch字符替换本字符串中的内容，迭代器start和end指示范围. 

  basic_string &replace( size_type index, size_type num, const basic_string &str );
  basic_string &replace( size_type index1, size_type num1, const basic_string &str, size_type index2,
  size_type num2 );
  basic_string &replace( size_type index, size_type num, const char *str );
  basic_string &replace( size_type index, size_type num1, const char *str, size_type num2 );
  basic_string &replace( size_type index, size_type num1, size_type num2, char ch );
  basic_string &replace( iterator start, iterator end, const basic_string &str );
  basic_string &replace( iterator start, iterator end, const char *str );
  basic_string &replace( iterator start, iterator end, const char *str, size_type num );
  basic_string &replace( iterator start, iterator end, size_type num, char ch );

    string str1 = "ABCDEFG";
    string str2 = "1234567";
    str1.replace(2,3,str2); //用str2替换str1下标2开始的3个字符
    cout << str1 << endl;// AB1234567FG
    string str3 = "@#$%&";
    str1.replace(2,3,str3,1,2);// AB#$4567FG
    cout << str1 << endl;
    str1.replace(0,2,3,'K');
    cout << str1 << endl;// KKK#$4567FG
    str1.replace(str1.begin(),str1.end(),5,'A');
    cout << str1 << endl;// AAAAA

4.26 reserve保留空间

 void reserve( size_type num );
 reserve() 函数设置本字符串的capacity 以保留num个字符空间。

    string str;
    str.reserve(5);
    cout << str.size() << endl;// 0
    cout << str.capacity() << endl;// 5

4.27 resize

  void resize( size_type num );
  void resize( size_type num, char ch );
  resize()函数改变本字符串的大小到num, 
  新空间的内容不确定。也可以指定用ch填充。

    string str1 = "ABCDEFG";
    cout << str1.size() << endl;// 7
    cout << str1.capacity() << endl;// 7
    str1.resize(3);
    cout << str1 << endl;
    cout << str1.size() << endl;// 3
    cout << str1.capacity() << endl;// 7
    string str2 = "ASDF";
    cout << str2.size() << endl;// 4
    cout << str2.capacity() << endl;// 4
    str2.resize(7);
    cout << str2 << endl;   //ASDF   (后有3个空)
    cout << str2.size() << endl;// 7
    cout << str2.capacity() << endl;// 8
    str2.resize(10,'P');
    cout << str2 << endl;   //ASDF   PP
    cout << str2.size() << endl;// 10
    cout << str2.capacity() << endl;// 16
    str2.reserve(0);
    cout << str2.capacity() << endl;// 10

4.28 swap交换

  void swap( basic_string &str );

    string first = "ABCDEFG";
    string second = "1234567";
    first.swap(second);
    cout << first << endl;  // 1234567
    cout << second << endl; //ABCDEFG

4.28 substr

  basic_string substr( size_type index, size_type num = npos );
  substr()返回本字符串的一个子串，从index开始，长num个字符。
  如果没有指定，将是默认值 string::npos。
  这样，substr()函数将简单的返回从index开始的剩余的字符串。

    string str1 = "ABCDFFFG";
    string str2 = str1.substr(2);
    cout << str2 << endl;   // CDFFFG

4.29 rfind

从右向左找

返回最后一个与str中的某个字符匹配的字符，从index开始查找。
如果没找到就返回string::npos 

返回最后一个与str中的某个字符匹配的字符，从index开始查找,最多查找num个字符。
如果没找到就返回string::npos 
返回最后一个与ch匹配的字符，从index开始查找。如果没找到就返回string::npos 

  size_type rfind( const basic_string &str, size_type index );
  size_type rfind( const char *str, size_type index );
  size_type rfind( const char *str, size_type index, size_type num );
  size_type rfind( char ch, size_type index );

    auto f = [](int loc){
        if(loc != string ::npos)
            cout << loc << endl;
        else
            cout << "not find" << endl;
    };
    string str1 = "DABCDEDFGD";
    f(str1.rfind('D',8));// 6

4.30 shrink_to_fit

通过释放不使用内存减少内存使用

    string str = "ABCDEFG";
    str.resize(3);
    cout << str.capacity() << endl;// 7
    str.shrink_to_fit();
    cout << str.capacity() << endl;// 3

4.31 front

访问首字符

4.32 back

访问最后的字符

4.33 clear

移除所有字符

    string str = "ABCDEFG";
    cout << str.capacity() << endl;// 7
    cout << str.front() << endl;  // A
    cout << str.back() << endl;   // G
    str.clear();
    cout << str.size() << endl; // 0
    str.shrink_to_fit();
    cout << str.capacity() << endl;// 0

4.34 pop_back

移除末尾字符

4.35 push_back

后附字符到末尾

    string str = "ABCDEFG";
    str.pop_back();
    cout << str << endl;// ABCDEF
    str.push_back('>');
    cout << str << endl;// ABCDEF>

4.36 starts_with

c++20
检查 string 是否始于给定前缀。
若 string 始于前缀起始则为 true ，否则为 false 。

bool starts_with(std::basic_string_view<CharT, Traits> sv)const noexcept;
bool starts_with(CharT c) const noexcept;
bool starts_with(const CharT* s) const;

    string str = "ABCDEFG";
    string str2 = "ABC";
    cout << str.starts_with('A') << endl;// 1
    cout << str.starts_with("ADD") << endl;// 0
    cout << str.starts_with(str2) << endl;// 1

4.37 ends_with

c++20
检查 string 是否终于给定后缀。
若 string 终于后缀则为 true ，否则为 false 。

bool ends_with(std::basic_string_view<CharT, Traits> sv) const noexcept;
bool ends_with(CharT c) const noexcept;
bool ends_with(const CharT* s) const;

    string str = "ABCDEFG";
    string str2 = "G";
    cout << str.ends_with('A') << endl;// 0
    cout << str.ends_with("FG") << endl;// 1
    cout << str.ends_with(str2) << endl;// 1

4.38 erase和erase_if

void erase(std::basic_string<...>& c, const U& value);
void erase_if(std::basic_string<...>& c, Pred pred);

    string str = "KKKKAB00CDEF0G0MMMM";
    erase_if(str,isZero);
    cout << str << endl;  // ABCDEFGMMMM
    erase(str,'M');
    cout << str << endl;  // ABCDEFG

4.39 to_string

C++11
std::string to_string( int value );
std::string to_string( long value );
std::string to_string( long long value );
std::string to_string( unsigned value );
std::string to_string( unsigned long value );
std::string to_string( unsigned long long value );
std::string to_string( float value );
std::string to_string( double value );
std::string to_string( long double value );

    int num1 = 10;
    string str1 = to_string(num1);
    float num2 = 2.2;
    string str2 = to_string(num2);
    cout << str1 << endl;   // 10
    cout << str2 << endl;   // 2.200000

4.40 atof

#include 
double atof( const char *str );
功能:将字符串str转换成一个双精度数值并返回结果。 
参数str 必须以有效数字开头,
但是允许以“E”或“e”除外的任意非数字字符结尾。

double x = atof("42.0is the answer"); // 42.0

4.41 atoi

#include 
int atoi( const char *str );
功能：将字符串str转换成一个整数并返回结果。
参数str 以数字开头，
当函数从str 中读到非数字字符则结束转换并将结果返回。
i = atoi( "512.035" );
i 的值为 512.

4.42 atol

#include 
long atol( const char *str );
功能：将字符串转换成长整型数并返回结果。
函数会扫描参数str字符串，跳过前面的空格字符，
直到遇上数字或正负符号才开始做转换，
而再遇到非数字或字符串结束时才结束转换，并将结果返回。例如，
x = atol( "1024.0001" );
x的值为1024L.

5. 其他相关

tolower

#include 
int tolower( int ch );
功能：函数字符ch的小写形式。

toupper

#include 
int toupper( int ch );
功能：函数字符ch的大写形式。

isalnum

#include 
int isalnum( int ch );
功能：如果参数是数字或字母字符，函数返回非零值，否则返回零值。

isalpha

#include 
int isalpha( int ch );
功能：如果参数是字母字符，函数返回非零值，否则返回零值。

iscntrl

#include 
int iscntrl( int ch );
功能：如果参数是控制字符（0和0x1F之间的字符，或者等于0x7F）
函数返回非零值，否则返回零值。 

isdigit

#include 
int isdigit( int ch );
功能：如果参数是0到9之间的数字字符，函数返回非零值，否则返回零值.

isgraph

#include 
int isgraph( int ch );
功能：如果参数是除空格外的可打印字符（可见的字符），
函数返回非零值，否则返回零值。

islower

#include 
int islower( int ch );
功能：如果参数是小写字母字符，函数返回非零值，否则返回零值。

isprint

#include 
int isprint( int ch );
功能：如果参数是可打印字符（包括空格），
函数返回非零值，否则返回零值。

ispunct

#include 
int ispunct( int ch );
功能：如果参数是除字母，数字和空格外可打印字符，
函数返回非零值，否则返回零值。

isspace

#include 
int isspace( int ch );
功能：如果参数是空格类字符（即：单空格，制表符，垂直制表符，满页符，回车符，新行符），
函数返回非零值，否则返回零值。

isupper

#include 
int isupper( int ch );
功能：如果参数是大写字母字符，函数返回非零值，否则返回零值。

isxdigit

#include 
int isxdigit( int ch );
功能：如果参数是十六进制数字字符（即：A-F, a-f, 0-9），
函数返回非零值，否则返回零值。

memchr

#include 
void *memchr( const void *buffer, int ch, size_t count );
功能：函数在buffer指向的数组的count个字符的字符串里查找ch 首次出现的位置。
返回一个指针，指向ch 在字符串中首次出现的位置, 
如果ch 没有在字符串中找到，返回NULL。

 char names[] = "Alan Bob Chris X Dave";
 if( memchr(names,'X',strlen(names)) == NULL )
   printf( "Didn't find an X\n" );
 else
   printf( "Found an X\n" );

memcmp

#include 
int memcmp( const void *buffer1, const void *buffer2, size_t count );
功能：函数比较buffer1 和 buffer2的前count 个字符。返回值如下:
Value 				解释 
less than 0 		buffer1 is less than buffer2 
equal to 0 			buffer1 is equal to buffer2 
greater than 0 		buffer1 is greater than buffer2 

memcpy

#include 
void *memcpy( void *to, const void *from, size_t count );
功能：函数从from中复制count 个字符到to中，并返回to指针。
如果to 和 from 重叠，则函数行为不确定。

memmove

#include 
void *memmove( void *to, const void *from, size_t count );
功能: 与mencpy相同，不同的是当to 和 from 重叠，函数正常仍能工作。

memset

#include 
void *memset( void *buffer, int ch, size_t count );
功能: 函数拷贝ch 到buffer 从头开始的count 个字符里, 并返回buffer指针。 memset() 可以应用在将一段内存初始化为某个值。例如：
memset( the_array, '\0', sizeof(the_array) );

strcat

#include 
char *strcat( char *str1, const char *str2 );
功能：函数将字符串str2 连接到str1的末端，并返回指针str1.

strchr

#include 
char *strchr( const char *str, int ch );
功能：函数返回一个指向str 中ch 首次出现的位置，当没有在str 中找ch到返回NULL。

strcmp

#include 
int strcmp( const char *str1, const char *str2 );
功能：比较字符串str1 and str2, 返回值如下:
返回值 			解释 
less than 0 	str1 is less than str2 
equal to 0 		str1 is equal to str2 
greater than 0 	str1 is greater than str2 

strcoll

#include 
int strcoll( const char *str1, const char *str2 );
功能：比较字符串str1 和 str2

strcpy

#include 
char *strcpy( char *to, const char *from );
功能：复制字符串from 中的字符到字符串to，包括空值结束符。返回值为指针to。

strcspn

#include 
size_t strcspn( const char *str1, const char *str2 );
功能：函数返回str1 开头连续n个字符都不含字符串str2内字符的字符数。

strerror

#include 
char *strerror( int num );
功能：函数返回一个被定义的与某错误代码相关的错误信息。

strlen

#include 
size_t strlen( char *str );
功能：函数返回字符串str 的长度( 即空值结束符之前字符数目)。

strncat

#include 
char *strncat( char *str1, const char *str2, size_t count );
功能：将字符串from 中至多count个字符连接到字符串to中，追加空值结束符。返回处理完成的字符串。

strncmp

#include 
int strncmp( const char *str1, const char *str2, size_t count );
功能：比较字符串str1 和 str2中至多count个字符。返回值如下：
返回值 			解释 
less than 0 	str1 is less than str2 
equal to 0 		str1 is equal to str2 
greater than 0 	str1 is greater than str2 
如果参数中任一字符串长度小于count, 
那么当比较到第一个空值结束符时，就结束处理。

strncpy

#include 
char *strncpy( char *to, const char *from, size_t count );
功能：将字符串from 中至多count个字符复制到字符串to中。
如果字符串from 的长度小于count，其余部分用'\0'填补。
返回处理完成的字符串。

strpbrk

#include 
char *strpbrk( const char *str1, const char *str2 );
功能：函数返回一个指针，它指向字符串str2中任意字符在字符串str1 首次出现的位置，
如果不存在返回NULL。

strrchr

#include 
char *strrchr( const char *str, int ch );
功能：函数返回一个指针，它指向字符ch 在字符串str末次出现的位置，
如果匹配失败，返回NULL。

strspn

#include 
size_t strspn( const char *str1, const char *str2 );
功能：函数返回字符串str1中第一个不包含于字符串str2的字符的索引。

strstr

#include 
char *strstr( const char *str1, const char *str2 );
功能：函数返回一个指针，它指向字符串str2 首次出现于字符串str1中的位置，如果没有找到，返回NULL。

strtod

#include 
double strtod( const char *start, char **end );
功能：函数返回带符号的字符串start所表示的浮点型数。
字符串end 指向所表示的浮点型数之后的部分。
如果溢出发生，返回HUGE_VAL或 -HUGE_VAL。

strtok

#include 
char *strtok( char *str1, const char *str2 );
功能：函数返回字符串str1中紧接“标记”的部分的指针, 字符串str2是作为标记的分隔符。
如果分隔标记没有找到，函数返回NULL。为了将字符串转换成标记，第一次调用str1 指向作为标记的分隔符。
之后所以的调用str1 都应为NULL。

strtol

#include 
long strtol( const char *start, char **end, int base );
功能：函数返回带符号的字符串start所表示的长整型数。
参数base代表采用的进制方式。
指针end 指向start所表示的整型数之后的部分。
如果返回值无法用长整型表示，
函数则返回LONG_MAX或LONG_MIN. 
错误发生时，返回零。

strtoul

#include 
unsigned long strtoul( const char *start, char **end, int base );
功能：函数基本等同 strtol(), 
不同的是，它不仅可以返回长整型数，而且可以返回无符号的长整型数。

strxfrm

#include 
size_t strxfrm( char *str1, const char *str2, size_t num );
功能：函数将字符串str2 的前num 个字符存储到字符串str1中。如果strcoll() 处理字符串str1 和旧的字符串str2, 
返回值和strcmp()的处理结果一样。

注：内容参考C&C++参考手册，部分为直接引用。

• ——————END-2022-02-12——————
• 个人学习笔记，如有纰漏，敬请指正。
• 感谢您的阅读。