标准C++中的string类的用法总结【转】

转自(略改动)：http://www.cnblogs.com/xFreedom/archive/2011/05/16/2048037.html

更全面新颖的说明见：http://www.cplusplus.com/reference/string/string/　　

 说明：　1、size_t
是个unsigned integral type.

　　　　 2、文中 c字符数组
是指末尾不带‘\0‘的，注意与 c字符串 的区别

相信使用过MFC编程的朋友对CString这个类的印象应该非常深刻吧？的确，MFC中的CString类使用起来真的非常的方便好用。但是如果离开了MFC框架，还有没有这样使用起来非常方便的类呢？答案是肯定的。也许有人会说，即使不用MFC框架，也可以想办法使用MFC中的API，具体的操作方法在本文最后给出操作方法。其实，可能很多人很可能会忽略掉标准C++中string类的使用。标准C++中提供的string类得功能也是非常强大的，一般都能满足我们开发项目时使用。现将具体用法的一部分罗列如下，只起一个抛砖引玉的作用吧，好了，直接进入正题吧！

要想使用标准C++中string类，必须要包含

#include <string>    // 注意是<string>，不是<string.h>，带.h的是C语言中的头文件；也不是<cstring>

然后

using  std::string;

using  std::wstring;

或

using namespace std;

下面你就可以使用string/wstring了，它们两分别对应着char和wchar_t。

string和wstring的用法是一样的，以下只用string作介绍：

string类的构造函数：

string(const char *s);    //用c字符串s初始化
string(int n,char
c);     //用n个字符c初始化
此外，string类还支持默认构造函数和复制构造函数，如string
s1；string s2(s1)；都是正确的写法。当构造的string太长而无法表达时会抛出length_error异常 ；

//更多：http://www.cplusplus.com/reference/string/string/string/
：(C++98标准)























default (1) 
string();
copy (2) 
string (const string& str);
substring (3) 
string (const string& str, size_t pos, size_t len = npos);

from c-string (4) 
string (const char* s);
from buffer (5) 
string (const char* s, size_t n);
fill (6) 
string (size_t n, char c);
range (7)   //[first,last) 
template <class InputIterator>

  string  (InputIterator first, InputIterator last);

//来自http://www.cplusplus.com/reference/string/string/string/

// string constructor

#include <iostream>

#include <string>


int main ()

{

  std::string s0 ("Initial string");


// constructors used in the same order as described above:

  std::string s1;

  std::string s2 (s0);

  std::string s3 (s0, 8, 3);

  std::string s4 ("A character sequence", 6);

  std::string s5 ("Another character sequence");

  std::string s6 (10, ‘x‘);

  std::string s7a (10, 42);      // 42 is the ASCII code for ‘*‘

  std::string s7b (s0.begin(), s0.begin()+7);


std::cout << "s1: " << s1 << "\ns2: " << s2 << "\ns3: " << s3;

  std::cout << "\ns4: " << s4 << "\ns5: " << s5 << "\ns6: " << s6;

  std::cout << "\ns7a: " << s7a << "\ns7b: " << s7b << ‘\n‘;

  return 0;

}


//输出：

/*

s1:

s2: Initial string

s3: str

s4: A char

s5: Another character sequence

s6: xxxxxxxxxx

s7a: **********

s7b: Initial

*/

实例

string类的字符操作：

//根据字符串是否具有const属性返回是否具有const属性的返回值。下同！
const
char &operator[] (size_t n) const;
char &operator[] (size_t
n);
const char &at (size_t n) const;
char &at (size_t
n);
operator[]和at()均返回当前字符串中第n个字符的引用，但at函数提供范围检查，当越界时会抛出out_of_range异常，下标运算符[]不提供检查访问。

//[C++11]
这两个函数不应该被空字符串调用
char
&front();    //直接返回字符串中第一个字符的引用
const char &front()
const;

char &back();   //直接返回字符串中最后一个字符的引用
const char
&back() const;

//很好的转为char*类型的操作。需要注意前两个返回为const类型，使用时不应该修改其内容:

const char *data() const;　　 //返回一个非null终止的 const c字符数组；大小为size()的返回值
const
char *c_str() const;　　//返回一个以null终止的
const c字符串；大小为size()的返回值+1
，最后一个是 ‘\0‘ 字符。
size_t copy (char *s, size_t n, size_t pos = 0) const;
//把当前串中以pos开始的n个字符拷贝到以s为起始位置的c字符数组中，返回实际拷贝的数目。不在目标末尾添\0 !!

