STL学习笔记--string

string是字符串，其中单个元素类型是char类型

头文件：string

1.定义：常用构造函数

1. 无参构造string();

string str1; 	//str为空 : char* ('\0')

转定义后string为basic_string的重定义

2. string( size_type length, char ch );

string str2 (5,'a');
cout << str2;	//aaaaa

3. string( const char *str );
   用str初始化

string str3 ("abcde");
cout << str3;	//abcde

4. string( const char *str, size_type length );
   输入字符，取前面的几个

string str4 ("abcde",3);
cout << str4;	//abc

5. string( string &str, size_type index, size_type length );
   输入str，取中间一段

string str5 (str4,2,4);
cout << str5;	//bcd

6. 拷贝构造
   用一个对象对另一个对象初始化

string str6 (str3);
cout << str6;	//abcde

函数：empty() 判断函数是否为空，空返回ture(1),非空返回false(0)
size_type ： 转定义看到是size_t 的重命名
size_t ： 非负整数

2.属性（重要）

1. 容量（重要，注意区分不同的编译器容量不同）
   创建的对象可以容纳多少个字符

1.1 capacity()
vs ：15+n16 初始默认申请15个，如果溢出再多申请16个
vc6.0 ：31+n32

string str1;
cout << str1.capacity();	//15
string str2 (17,'a');
cout << str2.capacity();	//31=15+16

1.2 reserve() 修改容量大小，只能变大
大小改变同上，15+16*n

string str2 (5,'a');
str.reserver(30);
cout << str2.capacity();	//31=15+16

2. 字符串长度 length(); == 字符的个数 size();
   (相当于 strlen()😉

 string str1;
 cout << str1.length();	//0  
 string str2 (17,'a');
 cout << str2.length();	//17
 string str3 (7,'a');
 cout << str3.size();	//7

3. 重新设置字符个数 resize();
   容量不变

string str2 ("abcedf");
str.resize(3);
cout<< str2.size() << endl; //3
cout << str2.length() << endl; //3
cout << str2.capacity() <<endl;	//15
cout << str2 <<endl ; // abc

3.输出（查）

1>整个输出：

1. cout <<
   cout << 可以输出字符串
   在这里“<<” 是string类内的重载 ，所以str是类，不是字符串

2. c_str();
   是字符串的备份，不是字符串的本身
   此函数的作用是return备份 char *p 的地址
   class中有一个char *p，初始化时会有字符串，给p一个空间 p=new[15] 并将字符串放入

string str ("abcdef");
cout << str <<endl; // abcdef
cout << str.c_str() << endl; //abdef    c_str()函数返回一个指向正规C字符串的指针, 内容与本字符串相同. 

2>. 输出单个运算符

1. []下标运算符，越界崩溃
   下标运算只能查找或者修改已存在的
   string a；不可以用下标赋值会崩溃，因为string没有空间要用append（下标运算不能改变容量）
   赋值只能append或者inser
2. at(); ，越界异常 (异常可处理)
   越界抛出out_of_ range 异常

string str ("abcdef");
cout << str[2] <<endl; //c
cout << str.at(2) <<endl; //c

//越界处理 系统向外抛出异常
try{
	str.at(8);
}
catch(...) // catch(out_of_ range &a)
{
	cout << "越界了" << endl;
}

4.修改 （增、删、改）

1. 修改指定元素
   1>. []下标运算符
   2>.at();

 string str ("abcdef");
 str[0]=b;
 str.at(2)=b'
 cout << str <<endl; //bbbdef

2. 中间插入 insert();
   在index的位置插入一个对象：
   basic_string &insert( size_type index, const basic_string &str );
   在index的位置插入一个字符串：
   basic_string &insert( size_type index, const char *str );
   在index的位置插入字符串str的一段：
   basic_string &insert( size_type index1, const basic_string &str, size_type index2, size_type num );
   在index的位置插入一个字符串的前num位：
   basic_string &insert( size_type index, const char *str, size_type num );
   在index的位置插入一个num个字符ch：
   basic_string &insert( size_type index, size_type num, char ch );

3. 尾巴插入
   1>.+=拼接 ：拼接对象、字符串
   2>.appand();
   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 );拼接num个字符ch

