使用场合：

因为C风格字符串(以空字符结尾的字符数组)太过复杂难于掌握，不适合大程序的开发，所以C++标准库定义了一种string类，它不必担心内存是否足够及字符串长度，可以使用输入输出流方式直接进行操作，也可以通过文件等手段进行操作，同时C++的算法库对string也有着很好的支持 ，而且string还和c语言的字符串之间有着良好的接口，因此现在编程中涉及到字符串的处理，就可以直接使用string类了。

string类是由模板而实例化的一个标准类，本质上不是一个标准数据类型，我们尽可以把它看成是C++的基本数据类型。

string 函数列表

函数名 描述
begin 得到指向字符串开头的Iterator
end 得到指向字符串结尾的Iterator
rbegin 得到指向反向字符串开头的Iterator
rend 得到指向反向字符串结尾的Iterator
size 得到字符串的大小
length 和size函数功能相同
max_size 字符串可能的最大大小
capacity 在不重新分配内存的情况下，字符串可能的大小
empty 判断是否为空
[  ]、at 下标访问，取第几个元素，相当于数组
c_str 取得C风格的const char* 字符串
data 取得字符串内容地址
operator= 赋值操作符
reserve 预留空间
swap 交换函数
insert 插入字符
append 追加字符
push_back 追加字符
+= += 操作符
erase 删除字符串
clear 清空字符容器中所有内容
resize 重新分配空间
assign 和赋值操作符一样
replace 替代
copy 字符串到空间
find 查找
rfind 反向查找
find_first_of 查找包含子串中的任何字符，返回第一个位置
find_first_not_of 查找不包含子串中的任何字符，返回第一个位置
find_last_of 查找包含子串中的任何字符，返回最后一个位置
find_last_not_of 查找不包含子串中的任何字符，返回最后一个位置
substr 得到字串
compare 比较字符串
+ 字符串链接
== 判断是否相等
!= 判断是否不等于
< 、 <= 、 >=  、> 判断是否小于、小于等于、大于等于、大于
>> 从输入流中读入字符串
<< 字符串写入输出流
getline 从输入流中读入一行

一、string的初始化

首先，为了在我们的程序中使用string类型，我们必须包含头文件 。

#include<string>                   //注意这里不是string.h ,    string.h是C字符串头文件,   当然也可以用万能头文件<bits/stdc++.h>

using    namespace   std;     //此语句必不可少，否则有的编译器无法识别。

二、C++字符串声明与初始化赋值

声明一个字符串变量：

string s;//声明一个string 对象
string ss[10];//声明一个string对象的数组

这样我们就声明了一个字符串变量s 和一个字符串对象数组。

string是C++中一个类，就有构造函数和析构函数。上面的声明没有传入参数，所以就直接使用了string的默认的构造函数，这个函数所作的就是把Str初始化为一个空字符串。String类的构造函数和析构函数如下：

#include<bits/stdc++.h>
using namespace std;
int main()
{ freopen("a.in","r",stdin);freopen("a.out","w",stdout);string str;             //定义了一个空字符串strstr = "Hello world";    // 给str赋值为"Hello world"，也可以上面定义时直接赋值。char cstr[] = "abcde";  //定义了一个C字符串string s1(str);         //调用复制构造函数生成s1，s1为str的复制品string s4(cstr);        //将C字符串作为s4的初值string str1("1234");    //生成"1234"的复制品cout<<s1<<endl;cout<<s4<<endl;cout<<str1<<endl;string s2(str,6);       //将str内，开始于位置6的部分当作s2的初值string s5(cstr,3);      //将C字符串前3个字符作为字符串s5的初值。string str4("123456",5);//结果为"12345"cout<<s2<<endl; cout<<s5<<endl;cout<<str4<<endl;string s3(str,6,3);     //将str内，开始于6且长度顶多为3的部分作为s3的初值string str3("12345",1,3);//结果为"234"cout<<s3<<endl;cout<<str3<<endl;string s6(5,'A');       //生成一个字符串，包含5个'A'字符cout<<s6<<endl;string s7(str.begin(),str.begin()+5); //区间str.begin()和str.begin()+5内的字符作为初值cout<<s7<<endl;str.~string();           //销毁str字串所有字符，释放内存
}

程序执行结果为：

Hello world
abcde
1234
world
abc
12345
wor
234
AAAAA
Hello

三、string特性描述

可用下列函数来获得string的一些特性：

返回值类型 函数 描述
int capacity() 返回当前容量（即string中不必增加内存即可存放的元素个数
int max_size() 返回string对象中可存放的最大字符串的长度
int size() 返回当前字符串的大小
int length() 返回当前字符串的长度
bool empty() 当前字符串是否为空
void resize(int len,char c) 把字符串当前大小置为len，多去少补，多出的字符c填充不足的部分

大小和容量：

1. size()和length()：返回string对象的字符个数，他们执行效果相同。C++的话，倾向于用 size();
2.empty()用来检查字符串是否为空。
3. max_size()：返回string对象最多包含的字符数，很可能和机器本身的限制或者字符串所在位置连续内存的大小有关系。我们一般情况下不用关心他，应该大小足够我们用的。但是不够用的话，会抛出length_error异常。
4. capacity()函数返回在重新申请更多的空间前字符串可以容纳的字符数.就是string当前能够容纳的最大字符数；即capacity()>=length()。
5.resize()函数，为string重新分配内存。重新分配的大小由其参数决定，默认参数为0，这时候会对string进行非强制性缩减。

#include<bits/stdc++.h>
using namespace std;
int main()
{   string str;if (str.empty())  cout<<"str is NULL."<<endl;else   cout<<"str is not NULL."<<endl;str = str + "abcdefg";cout<<"str is "<<str<<endl;cout<<"str's size is "<<str.size()<<endl;cout<<"str's capacity is "<<str.capacity()<<endl;cout<<"str's max size is "<<str.max_size()<<endl;cout<<"str's length is "<<str.length()<<endl;str.resize(20,'c');cout<<"str is "<<str<<endl;str.resize(5);cout<<"str is "<<str<<endl;return 0;
}

程序执行结果为：

str is NULL.
str is abcdefg
str's size is 7
str's capacity is 7
str's max size is 1073741820
str's length is 7
str is abcdefgccccccccccccc
str is abcde

四、string的比较操作（==、>、<、>=、<=、!=、compare()）

1、用运算符 ==、>、<、>=、<=、和!=比较字符串，这些操作符是按从左向右顺序逐一比较，遇到不相等的字符就按这个位置上的两个字符的ASC码大小比较，ASC码大的字串大。

2、compare()比较两个字符串。