string的特性描述:
size_t
capacity() const;         //返回当前为字符串已分配的存储空间（通常比length()大，即string中不必增加内存即可存放的元素个数），以字符数表示
void
reserve (size_t n = 0);  //改变字符串的capacity大小。当n比当前capacity()大时，会增加capacity大小到n或更大。

size_t max_size() const;       //返回string对象中潜在的可存放的最大字符串的长度，它由系统等限制决定的。不能保证实际字符串真能够达到这个最大长度
size_t
size() const;        
      //返回当前字符串的大小，以字符数表示
size_t length() const;  
       
//返回当前字符串的长度，以字符数表示。与size()等同
bool empty() const;      
      //当前字符串是否为空

void resize (size_t len);       //把字符串当前大小置为len。小于原长度，截取；大于原长度，以\0填充不足的地方
(注意:length()不因这些\0而改变)
void resize (size_t len, char c);
  //把字符串当前大小置为len。小于原长度，截取；大于原长度，并用字符c填充不足的部分

void shrink_to_fit(); //[C++11]  要求缩减串的capacity大小到适合它的size()
;该函数不具有强约束力，就是说，执行完后，其capacity仍可大于字符串的size。

string类的输入输出操作(不是成员函数):
string类重载运算符operator>>用于输入，同样重载运算符operator<<用于输出操作。
istream
&getline (istream &in, string &str); //用于从输入流in中读取字符串到str中，默认以换行符‘\n‘分开。提取并丢弃分隔符‘\n‘  
 【<缓冲区>】
istream &getline (istream &in,
string &str, char delim); //从输入流中读取字符串到str中,以字符delim做分隔符。提取并丢弃分隔符delim

string的赋值：

string &operator= (const char *s);　　 //把c类型字符串s赋给当前字符串
string
&operator= (const char c);　　  //把字符c赋给当前字符串
string &operator=
(const string &str); //把字符串str赋给当前字符串

//类似string类的几个构造函数，但构造函数是给字符串赋初值，而assign函数是替换掉字符串的内容！
string
&assign (const char *s);              
      
//用c类型字符串s赋值
string &assign (const char *s, size_t n);  
        //用c字符串s开始的n个字符赋值
string &assign
(const string &str);            //把字符串str赋给当前字符串
string
&assign (size_t n, char c);          //用n个字符c赋值给当前字符串
string
&assign (const string &str, size_t start, size_t n);    
     //把字符串str中从start开始的n个字符赋给当前字符串
string
&assign (const_iterator first, const_itertor last);      
 
//把first和last迭代器之间的部分赋给字符串。[first,
last)， 不包括last指向的字符

string的连接：
string
&operator+= (const string &str);          //把字符串str连接到当前字符串的结尾 
string
&append (const string &str);      
         //同operator+=()
string &append
(const string &str, size_t pos, size_t n);   //把字符串str中从pos开始的n个字符连接到当前字符串的结尾
string
&append (const char *s);              
  
//把c类型字符串s连接到当前字符串结尾
string &append (const char *s, size_t n);
   //把c类型字符串s的前n个字符连接到当前字符串结尾
string
&append (size_t n, char c);            
  //在当前字符串结尾添加n个字符c
string &append
(const_iterator first, const_iterator last);  //把迭代器first和last之间的部分连接到当前字符串的结尾。[first, last)， 不包括last指向的字符

void push_back (char c);   //把字符c添加到当前字符串末尾，并使字符串长度加1

string的比较：

//下面的这些操作符重载也不是成员函数
bool
operator== (const string &str1, const string &str2) const;  
 //比较两个字符串是否相等
运算符">","<",">=","<=","!="均被重载用于字符串的比较；

//成员函数compare函数在>时返回1，<时返回-1，==时返回0 
int
compare (const string &str) const;     //比较当前字符串
和 str 的大小
int compare (size_t pos, size_t n, const string &str)
const;     //比较当前字符串从pos开始的n个字符组成的字符串 与 str
的大小
int compare (size_t pos, size_t n, const string &str, size_t
pos2, size_t n2) const;    //比较当前字符串从pos开始的n个字符组成的字符串 与
str中pos2开始的n2个字符组成的字符串的大小　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