4. 重新赋值
   1>.=赋值
   2>. “>>” 输入
   3>.assign();
   basic_string &assign( const basic_string &str ); 以str赋值
   basic_string &assign( const char *str ); 以字符串赋值
   basic_string &assign( const basic_string &str, size_type index, size_type len ); 以str中间几个赋值
   basic_string &assign( const char *str, size_type num ); 以字符串前几个赋值
   basic_string &assign( size_type num, char ch ); num个字符ch赋值

string str("abcd");
str.insert(1,"1");
str.append("2");
cout<<str<<endl;    //a1bcd2
str.assign("123456");
cout<<str<<endl;    //123456

5.操作函数–内部成员函数

用法：对象.函数(参数)；

1. 比较 compare();
   返回 1，0，-1
   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 );

cout<<str2.compare("abc")<<endl;

2. 复制（copy）：从里面复制到外面
   size_type copy( char *str, size_type num, size_type index );
   将对象的某一段复制到字符数组中
   返回值是copy的字符数

//使用copy会有警告--去除警告：预处理
#pragma warning(disable:4996) //去掉4996的错误报告
#pragma warning(disable:4110)
int main(){
 string str("abcdef");
 char arrstr[6]={0};
 str.copy(arrstr[6],2,3); //注意不要越界，该警告的也是提醒越界问题
 return 0;
}

3. 查找字串：find函数 (重要)
   从指定位置开始查找str，找到返回起始位置，找不到返回-1
   size_type find( const basic_string &str, size_type index );
   size_type find( const char *str, size_type index );
   size_type find( char ch, size_type index );

cout << str.find(str1,0)<<endl； //查找str1在str中的位置，从头开始找，找到返回位置
//改变输出类型： 没有找到返回'-1'时，用int类型输出才是'-1'，默认类型为无符号整型（为'-1'的补码）
cout << (int)str.find(str1,0)<<endl; 

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

string str("abcdef");
cout<<str.substr(1,4)<<endl; //bcde
cout<<str.substr(1)<<endl;   //bcdef

5. 交换
   swap( basic_string &str );
   交换两个的内容

string str("abcdef");
string str1(5,'a');
str.swap(str1);
cout<<str<<endl; //aaaaa
cout<<str1<<endl;//abcdef

6. 运算符重载
   eg： +

str=str1+str2;
astr=str1+"abc";

string的迭代器

1.定义

1. 定义
   string::iterator ite; (== int a;)
   string:类名 iterator:容器关键字 ite:为迭代器的名字
   string::iterator 为 ite 的类型 eg:string::iterator ite为指向string类型的迭代器
   （类似：operator : 运算符重载）

2.怎么用

2. 理解
   指向string对象元素的指针：string元素类型为char，ite为char char*；string元素类型为int，ite为char int*；
   本质是char* 指针，相当于一个字符的指针

• 使用：迭代器ite 与char* 使用方式相同

3. 遍历
   begin(); 返回一个迭代器,指向字符串的第一个元素.
   size(); 类型 ：size_type size();
   end(); 函数返回一个迭代器，指向字符串的末尾(最后一个字符的下一个位置).

	string str("abcdef"); 
	string::iterator ite；
	
	//指向字符串首地址
	//char* a=str.c_str(); //char* 的指针 
	ite = str.begin(); //迭代器 
	
	//方法一：
	for(int i=0;i<str.size();i++) //会出现警告 
	{
		cout << *ite << " ";
		ite++;
	} 
	
	/* 更改为： size 为 size_t（无符号整型），i与size改为同一类型
	for(size_t i=0;i<str.size();i++)
	{
		cout << *ite <<" ";
		ite++;
	} 
	*/
	
	//方法二：下标运算
	for(size_t i=0;i<str.size();i++)
	{
		cout << ite[i] <<" ";
	} 
	
	//方法三：
	for(ite;ite!=str.end();ite++) //end();返回下一位置：'/0'
	{
		cout<<*ite<<" ";
	}