compare()为区分大小写比较字符串，比如，利用compare比较字串“str”与字串“lpsz”，等同于区分大小写比较“str”与“lpsz”的第一个相异字符，如果“str”该处的字符比“lpsz”大，则字符串“str”大于“lpsz”，返回1；如果“str”该处的字符比“lpsz”小，则字符串“str”小于“lpsz”，返回-1；“str”与“lpsz”内容完全一致则返回0。

返回值类型 函数 描述
int str.compare(const string &s) 比较字符串str和s的大小
int str.compare(int pos, int n,const string &s) 比较字符串str从pos开始的n个字符组成的字符串与s的大小
int str.compare(int pos, int n,const string &s,int pos2,int n2)

比较字符串str从pos开始的n个字符组成的字符串与s中pos2开始的n2个字符组成的字符串的大小
int str.compare(const char *s) ; 比较字符串str和c字符串s的大小
int  str.compare(int pos, int n,const char *s) ; 比较字符串str从pos开始的n个字符组成的字符串与c字符串s的大小
int str.compare(int pos, int n,const char *s, int pos2，int n2) ; 比较字符串str从pos开始的n个字符组成的字符串与c字符串s中pos2开始的n2个字符组成的字符串的大小

例一：

#include<bits/stdc++.h>
using namespace std;
int main()
{   string str1="hi,test,hello";string str2="hi,test";//字符串比较if(str1.compare(str2)>0) printf("str1>str2\n");else if(str1.compare(str2)<0)  printf("str1<str2\n");else printf("str1==str2\n");//str1的子串（从索引3开始，包含4个字符）与str2进行比较if(str1.compare(3,4,str2)==0)    printf("str1的指定子串等于str2\n");else  printf("str1的指定子串不等于str2\n");//str1指定子串与str2的指定子串进行比较if(str1.compare(3,4,str2,3,4)==0) printf("str1的指定子串等于str2的指定子串\n");else printf("str1的指定子串不等于str2的指定子串\n");//str1指定子串与字符串的前n个字符进行比较if(str1.compare(0,2,"hi,hello",2)==0) printf("str1的指定子串等于指定字符串的前2个字符组成的子串\n");else printf("str1的指定子串不等于指定字符串的前2个字符组成的子串\n");return 0;
}

程序执行结果为：

str1>str2
str1的指定子串不等于str2
str1的指定子串等于str2的指定子串
str1的指定子串等于指定字符串的前2个字符组成的子串

例二：

#include<bits/stdc++.h>
using namespace std;
int main()
{   string A("aBcdef");   string B("AbcdEf");   string C("123456");   string D("123dfg");int m = A.compare(B);int n = A.compare(1, 5, B);int p = A.compare(1, 5, B, 4, 2);int q = A.compare(0, 3, D, 0, 3);cout << "m=" << m << endl;cout << "n=" << n << endl;cout << "p=" << p << endl;cout << "q=" << q << endl;
}

程序执行结果为：

m=1
n=1
p=-1
q=1

五、字符串内容修改

（5.1）string类的赋值函数：给字符串赋值assign()函数。

返回值类型 函数 描述
string str=(const string &s); 把字符串s，赋值给字符串str
string str.assign(const char *s); 用c类型字符串s赋值给字符串str
string str.assign(const char *s,int n); 用c字符串s前n个字符，赋值给字符串str
string str.assign(const string &s); 把字符串s，赋值给字符串str
string str.assign(int n,char c); 用n个字符c，赋值给字符串str
string str.assign(const string &s,int start,int n); 把字符串s中从start开始的n个字符，赋值给字符串str
string str.assign(const_iterator first,const_itertor last); 把first和last迭代器之间的部分，赋值给字符串str 
#include<bits/stdc++.h>
using namespace std;
int main()
{   string str;string base="The quick brown fox jumps over a lazy dog.";str.assign(base);       //直接把base赋值给str//str(base)是错误的，只有在赋初值时可以用str(base)。cout<<str<<'\n';str.assign(base,10,9);  //把base第10个字符以及后面的8个字符赋给strcout<<str<<'\n';        // "brown fox"str.assign("pangrams are cool",7);//把参数中的0到6个字符串赋给strcout<<str<<'\n';        // "pangram"str.assign("c-string"); //直接使用参数赋值cout << str << '\n';    // "c-string"str.assign(10,'*');     //给str赋值10个'*'字符cout<<str<<'\n';        // "**********"str.assign<int>(10,0x2D);//赋值是10个'-'cout << str << '\n';     // "----------"str.assign(base.begin()+16,base.end()-12); //指定base迭代器范围的字符串cout<<str<<'\n';         // "fox jumps over"
}

程序执行结果为：

The quick brown fox jumps over a lazy dog.
brown fox
pangram
c-string
**********
----------
fox jumps over

（5.2）字符的连接（在尾巴上增加）

        1、append()函数可以用来在字符串的末尾追加字符和字符串，

        2、也可以用　+　和　+=　来实现，

        3、push_back()在字符串的末尾追加一个字符，不能追加字符串。

返回值类型 函数 描述
string str+=(const string &s); 把字符串s,连接到字符串str的结尾 
string str.append(const char *s);  把c类型字符串s,连接到字符串str的结尾 
string str.append(const char *s,int n); 把c类型字符串s的前n个字符,连接到字符串str的结尾 
string str.append(const string &s);  把字符串s,连接到字符串str的结尾 ,同+=相同。
string str.append(const string &s,int pos,int n); 把字符串s中从pos开始的n个字符,连接到字符串str的结尾 
string str.append(int n,char c);   在字符串str结尾添加n个字符c
string str.append(const_iterator first,const_iterator last); 把迭代器first和last之间的部分,连接到字符串str的结尾 
string str.push_back(char c) 在字符串str的末尾追加一个字符 
#include<bits/stdc++.h>
using namespace std;
int main()
{string str;string str2="Writing ";string str3="print 10 and then 5 more";str.append(str2);        //直接追加一个str2的字符串，追加"Writing "str.append(str3,6,3);    //后面追加str3第6个字符开始的3个字符串 ,追加"10 "str.append("dots are cool",5); //追加字符串形参的前5个字符，追加"dots "str.append("here: ");    //直接追加 "here: "str.append(10,'.');     //追加 10个'.' ，追加 ".........."str.append(str3.begin()+8,str3.end()); //从str3的第8个字符开始追加" and then 5 more"str.append<int>(5,65);   //这个比较特殊，意思是添加5个'A'，65对应的asc码就是65str+="lalala";           //字符串追加也可以用重载运算符实现str.push_back('X');    //括号内不能用双引号如：“X”,不能用多个字符如：“AFF”。 cout<<str<<'\n';
}

程序执行结果为：

Writing 10 dots here: .......... and then 5 moreAAAAAlalalaX

（5.3）string类的插入函数：插入字符串insert()。