int compare (const char *s) const;      
//当前字符串 与 c字符串 的大小比较
int compare (size_t pos, size_t n, const char *s)
const;    //当前字符串从pos开始的n个字符组成的字符串 与 c字符串
的大小比较 
int compare (size_t pos, size_t n, const char *s, size_t
n2) const; //当前字符串从pos开始的n个字符组成的字符串 与
n2大小的c字符数组 的大小比较

string的子串：
string
substr (size_t pos = 0, size_t n = npos) const; //返回pos开始的n个字符组成的字符串对象。（无符号类型）npos
= -1，这里代表字符串的末尾。

string的交换：（非成员函数）
void
swap (string &str2);    //交换当前字符串与str2的值

string类的查找函数：（无符号 npos = -1）

//查找成功时返回第一个匹配的第一个字符所在的位置；失败返回string::npos的值  (npos
= -1)
size_t find (const string &str, size_t pos = 0) const;
  //从pos开始查找字符串str在当前串中的位置
size_t find
(const char *s, size_t pos = 0) const;   //从pos开始查找
c字符串s 在当前串中的位置
size_t find (const char *s, size_t pos, size_t n)
const;  //从pos开始查找 c字符串s
中前n个字符在当前串中的位置
size_t find (char c, size_t pos = 0) const;  
 //从pos开始查找 字符c 在当前字符串的位置

//从pos开始从后向前查找
字符串s或str(中前n个字符组成的字符串)
在当前串中的位置，成功返回第一个匹配的第一个字符所在的位置；失败返回string::npos的值 
size_t rfind
(const string &str, size_t pos = npos) const;   //从pos开始从后向前查找字符串str在当前串中的位置。默认npos，即从字符串末尾开始向前查找
size_t
rfind (const char *s, size_t pos = npos) const;
size_t rfind (const char *s,
size_t pos, size_t n) const;
size_t rfind (char c, size_t pos = npos)
const;

//从pos开始查找当前串中 第一个匹配 str或s中的任意一个字符的位置。查找失败返回string::npos 
size_t
find_first_of (const string &str, size_t pos = 0) const;   //从pos开始查找字符串str第一次出现的位置
size_t
find_first_of (const char *s, size_t pos = 0) const;
size_t find_first_of
(const char *s, size_t pos, sizet_t n) const;
size_t find_first_of (char c,
size_t pos = 0) const;

//从当前串中查找 第一个不匹配
str或s中的任意一个字符出现的位置，失败返回string::npos 
size_t
find_first_not_of (const string &str, size_t pos = 0) const;
size_t
find_first_not_of (const char *s, size_t pos = 0) const;
size_t
find_first_not_of (const char *s, size_t pos, size_t n) const;
size_t
find_first_not_of (char c, size_t pos = 0) const;

//find_last_of和find_last_not_of与find_first_of和find_first_not_of相似，只不过是从后向前查找
size_t
find_last_of (const string &str, size_t pos = npos) const;
size_t
find_last_of (const char *s, size_t pos = npos) const;
size_t find_last_of
(const char *s, size_t pos, size_t n) const;
 size_t find_last_of (char
c, size_t pos = npos) const;

size_t find_last_not_of (const string &str, size_t pos = npos)
const;
size_t find_last_not_of (const char *s, size_t pos = npos)
const;
size_t find_last_not_of (const char *s, size_t pos, size_t n)
const;
size_t find_last_not_of (char c, size_t pos = npos) const;

string类的替换函数： (返回当前字符串的引用)
string
&replace (size_t pos, size_t n, const char *s);   //删除从pos开始的n个字符，然后在pos处插入c字符串s
string
&replace (size_t pos, size_t n, const char *s, size_t n2);  //删除pos开始的n个字符，然后在pos处插入c字符串s的前n2个字符
string
&replace (size_t pos, size_t n, const string &str);   //删除从pos开始的n个字符，然后在pos处插入串str
string
&replace (size_t pos, size_t n, const string &str, size_t pos2, size_t
n2);  
//删除pos开始的n个字符，然后在pos处插入串str中从pos2开始的n2个字符
string &replace (size_t
pos, size_t n, size_t n2, char c);  
//删除pos开始的n个字符，然后在pos处插入n2个字符c