4. 通过迭代器赋值

	string str("abcdef"); 
	string::iterator ite;
	
	//方法一： *
	ite = str.begin();
	for(ite;ite!=str.end();ite++)  //循环结束后，ite指向尾部
	{
		*ite='a';
	}
	cout << str << endl;   //aaaaaa
	
	//方法二：[] 下标运算符
	ite = str.begin();	
	ite[2]='w';
	cout << str << endl;   //aawaaa

5. 迭代器失效（重要）：重新申请空间时，迭代器失效
   eg：string是数组，重新申请空间
   若是链表，不用重新申请空间(头不变)

	string str("abcdef"); 
	string::iterator ite;
	ite = str.begin();
	str.append(18,'a'); //已重新申请空间
	ite = str.begin();	//重新指向新的空间，没有这条命令ite使用将崩溃
	ite[2]='w';
	cout<<str;  //abwdefaaaaaaaaaaaaaaaaaa

string成员函数涉及到迭代器的

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

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

8. append();连接（尾插法）
   basic_string &append( input_iterator start, input_iterator end ); 在字符串的末尾添加以迭代器start和end表示的字符序列.

9. 删除
   iterator erase( iterator pos );
   iterator erase( iterator start, iterator end );

10. 增加
    void insert( iterator i, size_type num, const char &ch );
    void insert( iterator i, iterator start, iterator end );

//注：将begin()，end() 位置也可以用迭代器去指
//append();  在str后面加str1的某段或全部
	string str("abc"); 
	string str1("def");
	str.append(str1.begin()+1,str1.end());  
	cout<<str<<endl;
	
//删除
	string str("abcdef"); 
	str.erase(str.begin()+1);
	cout<<str;  //acdef
	
	string str("abcdef"); 
	str.erase(str.begin()+1,str.begin()+5);
	cout<<str;  //af

//增加
	string str("abcdef"); 
	str.insert(str.begin()+2,5,'a');
	cout<<str; //abaaaaacdef
	
	string str("abcdef"); 
	string str1("aaaaaa"); 
	str.insert(str.begin()+2,str1.begin()+2,str1.end());
	cout<<str; //abcdefabaaaacdef

string的算法

头文件：algorithm

1. 遍历 for_each();
   template<class Inputlterator, class Function>
   Function for_each( Inputlterator_First, Inputlterator_Last, Function_func )
   参数为：迭代器头，迭代器尾，遍历时的功能(函数fun)
   要点：fun函数可以是 int 或者 void 型；fun函数参数是该容器元素的类型

2. 排序 sort();
   默认从小到大：
   template< class RandomAccesslterator>
   void sort(RandomAccesslterator_First, RandomAccesslterator_Last)
   从大到小：greater<>() 可以指定从大到小
   template< class RandomAccesslterator>
   void sort(RandomAccesslterator_First, RandomAccesslterator_Last, BinaryPredicate_Comp)

#include<iostream>
#include<string>
#include<algorithm>
#include<Functional>
using namespace std;

void fun(char c){
    cout<<c;
}
void Funfor(){
    string str("qwertyab");
    //遍历
    for_each(str.begin(),str.end(),fun);
    cout<<endl;

    //排序：默认从小到大
    sort(str.begin(),str.end());
    for_each(str.begin(),str.end(),fun);
    cout<<endl;

    //排序：从大到小
    sort(str.begin(),str.end(),greater<char>()); //greater:仿函数 头文件：Functional
    for_each(str.begin(),str.end(),fun);
    cout<<endl;
}

int main(){
    Funfor();
    return 0;
}