返回值类型 函数 描述
string str.insert(int p0, const char *s); 在p0位置插入C语言字符串s
string str.insert(int p0, const char *s, int n); 在p0位置插入C语言字符串s的前n个字符
string str.insert(int p0,const string &s); 在p0位置插入C++字符串s
string str.insert(int p0,const string &s, int pos, int n); 在p0位置插入C++字符串s从pos开始的连续n个字符
string str.insert(int p0, int n, char c); 在p0处插入n个字符c
iterator str.insert(iterator it, char c); 在it处插入字符c，返回插入后迭代器的位置
void str.insert(iterator it, const_iterator first, const_iteratorlast); 在it处插入从first开始至last-1的所有字符
void str.insert(iterator it, int n, char c); 在it处插入n个字符c

例一、

#include <bits/stdc++.h>
using namespace std;
int main()
{   ios::sync_with_stdio(false);    string str="to be question";string str2="the ";string str3="or not to be";string::iterator it;//s.insert(pos,str)//在s的pos位置插入strstr.insert(6,str2);                 // to be the questioncout<<str<<endl;//s.insert(pos,str,a,n)在s的pos位置插入str中插入位置a到后面的n个字符str.insert(6,str3,3,4);             // to be not the questioncout<<str<<endl;//s.insert(pos,cstr,n)//在pos位置插入cstr字符串从开始到后面的n个字符str.insert(10,"that is cool",8);    // to be not that is the questioncout<<str<<endl;//s.insert(pos,cstr)在s的pos位置插入cstrstr.insert(10,"to be ");            // to be not to be that is the questioncout<<str<<endl;//s.insert(pos,n,ch)在s.pos位置上面插入n个chstr.insert(15,1,':');               // to be not to be: that is the questioncout<<str<<endl;//s.insert(s.it,ch)在s的it指向位置前面插入一个字符ch，返回新插入的位置的迭代器it = str.insert(str.begin()+5,','); // to be, not to be: that is the questioncout<<*it<<endl;cout<<str<<endl;//s.insert(s.it,n,ch)//在s的it所指向位置的前面插入n个chstr.insert (str.end(),3,'.');       // to be, not to be: that is the question...cout<<str<<endl;//s.insert(it,str.ita,str.itb)在it所指向的位置的前面插入[ita,itb)的字符串str.insert (it+2,str3.begin(),str3.begin()+3); // to be, or not to be: that is the question...cout<<str<<endl;
}

程序执行结果为：

to be the question
to be not the question
to be not that is the question
to be not to be that is the question
to be not to be: that is the question
,
to be, not to be: that is the question
to be, not to be: that is the question...
to be, or not to be: that is the question...

在竞赛中遇到大数据时，往往读文件成了程序运行速度的瓶颈，需要更快的读取方式。cin读入速度缓慢原因一般cin与stdin总是保持同步的，正因为这个的特性，导致cin有许多额外的开销，禁用这个特性只需一个语句std::ios::sync_with_stdio(false);，这样就可以取消cin于stdin的同步了，效率可以提高几乎10倍。

（5.4）string类的删除函数 ：删除字符串erase（）。