string &replace (iterator first, iterator last, const char *s);  
//把[first，last)
之间的部分替换为c字符串s
string &replace (iterator first, iterator last,
const char *s, size_t n);   //把[first，last)
之间的部分替换为c字符串s的前n个字符
string &replace (iterator first, iterator
last, const string &str);   //把[first，last) 之间的部分替换为串str
string
&replace (iterator first, iterator last, size_t n, char c);   //把[first，last) 之间的部分替换为n个字符c
string
&replace (iterator first, iterator last, const_iterator first2,
const_iterator last2);   //把[first，last)之间的部分替换成[first2，last2)之间的字符串

string类的插入函数：

//要插入的字符或字符串 插入到pos位置的左边，
换句话说，取代了pos处原字符的[pos]...string
mystr("abc");mystr.insert(2,"YYY"); =》abYYYc
string &insert
(size_t pos, const char *s);   //在当前串的pos位置插入c字符串s
string &insert
(size-t pos, const char *s, size_t n);   //在当前串的pos位置插入c字符数组的前n个字符
string
&insert (size_t pos, const string &str);  
//在当前串的pos位置插入字符串str
string &insert (size_t pos, const string
&str, size_t pos2, size_t n);   //在当前串的pos位置插入
字符串str从pos2位置开始的n个字符

string &insert (size_t pos, size_t n,
char c);  //在pos位置处插入n个字符c
iterator insert
(iterator it, char c);   //在it处插入字符c，返回插入后迭代器的位置
void insert
(iterator it, size_t n, char c);   //在it处插入n个字符c
void insert (iterator it,
const_iterator first, const_iterator last);   //在it处插入[first，last）之间的字符

string类的删除函数 

string &erase (size_t pos = 0, size_t n = npos);  
//删除pos开始的n个字符，返回修改后的字符串。默认值清空字符串
iterator erase (iterator it);  
//删除it指向的字符，返回删除后迭代器的位置（应该和it指向相同的位置）
iterator
erase (iterator first, iterator last);   //删除[first，last）之间的所有字符，返回占用已删除的第一个字符的位置（应该和first指向相同的位置）

void pop_back(); //[C++11]
删除当前字符串的最后一个字符。

string类的迭代器处理： 
string类提供了向前和向后遍历的迭代器iterator，类似于指针操作，迭代器不检查范围。函数根据string对象是否const限制返回是否const属性的
iterator
用string::iterator或string::const_iterator声明迭代器变量，const_iterator不允许改变迭代的内容。常用迭代器函数有：

const_iterator begin() const;
iterator
begin();               
//返回string的起始位置

const_iterator end() const;
iterator
end();                   
//返回string的最后一个字符后面的位置。若为空字符串，返回值和begin()相同。

const_reverse_iterator rbegin() const;
reverse_iterator
rbegin();               
//返回string的最后一个字符的位置

const_reverse_iterator rend() const;
reverse_iterator
rend();                    //返回string第一个字符前面的位置

rbegin和rend用于从后向前的迭代访问，通过设置迭代器string::reverse_iterator,string::const_reverse_iterator实现(如对这种迭代器进行++操作时，方向是沿着相反方向)