返回值类型 函数 描述
iterator str.erase(iterator first, iterator last); 删除[first，last）之间的所有字符，返回删除后迭代器的位置
iterator str.erase(iterator it); 删除it指向的字符，返回删除后迭代器的位置
string str.erase(int pos = 0, int n = npos); 删除pos开始的n个字符，返回修改后的字符串 
#include <bits/stdc++.h>
using namespace std;
int main()
{ string str("This is an example sentence.");cout << str << '\n';  // "This is an example sentence."str.erase (10,8);       //            ^^^^^^^^//直接指定删除的字符串位置第十个后面的8个字符cout << str << '\n';// "This is an sentence."str.erase (str.begin()+9);//           ^//删除迭代器指向的字符cout << str << '\n';// "This is a sentence."//       ^^^^^str.erase (str.begin()+5, str.end()-9);//删除迭代器范围的字符cout << str << '\n';// "This sentence."
}

程序执行结果为：

This is an example sentence.
This is an sentence.
This is a sentence.
This sentence.

（5.5）string类的替换函数（replace）：​​​​​替换字符串。

返回值类型 函数 描述
string str.replace(int p0, int n,const char *s); 删除从p0开始的n0个字符，然后在p0处插入串s
string str.replace(int p0, int n0,const char *s, int n); 删除p0开始的n0个字符，然后在p0处插入字符串s的前n个字符
string str.replace(int p0, int n0,const string &s); 删除从p0开始的n0个字符，然后在p0处插入串s
string str.replace(int p0, int n0,const string &s, int pos, int n); 删除p0开始的n0个字符，然后在p0处插入串s中从pos开始的n个字符
string str.replace(int p0, int n0,int n, char c); 删除p0开始的n0个字符，然后在p0处插入n个字符c
string str.replace(iterator first0, iterator last0,const char *s); 把[first0，last0）之间的部分替换为字符串s
string str.replace(iterator first0, iterator last0,const char *s, int n); 把[first0，last0）之间的部分替换为s的前n个字符
string str.replace(iterator first0, iterator last0,const string &s); 把[first0，last0）之间的部分替换为串s
string replace(iterator first0, iterator last0,int n, char c); 把[first0，last0）之间的部分替换为n个字符c
string replace(iterator first0, iterator last0,const_iterator first, const_iterator last); 把[first0，last0）之间的部分替换成[first，last）之间的字符串

例一：

#include <bits/stdc++.h>
using namespace std;
int main ()
{   string base="this is a test string.";string str2="n example";string str3="sample phrase";string str4="useful.";string str=base;   // "this is a test string."
cout<<str<<endl; //str第9个字符以及后面的5个字符被str2代替
str.replace(9,5,str2);  // "this is an example string." (1)
cout<<str<<endl;//第19个字符串以及后面的6个字符用str的第7个字符以及后面的6个字符代替
str.replace(19,6,str3,7,6);   // "this is an example phrase." (2)
cout<<str<<endl;//第8个字符以及后面的9个字符用字符串参数代替
str.replace(8,10,"just a");   // "this is just a phrase."     (3)
cout<<str<<endl;//第8个字符以及后面的5个字符用字符串参数的前7个字符替换
str.replace(8,6,"a shorty",7); // "this is a short phrase."    (4)
cout<<str<<endl;//第22以及后面的0个字符用3个叹号替换
str.replace(22,1,3,'!');       // "this is a short phrase!!!"  (5)
cout<<str<<endl;//迭代器的原理同上// Using iterators:    0123456789*123456789*
str.replace(str.begin(),str.end()-3,str3);      // "sample phrase!!!"      (1)
cout<<str<<endl;
str.replace(str.begin(),str.begin()+6,"replace");  // "replace phrase!!!"  (3)
cout<<str<<endl;
str.replace(str.begin()+8,str.begin()+14,"is coolness",7);//"replace is cool!!!" (4)
cout<<str<<endl;
str.replace(str.begin()+12,str.end()-4,4,'o');  // "replace is cooool!!!"  (5)
cout<<str<<endl;
str.replace(str.begin()+11,str.end(),str4.begin(),str4.end()); // "replace is useful." (6)
cout<<str<<endl;
}

程序执行结果为：

this is a test string.
this is an example string.
this is an example phrase.
this is just a phrase.
this is a short phrase.
this is a short phrase!!!
sample phrase!!!
replace phrase!!!
replace is cool!!!
replace is cooool!!!
replace is useful.

（5.6）sawp()函数：相互交换字符串

#include <bits/stdc++.h>
using namespace std;
int main()
{string str="give me";string str1="a cup'";str.swap(str1);cout<<str<<endl;    //输出:a cupcout<<str1<<endl;   //输出:give me
}

（5.7）把字符串清空

把字符串清空的方法有三个：

1、s=””;

２、s.clear();

３、s.erase();

（5.8）string和数值转换  ：

在c++11当中有定义好的现成的函数取调用，非常方便。

返回值类型 函数 描述
string to_string(val) 把val转换成string
int stoi(s,p,b) 把字符串s从p开始转换成b进制的int
long stol(s,p,b)  把字符串s从p开始转换成b进制的long
unsigned long stoul(s,p,b)  把字符串s从p开始转换成b进制的unsigned long
long long stoll(s,p,b) 把字符串s从p开始转换成b进制的long long
unsigned long long stoull(s,p,b) 把字符串s从p开始转换成b进制的unsigned long long
float stof(s,p) 把字符串s从p开始转换成float
double stod(s,p)  把字符串s从p开始转换成double
long double stold(s,p)  把字符串s从p开始转换成long double

以上函数是C++11中的库函数，让Dev C++支持C++11还要在软件中进行设置。

1.先在dev的【工具】里找到【编译选项】

2.一开始普遍的dev应该都是以下这个界面，在【编译时加入以下命令】栏是空白的且没有打钩。

3.奇迹就在此刻改变.在这个【编译时加入以下命令】处打钩,然后在空白栏输入【-std=c++11】（c是小写的），确定.然后就能支持c++1

#include <bits/stdc++.h>
using namespace std;
int main()
{ios::sync_with_stdio(false);string s1;s1=to_string(100);cout<<s1<<endl;int a=stoi(s1,0,10)+1;cout<<a<<endl;
}

以上程序在Dev C++编译环境中设置好【-std=c++11】后才可以运行。

（5.9）String字符串与字符(char类型)数组互相转换 ：

1、字符数组转化成string类型

#include<bits/stdc++.h>
using namespace std;
int main()
{char ch[] = "ABCDEFG";string str(ch);//也可string str = ch;cout<<str;
}

或者

#include<bits/stdc++.h>
using namespace std;
int main()
{char ch[]="ABCDEFG";string str;str=ch;//在原有基础上添加可以用str+=ch;cout<<str;
}

２、将string类型转换为字符数组
char buf[10];
string str("ABCDEFG");
length = str.copy(buf, 9);
buf[length] = '\0';
或者
char buf[10];
string str("ABCDEFG");
strcpy(buf, str.c_str());//strncpy(buf, str.c_str(), 10);

标准库的string类提供了3个成员函数来从一个string得到c类型的字符数组：c_str()、data()、copy(p,n)。

1. c_str()：生成一个const char*指针，指向以空字符终止的数组。

注：

①这个数组的数据是临时的，当有一个改变这些数据的成员函数被调用后，其中的数据就会失效。因此要么现用先转换，要么把它的数据复制到用户自己可以管理的内存中。注意。看下例：

const char* c;

string s="1234";

c = s.c_str();

cout<<c<<endl; //输出：1234

s="abcd";

cout<<c<<endl; //输出：abcd

上面如果继续用c指针的话，导致的错误将是不可想象的。就如：1234变为abcd

其实上面的c = s.c_str(); 不是一个好习惯。既然c指针指向的内容容易失效，我们就应该按照上面的方法，那怎么把数据复制出来呢？这就要用到strcpy等函数（推荐）。

//const char* c; //①

//char* c;       //②

//char c[20];

char* c=new char[20];

string s="1234";

//c = s.c_str();

strcpy(c,s.c_str());

cout<<c<<endl; //输出：1234

s="abcd";

cout<<c<<endl; //输出：1234

注意：不能再像上面一样①所示了，const还怎么向里面写入值啊；也不能②所示，使用了未初始化的局部变量“c”，运行会出错的 。

② c_str()返回一个客户程序可读不可改的指向字符数组的指针，不需要手动释放或删除这个指针。

2. data():与c_str()类似，但是返回的数组不以空字符终止。

3. copy(p,n,size_type _Off = 0)：从string类型对象中至多复制n个字符到字符指针p指向的空间中。默认从首字符开始，但是也可以指定，开始的位置（记住从0开始）。返回真正从对象中复制的字符。------用户要确保p指向的空间足够保存n个字符。

#include <bits/stdc++.h>using namespace std;int main( ){   string str1 ( "1234567890" );basic_string <char>::iterator str_Iter;char array1 [ 20 ] = { 0 };char array2 [ 10 ] = { 0 };basic_string <char>:: pointer array1Ptr = array1;basic_string <char>:: value_type *array2Ptr = array2;cout << "The original string str1 is: ";for ( str_Iter = str1.begin( ); str_Iter != str1.end( ); str_Iter++ )cout << *str_Iter;cout << endl;basic_string <char>:: size_type nArray1;// Note: string::copy is potentially unsafe, consider// using string::_Copy_s instead.nArray1 = str1.copy ( array1Ptr , 12 );  // C4996cout << "The number of copied characters in array1 is: "<< nArray1 << endl;cout << "The copied characters array1 is: " << array1Ptr << endl;basic_string <char>:: size_type nArray2;// Note: string::copy is potentially unsafe, consider// using string::_Copy_s instead.nArray2 = str1.copy ( array2Ptr , 5 , 6  );  // C4996cout << "The number of copied characters in array2 is: "<< nArray2 << endl;cout << "The copied characters array2 is: " << array2Ptr << endl;

六、访问单个字符。可以通过[　]下标，函数at（）及迭代器三种方法来访问单个字符。

#include <bits/stdc++.h>
using namespace std;
int main()
{   string s1 = "abcdefg";//1、数组方式cout << "数组方式:" << endl;for (int i = 0; i < s1.length(); i++)cout <<s1[i] <<endl;//2、函数方式cout << "数组方式:" << endl;for (int i = 0; i < s1.length(); i++)cout <<s1.at(i) <<endl;    //３、迭代方式cout << "迭代方式:" << endl;for (string::iterator it = s1.begin(); it != s1.end(); it++)cout<<*it<< endl;
}

注意：运算符[  ]和at()均返回当前字符串中第n个字符的位置，但at函数提供范围检查，当越界时会抛出out_of_range异常，下标运算符[  ]不提供检查访问。

七、字符串的输入输出。>>、 << 、getline()

1、string类重载运算符operator>>用于输入，同样重载运算符operator<<用于输出操作。

2、getline()的原型： getline ( istream &is , string &str , char delim );

其中:

istream &is 表示一个输入流，譬如cin；

string&str表示把从输入流读入的字符串存放在这个字符串中（可以自己随便命名，str什么的都可以）；

char delim表示遇到这个字符停止读入，在不设置的情况下系统默认该字符为'\n'，也就是回车换行符（遇到回车停止读入）。

例如：

string line;
cout<<"please cin a line:";
getline（cin,line,'#');
cout<<"The line you give is:"<<line<<endl;

输入"You are the #best!" 的时候，输入流实际上只读入了"You are the "，#后面的并没有存放到line中。

程序运行结果应该是这样的：

please cin a line:You are the #best!
The line you give is:You are the

while(getline(cin,line))语句

注意这里默认回车符停止读入,按Ctrl+Z或键入回车即可退出循环。

在这个语句中，首先getline从标准输入设备上读入字符，然后返回给输入流cin，注意了，是cin，所以while判断语句的真实判断对象是cin，也就是判断当前是否存在有效的输入流。在这种情况下，我想只要你的电脑不中毒不发神经你的输入流怎么会没有效？所以这种情况下不管你怎么输入都跳不出循环，因为你的输入流有效，跳不出循环。

然而有些同学误以为while判断语句的判断对象是line（也就是line是否为空），然后想通过直接回车（即输入一个空的line）跳出循环，却发现怎么也跳不出循环。这是因为你的回车只会终止getline()函数的读入操作。getline()函数终止后又进行while（）判断（即判断输入流是否有效，你的输入流当然有效，满足条件），所以又运行getline()函数。

所以，以下的写法根本不可能让你推出while（）循环的：

while(getline(cin,line))    cout<<line<<endl;

二、cin.getline()

此函数会一次读取多个字符(包括空白字符）。它以指定的地址为存放第一个读取的字符的位置，依次向后存放读取的字符，直到读满N-1个，或者遇到指定的结束符为止。若不指定结束符，则默认结束符为'\n'。其语法为:

cin.getline(字符指针(char*),字符个数N(int),结束符(char));

#include <bits/stdc++.h>
using namespace std;
int main()
{char a[30];cout << "请输入一个字符串：" << endl;cin.getline(a, 10);//第10位存放字符串结束符'\0'for (int i = 0; i<10; i++)cout << "第"<<i+1<<"个值为："<<a[i] << endl;return 0;
}

输入:1234567890123

输出:

请输入一个字符串：
第1个值为：1
第2个值为：2
第3个值为：3
第4个值为：4
第5个值为：5
第6个值为：6
第7个值为：7
第8个值为：8
第9个值为：9
第10个值为：

八、string的搜索操作: 

8.1、 find()  和  rfind() 函数:  find函数主要是查找一个字符串是否在调用的字符串中出现过，大小写敏感。

str.find(str2)，当str2是str的子串时，返回其在str中第一次出现的位置，否则返回string::npos。

str.find(str2,pos)，是从str的pos号位开始查找匹配str2，找到返回其位置；否则返回string::npos。

string::npos是一个常数，其本身的值等于-1，但由于是unsigned int类型，因此，也可以认为是unsigned int类型的最大值（4294967295）。

rfind()与find()很相似，差别在于查找顺序不一样，find()是从指定位置起向后查找，直到串尾。rfind()是从指定位置起向前查找，直到串首，相当于逆向查找，返回的位置仍然是从前往后数的。

返回值类型 函数 描述
int str.find(char c, int pos = 0); 从pos开始查找字符c在C++字符串str中的位置
int str.find(const char *s, int pos = 0);  从pos开始查找c语言字符串s在C++字符串str中的位置
int str.find(const char *s, int pos, int n); 从pos开始查找c语言字符串s中前n个字符在C++字符串str中的位置
int str.find(const string &s, int pos = 0);  从pos开始查找c++字符串s在C++字符串str中的位置。
int str.rfind(char c, int pos = npos); 从pos开始从后向前查找字符c在C++字符串str中的位置
int str.rfind(const char *s, int pos = npos);   从pos开始从后向前查找c语言字符串s在C++字符串str中的位置
int str.rfind(const char *s, int pos, int n = npos); 从pos开始从后向前查找c语言字符串s中前n个字符在C++字符串str中的位置
int str.rfind(const string &s,int pos = npos); 从pos开始从后向前查找c++字符串s在C++字符串str中的位置。

例一、

#include <bits/stdc++.h>
using namespace std;
int main()
{ios::sync_with_stdio(false);string str ("There are two needles in this haystack with needles.");string str2 ("needle");//在str当中查找第一个出现的needle，找到则返回出现的位置，否则返回结尾int found = str.find(str2);if (found!=string::npos)cout << "first 'needle' found at: " << found << '\n';//在str当中，从第found+1的位置开始查找参数字符串的前6个字符found=str.find("needles are small",found+1,6);if (found!=string::npos)cout << "second 'needle' found at: " << found << '\n';//在str当中查找参数中的字符串found=str.find("haystack");if (found!=string::npos)cout << "'haystack' also found at: " << found << '\n';//查找一个字符found=str.find('.');if (found!=string::npos)cout << "Period found at: " << found << '\n';//组合使用，把str2用参数表中的字符串代替// let's replace the first needle:str.replace(str.find(str2),str2.length(),"preposition");cout << str << '\n';return 0;
}

程序结果：

first 'needle' found at: 14
second 'needle' found at: 44
'haystack' also found at: 30
Period found at: 51
There are two prepositions in this haystack with needles.

例二、

#include <bits/stdc++.h>
using namespace std;
int main()
{//测试find (charT c, size_type pos = 0) const noexcept;string st1("babbabab");cout <<st1.find('a')<<endl;//1 由原型知，若省略第2个参数，则默认从位置0（即第1个字符）起开始查找cout<<st1.find('a',0)<<endl;//1cout<<st1.find('a',1)<<endl;//1   cout<<st1.find('a',2)<<endl;//4  在st1中，从位置2（包括位置2）开始查找字符a，返回首次匹配的位置，匹配失败，返回nposcout<<st1.rfind('a',7)<<endl;//6  cout<<st1.find('c',0)<<endl;//4294967295cout<<(st1.find('c',0) == -1)<<endl;//1cout<<(st1.find('c',0)==4294967295)<<endl;//1 两句均输出1，原因是计算机中-1和4294967295都表示为32个1（二进制）cout<<st1.find('a',100)<<endl;//4294967295  当查找的起始位置超出字符串长度时，按查找失败处理，返回npos//测试find (const basic_string& str, size_type pos = 0);string st2("aabcbcabcbabcc");string str1("abc");cout<<st2.find(str1,2)<<endl;//6  从st2的位置2开始匹配，返回第一次成功匹配时匹配的串（abc）的首字符在st2中的位置，失败返回npos//测试size_type find (const charT* s, size_type pos = 0) ;cout << st2.find("abc",2)<<endl; //6   同上，只不过参数不是string而是char*//测试size_type find (const charT* s, size_type pos, size_type n) ;cout<<st2.find("abcdefg",2,3)<<endl;//6   取abcdefg得前3个字符（abc）参与匹配，相当于st2.find("abc",2)cout<<st2.find("abcbc",0,5)<<endl;//1  相当于st2.find("abcbc", 0)cout<<st2.find("abcbc",0,6)<<endl;//4294967295  第3个参数超出第1个参数的长度时，返回npos
}

例三、

#include <bits/stdc++.h>
using namespace std;
int main()
{ios::sync_with_stdio(false);string str ("The sixth sick sheik's sixth sheep's sick.");string key ("sixth");//                    ^//rfind是找最后一个出现的匹配字符串size_t found = str.rfind(key);if (found!=string::npos){cout<<found<<endl;//输出23str.replace (found,key.length(),"seventh");//找到的sixth替换成seventh}cout << str << '\n';return 0;
}

程序结果：

23
The sixth sick sheik's seventh sheep's sick.

8.2、find_first_of（）和 find_first_not_of（）和 函数: 
        在源串中从位置pos起往后查找，只要在源串中遇到一个字符，该字符与目标串中任意一个字符相同，就停止查找，返回该字符在源串中的位置；若匹配失败，返回npos。

注意find_first_of函数和find函数的区别，如果是str.find(“abc”)的话，则必须找到完全匹配abc的才算查找成功，而find_first_of只需要abc中任何一个出现即可。

返回值类型 函数 描述
int str.find_first_of(char c, int pos = 0); 从pos开始查找字符c在C++字符串str中的位置
int str.find_first_of(const char *s, int pos = 0);  从pos开始查找c语言字符串s中任何一个字符首次在C++字符串str中的位置
int str.find_first_of(const char *s, int pos, int n); 从pos开始查找c语言字符串s中前n个字符中任何一个字符首次在C++字符串str中的位置
int str.find_first_of(const string &s,int pos = 0);  从pos开始查找c++字符串s中任何一个字符首次在C++字符串str中的位置。
int str.find_first_not_of(char c, int pos = 0); 从pos开始查找字符c以外的任何一个字符在C++字符串str中的位置
int str.find_first_not_of(const char *s, int pos = 0);   从pos开始c语言字符串s以外的任何一个字符在C++字符串str中的位置
int str.find_first_not_of(const char *s, int pos,int n); 从pos开始查找c语言字符串s中前n个字符以外的任何一个字符在C++字符串str中的位置
int str.find_first_not_of(const string &s,int pos = 0); 从pos开始查找c++字符串s以外的任何一个字符在C++字符串str中的位置。

8.3、find_last_of（）和 find_last_not_of（）和 函数: 

在源串中从位置pos起往前查找，只要在源串中遇到一个字符，该字符与目标串中任意一个字符相同，就停止查找，返回该字符在源串中的位置；若匹配失败，返回npos。find_last_of和find_last_not_of与find_first_of和find_first_not_of相似，只不过是从后向前查找

返回值类型 函数 描述
int str.find_last_of(char c, pos = npos); 从pos开始由后向前查找字符c在C++字符串str中的位置
int str.find_last_of(const char *s, int pos = npos);  从pos开始由后向前查找c语言字符串s中任何一个字符首次在C++字符串str中的位置
int str.find_last_of(const char *s, int pos, int n=npos); 从pos开始由后向前查找c语言字符串s中前n个字符中任何一个字符首次在C++字符串str中的位置
int str.find_last_of(const string &s,int pos = npos);  从pos开始由后向前查找c++字符串s中任何一个字符首次在C++字符串str中的位置。
int str.find_last_not_of(char c, int pos = npos); 从pos开始由后向前从后向前查找字符c以外的任何一个字符在C++字符串str中的位置
int str.find_last_not_of(const char *s, int pos = npos);   从pos开始由后向前从后向前查找c语言字符串s以外的任何一个字符在C++字符串str中的位置
int str.find_last_not_of(const char *s, int pos,int n); 从pos开始由后向前从后向前查找c语言字符串s中前n个字符以外的任何一个字符在C++字符串str中的位置
int str.find_last_not_of(const string &s,int pos = npos); 从pos开始由后向前从后向前查找c++字符串s以外的任何一个字符在C++字符串str中的位置。

九、string的子串substr():

这个函数的作用是取字符串str中位置为pos开始的len个字符，返回一个字符串。

如果pos开始后len个字符长度超出了字符串的长度，则取到最后一个字符。

返回值类型 函数 描述
string str.substr(int pos = 0,int n = npos) ; 返回pos开始的n个字符组成的字符串给str字符串

假设：string s = “0123456789”;

string sub1 = s.substr(5); //只有一个参数5,  则表示从下标为5开始一直到结尾：sub1 = “56789”string sub2 = s.substr(5, 3); //有二个参数（5，3），表示从下标为5开始截取长度为3位：sub2 = “567”

10、读程序，写结果：

#include <bits/stdc++.h>
using namespace std;
int main()
{  string str1; cin >> str1;//当用cin>>进行字符串的输入的时候，遇到空格的地方就停止字符串的读取输入cout << str1 << endl;   cin.get();//这个的作用就是读取cin>>输入的结束符，不用会对getline的输入产生影响！getline(cin, str1);//字符串的行输入cout << str1 << endl;   string str2 = "aaaaa";//最简单的字符串初始化cout << str2 << endl;   char *s = "bbbbb";   string str3(s);//用c字符串s初始化cout << str3 << endl;   char ch = 'c';   string str4(5, ch);//用n个字符ch初始化cout << str4 << endl;   string str5 = "abcde";   ch = str5[3];//返回当前字符串中第n个字符的位置cout << ch << endl;   string str6 = "abcde";   ch = str6.at(4);    //at()返回当前字符串中第n个字符的位置,并且提供范围检查，当越界时会抛出异常！cout << ch << endl;    string str7 = "abcdefgh";   int size;    size = str7.capacity();    //返回当前容量 cout << size << endl;   size = str7.max_size();   //返回string对象中可存放的最大字符串的长度 cout << size << endl;   size = str7.size();        //返回当前字符串的大小 cout << size << endl;   size = str7.length();      //返回当前字符串的长度 cout << size << endl;   bool flag;   flag = str7.empty();      //判断当前字符串是否为空 cout << flag << endl;   int len = 10;   str7.resize(len, ch);   //把字符串当前大小置为len，并用字符ch填充不足的部分 cout << str7 << endl;   string str8;   str8 = str7;              //把字符串str7赋给当前字符串 cout << str8 << endl;   str8.assign(str7);      //把字符串str7赋给当前字符串 cout << str8 << endl;    str8.assign(s);         //用c类型字符串s赋值 ?cout << str8 << endl;    str8.assign(s, 2);         //用c类型字符串s开始的n个字符赋值 cout << str8 << endl;   str8.assign(len, ch);   //用len个字符ch赋值给当前字符串 cout << str8 << endl;   str8.assign(str7, 0, 3);   //把字符串str7中从0开始的3个字符赋给当前字符串 cout << str8 << endl;    string str9 = "0123456789";   str8.assign(str9.begin(), str9.end());//把迭代器之间的字符赋给字符串 cout << str8 << endl;    string str10;   str10 += str9;          //把字符串str9连接到当前字符串的结尾 cout << str10 << endl;    str10.append(s);         //把c类型字符串s连接到当前字符串的结尾 cout << str10 << endl;   str10.append(s, 2);      //把c类型字符串s的前2个字符连接到当前字符串的结尾 cout << str10 << endl;    str10.append(str9.begin(), str9.end());      //把迭代器之间的一段字符连接到当前字符串的结尾 cout << str10 << endl;    str10.push_back('k');   //把一个字符连接到当前字符串的结尾 cout << str10 << endl;   //7.string的比较 ?flag = (str9 == str10);   //判断两个字符串是否相等 cout << flag << endl;    flag = (str9 != str10);   //判断两个字符串是否不相等 cout << flag << endl;    flag = (str9 > str10);   //判断两个字符串是否大于关系 cout << flag << endl;   flag = (str9 < str10);   //判断两个字符串是否为小于关系 cout << flag << endl;    flag = (str9 >= str10);   //判断两个字符串是否为大于等于关系 cout << flag << endl;    flag = (str9 <= str10);   //判断两个字符串否为小于等于关系 cout << flag << endl;    //以下的3个函数同样适用于c类型的字符串，//在compare函数中>时返回1，<时返回-1，=时返回0 flag = str10.compare(str9);   //比较两个字符串的大小，通过ASCII的相减得出！ cout << flag << endl;   flag = str10.compare(6, 12, str9);   //比较str10字符串从6开始的12个字符组成的字符串与str9的大小 cout << flag << endl;   flag = str10.compare(6, 12, str9, 3, 5);   //比较str10字符串从6开始的12个字符组成的字符串与str9字符串从3开始的5个字符组成的字符串的大小 cout << flag << endl;   string str11;   str11 = str10.substr(10, 15);   //返回从下标10开始的15个字符组成的字符串 cout << str11 << endl;   //9.string的交换 ?str11.swap(str10);   //交换str11与str10的值 cout << str11 << endl;   //10.string的查找，查找成功时返回所在位置，失败时返回string::npos的值，即是-1 string str12 = "abcdefghijklmnopqrstuvwxyz";   int pos;   pos = str12.find('i', 0);     //从位置0开始查找字符i在当前字符串的位置 cout << pos << endl;   pos = str12.find("ghijk", 0);   //从位置0开始查找字符串“ghijk”在当前字符串的位置 cout << pos << endl;   pos = str12.find("opqrstuvw", 0, 4);   //从位置0开始查找字符串“opqrstuvw”前4个字符组成的字符串在当前字符串中的位置 cout << pos << endl;   pos = str12.rfind('s', string::npos);   //从字符串str12反向开始查找字符s在字符串中的位置 cout << pos << endl;   pos = str12.rfind("klmn", string::npos);   //从字符串str12反向开始查找字符串“klmn”在字符串中的位置 cout << pos << endl;   pos = str12.rfind("opqrstuvw", string::npos, 3);   //从string::pos开始从后向前查找字符串s中前n个字符组成的字符串在当前串中的位置 cout << pos << endl;   string str13 = "aaaabbbbccccdddeeefffggghhhiiijjjkkllmmmandjfaklsdfpopdtwptioczx";   pos = str13.find_first_of('d', 0);   //从位置0开始查找字符d在当前字符串第一次出现的位置cout << pos << endl;    pos = str13.find_first_of("eefff", 0);   //从位置0开始查找字符串“eeefff“在当前字符串中第一次出现的位置 cout << pos << endl;   pos = str13.find_first_of("efff", 0, 3);   //从位置0开始查找当前串中第一个在字符串”efff“的前3个字符组成的数组里的字符的位置 cout << pos << endl;    pos = str13.find_first_not_of('b', 0);   //从当前串中查找第一个不在串s中的字符出现的位置 cout << pos << endl;    pos = str13.find_first_not_of("abcdefghij", 0);   //从当前串中查找第一个不在串s中的字符出现的位置 cout << pos << endl;    pos = str13.find_first_not_of("abcdefghij", 0, 3);   //从当前串中查找第一个不在由字符串”abcdefghij”的前3个字符所组成的字符串中的字符出现的位置 cout << pos << endl;    //下面的last的格式和first的一致，只是它从后面检索！   pos = str13.find_last_of('b', string::npos);    cout << pos << endl;   pos = str13.find_last_of("abcdef", string::npos);    cout << pos << endl;    pos = str13.find_last_of("abcdef", string::npos, 2);   cout << pos << endl;   pos = str13.find_last_not_of('a', string::npos);   cout << pos << endl;    pos = str13.find_last_not_of("abcdef", string::npos);   cout << pos << endl;   pos = str13.find_last_not_of("abcdef", string::npos, 3);   cout << pos << endl;   //11.string的替换 string str14 = "abcdefghijklmn";    str14.replace(0, 3, "qqqq");   //删除从0开始的3个字符，然后在0处插入字符串“qqqq” cout << str14 << endl;   str14.replace(0, 3, "vvvv", 2);    //删除从0开始的3个字符，然后在0处插入字符串“vvvv”的前2个字符 cout << str14 << endl;   str14.replace(0, 3, "opqrstuvw", 2, 4);   //删除从0开始的3个字符，然后在0处插入字符串“opqrstuvw”从位置2开始的4个字符 cout << str14 << endl;   str14.replace(0, 3, 8, 'c');   //删除从0开始的3个字符，然后在0处插入8个字符 c cout << str14 << endl;   //上面的位置可以换为迭代器的位置，操作是一样的，在这里就不再重复了！ //12.string的插入，下面的位置处亦可以用迭代器的指针表示，操作是一样的 string str15 = "abcdefg";   str15.insert(0, "mnop");//在字符串的0位置开始处，插入字符串“mnop” cout << str15 << endl;   str15.insert(0, 2, 'm');    //在字符串的0位置开始处，插入2个字符m cout << str15 << endl;   str15.insert(0, "uvwxy", 3);   //在字符串的0位置开始处，插入字符串“uvwxy”中的前3个字符 cout << str15 << endl;    str15.insert(0, "uvwxy", 1, 2);    //在字符串的0位置开始处，插入从字符串“uvwxy”的1位置开始的2个字符cout << str15 << endl;   //13.string的删除 string str16 = "gfedcba"; string::iterator it;   it = str16.begin();   it++;   str16.erase(it);   //删除it指向的字符，返回删除后迭代器的位置 cout << str16 << endl;   str16.erase(it, it+3);   //删除it和it+3之间的所有字符，返回删除后迭代器的位置 cout << str16 << endl;   str16.erase(2);   //删除从字符串位置3以后的所有字符，返回位置3前面的字符 cout << str16 << endl;   //14.字符串的流处理 string str17("hello,this is a test");istringstream is(str17);string s1,s2,s3,s4;is>>s1>>s2>>s3>>s4;//s1="hello,this",s2="is",s3="a",s4="test" ostringstream os;os<<s1<<s2<<s3<<s4;cout<<os.str() << endl;}

STL详解（十） 字符串string相关推荐

  1. java object数组转实体类_详解Java中String JSONObject JSONArray List实体类转换

    JSON使用阿里的fastJson为依赖包 gradle依赖管理如下: compile group: "com.alibaba", name: "fastjson&quo ...

  2. python比较两个字符串相似度_详解Python 字符串相似性的几种度量方法

    字符串的相似性比较应用场合很多,像拼写纠错.文本去重.上下文相似性等. 评价字符串相似度最常见的办法就是:把一个字符串通过插入.删除或替换这样的编辑操作,变成另外一个字符串,所需要的最少编辑次数,这种 ...

  3. Linux内核Thermal框架详解十二、Thermal Governor（2）

    本文部分内容参考 万字长文 | Thermal框架源码剖析, Linux Thermal机制源码分析之框架概述_不捡风筝的玖伍贰柒的博客-CSDN博客, "热散由心静,凉生为室空" ...

  4. 元宇宙技术普及读本重磅问世 详解十大技术 把脉数字经济 前瞻产业布局

    转自 元宇宙共识圈 王恩东.倪光南.沈昌祥.郑纬民--四位中国工程院院士联袂力荐 倪健中.姚前.李正茂.朱嘉明.肖风.敖然等权威专家一致推荐 汇聚元宇宙技术专家及产业一线佼佼者倾力撰写 元宇宙技术普及 ...

  5. 【STL详解】string类

    目录 1.标准库中的string类 string类的常用接口说明: 1. string类对象的常见构造 2.2string类对象的容量操作 3. string类对象的访问及遍历操作 4. string ...

  6. Java源码详解四：String源码分析--openjdk java 11源码

    文章目录 注释 类的继承 数据的存储 构造函数 charAt函数 equals函数 hashCode函数 indexOf函数 intern函数 本系列是Java详解,专栏地址:Java源码分析 Str ...

  7. shell脚本详解(十)——sed编辑器的使用方法

    shell脚本详解(十)--sed编辑器的使用方法 一.sed编辑器 二.sed编辑器工作流程 1.读取: 2.执行: 3.显示: 4.注: 三.命令格式 四.常用选项 五.常用操作 六.使用地址 s ...

  8. JVM(1)之JVM的组成详解（字符串常量池+双亲委派机制+JIT即时编译......）

    以下总结自:<深入理解java虚拟机> + 宋红康老师视频 字节码文件介绍:深入理解JVM之Java字节码(.class)文件详解_Windy_729的博客-CSDN博客_字节码文件 JV ...

  9. 攻防世界杂项(misc)--新手练习区(详解十二道题完结，附件做题过程中使用到的各种工具和网站)

    攻防世界杂项(misc)–新手练习区(详解) 第一题:this_is_flag 题目描述:Most flags are in the form flag{xxx}, for example:flag{ ...

最新文章

  1. string Format转义大括号
  2. 旋转矩阵中6保6_40岁阿姨发明新型手推车，可以360度旋转，干活效率提升6倍
  3. CentOS下ZooKeeper单机模式、集群模式安装
  4. libxml -- 解析 XML 文档
  5. 最新后端架构师技术图谱
  6. /var/spool/clientmqueue目录下存在大量文件的原因及解决方法
  7. ssh:could not resolve hostname XXX:Temporary failure in name resolution
  8. 服务器pe系统ghost系统安装教程,科技教程：U盘PE启动安装GHOST系统图文教程
  9. 《麦肯锡卓越工作方法》
  10. 小飞鱼通达二开 致远OA启动时报错“无法初始化数据库连接池，系统无法启动”的问题处理（图文）
  11. html表头解释_1分钟内解释的html
  12. 微服务 ZooKeeper ，Dubbo ，Kafka 介绍应用
  13. 面向计算机架构的机器学习
  14. Salesforce诊断网络问题以排除性能下降
  15. 掉进悬崖的小白，捡到python基础秘籍，学习第一周——语法基础，小游戏，无脑循环
  16. 双屏显示时鼠标如何从左（右）侧移入另一屏
  17. [echart] 渐变内置生成器echarts.graphic.LinearGradient
  18. 金属轻工机械电力设备用原浆型环氧云铁中间漆 漆膜坚韧
  19. 惠普dl380g7安装linux,hp380服务器安装linux
  20. 计算机管理员服务承诺,机房管理员工作承诺书范文

热门文章

  1. java一加到十_刘作虎“口出狂言”：一加7流畅度超过iphone，你相信吗？
  2. linux centos 如何查看操作系统版本信息
  3. Django3（二）异步编程
  4. 实训记录（二）——分镜的制作！
  5. python自动化办公实战案例,python 自动化办公 案例
  6. 大二学生HTML期末大作业——HTML+CSS+JavaScript食品网上超市购物商城网页与制作
  7. #if 0 和 #endif 的用处
  8. 成语接龙（字符串，思路，按长度排序）
  9. 【温故而知新-Javascript】理解 DOM
  10. Java Eclipse 生成UML类图插件(AmaterasUML插件)安装使用教程