字符串流处理： 
通过定义ostringstream和istringstream变量实现，#include
<sstream>头文件中
例如：
    string input("hello,this is a
test");
    istringstream is(input);
   
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();

以上就是对C++ string类的一个简要介绍。用的好的话它所具有的功能不会比MFC中的CString类逊色多少，呵呵，个人意见！

最后要介绍如何在Win32 应用程序中引用MFC中的部分类，例如CString。

1.在工程目录下右键选择"Properties”--->"Configuration
Properties”--->“General”--->"Use of MFC"--->"Use MFC in a Static
Library"，

默认的是："Use Standard Windows Libraries"，如下图：

2.在你所用的所有头文件之前包含#include <afxwin.h>，例如：可以在stdafx.h文件的最前面包含#include
<afxwin.h>头文件，这样在你的源代码中就可以使用

　CString类了，不过这样也有一个缺点，就是编译出来的程序要比原来的大很多。我试过一个小程序，选择"Use Standard Windows
Libraries" 编译出来

　的Release版本大概92kb，使用"Use MFC in a Static
Library"编译出来的Release版本大概192kb，足足大了100kb，这个就个人考虑了......

标准C++中的string类的用法总结【转】,布布扣,bubuko.com

时间： 2024-03-23 02:23:43

标准C++中的string类的用法总结【转】的相关文章

标准C++中的string类的用法总结

标准C++中的string类的用法总结 相信使用过MFC编程的朋友对CString这个类的印象应该非常深刻吧?的确,MFC中的CString类使用起来真的非常的方便好用.但是如果离开了MFC框架,还有没有这样使用起来非常方便的类呢?答案是肯定的.也许有人会说,即使不用MFC框架,也可以想办法使用MFC中的API,具体的操作方法在本文最后给出操作方法.其实,可能很多人很可能会忽略掉标准C++中string类的使用.标准C++中提供的string类得功能也是非常强大的,一般都能满足我们开发项目时使用

[转]标准C++中的string类的用法总结

原文地址:http://www.cnblogs.com/xFreedom/archive/2011/05/16/2048037.html 相信使用过MFC编程的朋友对CString这个类的印象应该非常深刻吧?的确,MFC中的CString类使用起来真的非常的方便好用.但是如果离开了MFC框架,还有没有这样使用起来非常方便的类呢?答案是肯定的.也许有人会说,即使不用MFC框架,也可以想办法使用MFC中的API,具体的操作方法在本文最后给出操作方法.其实,可能很多人很可能会忽略掉标准C++中stri

VC++ 标准C++中的string类的用法总结

相信使用过MFC编程的朋友对CString这个类的印象应该非常深刻吧?的确,MFC中的CString类使用起来真的非常的方便好用.但是如果离开了MFC框架,还有没有这样使用起来非常方便的类呢?答案是肯定的.也许有人会说,即使不用MFC框架,也可以想办法使用MFC中的API,具体的操作方法在本文最后给出操作方法.其实,可能很多人很可能会忽略掉标准C++中string类的使用.标准C++中提供的string类得功能也是非常强大的,一般都能满足我们开发项目时使用.现将具体用法的一部分罗列如下,只起一个

标准C++中的string类的用法总结（转）

http://www.cnblogs.com/xFreedom/archive/2011/05/16/2048037.html 相信使用过MFC编程的朋友对CString这个类的印象应该非常深刻吧?的确,MFC中的CString类使用起来真的非常的方便好用.但是如果离开了MFC框架,还有没有这样使用起来非常方便的类呢?答案是肯定的.也许有人会说,即使不用MFC框架,也可以想办法使用MFC中的API,具体的操作方法在本文最后给出操作方法.其实,可能很多人很可能会忽略掉标准C++中string类的使

【转载】标准c++中的string类型的用法

http://www.cnblogs.com/xFreedom/archive/2011/05/16/2048037.html 相信使用过MFC编程的朋友对CString这个类的印象应该非常深刻吧?的确,MFC中的CString类使用起来真的非常的方便好用.但是如果离开了MFC框架,还有没有这样使用起来非常方便的类呢?答案是肯定的.也许有人会说,即使不用MFC框架,也可以想办法使用MFC中的API,具体的操作方法在本文最后给出操作方法.其实,可能很多人很可能会忽略掉标准C++中string类的使

java面向对象-------String类基本用法

package cn.zxg.oop; /** * 测试string类的用法,不能被重写 */ public class TestString { String a; public static void main(String[] args) { String str="abc"; String str2=new String("def"); String str3="abc"+"def"; String str4=&quo

[经典面试题][百度]c++实现STL中的string类

题目 请用c++ 实现stl中的string类,实现构造,拷贝构造,析构,赋值,比较,字符串相加,获取长度及子串等功能. 代码 /*------------------------------------- * 日期:2015-03-31 * 作者:SJF0115 * 题目: 实现string类 * 来源:百度 * 博客: ------------------------------------*/ #include <iostream> #include <cstring> us

java 中的String类

String a = "aaa"; 用这种方式的时候java首先在内存中寻找"aaa"字符串,如果有,就把aaa的地址给它 如果没有则创建 String a = new String("aaa"); 是不管内存中有没有"aaa" 都开辟一块新内存保存它 可以用以下方法验证下 String a = "aaa"; String b = "aaa"; String c = new String

C++中的string类

C++中的string类1)是什么:专门的字符串操作的一个类,非常强大,字符串CString,QString2)跟char *的区别Char *是指向字符数组首地址的指针,然后我们系统提供一个string.h,这个头文件声明了很所字符串操作函数,strlen.strcat.strcmp.strcpy--.Stirng这个类,我们使用的时候不用考虑内存非配与释放,不用担心越界,因为前辈在封装string的时候,已经把几乎所有的情况都考虑到了,3)学习方法,学会查找三种方式:MSDN.工具书.百度4