对C++中string类型的总结

最新推荐文章于 2024-07-08 21:06:18 发布
最新推荐文章于 2024-07-08 21:06:18 发布
阅读量732 收藏 1
点赞数

转自：http://www.cnblogs.com/jerrychoi/archive/2009/07/08/1518919.html     


1:  explicit basic_string();
2:  string(const char *s);
3:  string(const char *s, size_type n);
4:  string(const string& str);
5:  string(const string& str, size_type pos, size_type n);
6:  string(size_type n, E c);
7:  string(const_iterator first, const_iterator last);

string对象的操作

  1. 字符串比较

            支持六种关系运算符(==、!=、>、>=、<、<=)，其采用字典排序策略（与C中字符串比较策略完全一样）。这六个关系运算符是非成员的重载运算符。而这些运算符都支持三种操作数组合：string op string、string op const char*、const char* op string（其中op是前面六种关系运算符中任意一种）。解释：提供运算符的三种重载版本主要是从效率角度考虑的，其避免了临时string对象的产生。

            另外，string类还提供了各种重载版本的成员函数compare来比较，简化函数原型为：

    1:  int compare(const string& str) const;
    2:  int compare(size_type p0, size_type n0, const string& str);
    3:  int compare(size_type p0, size_type n0, const string& str, size_type pos, size_type n);
    4:  int compare(const char* s) const;
    5:  int compare(size_type p0, size_type n0, const char* s) const;
    6:  int compare(size_type p0, size_type n0, const char* s, size_type n) const;
                 返回值：如果调用该函数的对象的比较序列小于操作数比较序列，则返回负数；若相等，则返回0；否则，返回正数。

     

  2. 字符串相加
           

            针对string类提供了非成员重载operator+，支持string对象之间、string对象与const char*对象之间、string对象与char对象之间相加，并且operator + 两边的操作数的任意顺序都支持。简化函数原型如下：
            

    1:  string operator+ (const string& lhs, const string& rhs);
    2:  string operator+ (const string& lhs, const char *rhs);
    3:  string operator+ (const string& lhs, char rhs);
    4:  string operator+ (const char *lhs, const string& rhs);
    5:  string operator+ (char lhs, const string& rhs);

     

  3. 字符串赋值
           

            字符串赋值有两种方式：一是利用成员重载运算符operator=；另外就是使用成员重载函数assign可以更加灵活地处理。这里只提供简化函数原型供参考： 

    1:  string& operator=(char c);
    2:  string& operator=(const char *s);
    3:  string& operator=(const string& rhs);
    4:  string& assign(const char *s);
    5:  string& assign(const char *s, size_type n);
    6:  string& assign(const string& str, size_type pos, size_type n);
    7:  string& assign(const string& str);
    8:  string& assign(size_type n, char c);
    9:  string& assign(const_iterator first, const_iterator last);

     

  4. 字符串追加

            字符串追加同样有两种方式：一是operator+=；另外就是成员函数append。简化函数原型如下： 

    1:  string& operator+=(char c);
    2:  string& operator+=(const char *s);
    3:  string& operator+=(const string& rhs);
    4:  string& append(const char *s);
    5:  string& append(const char *s, size_type n);
    6:  string& append(const string& str, size_type pos, size_type n);
    7:  string& append(const string& str);
    8:  string& append(size_type n, char c);
    9:  string& append(const_iterator first, const_iterator last);

     

  5. 读取子串

            获取某个下标处的字符：一是用at成员函数；另外就是用operator[]。获取子串，可以用成员函数c_str及substr，还有成员函数data和copy。简化函数原型如下： 

    1:  reference operator[](size_type pos);
    2:  const_reference operator[](size_type pos) const;
    3:  reference at(size_type pos);
    4:  const_reference at(size_type pos) const;
    5:   
    6:  const char *c_str() const;
    7:  const char *data() const;
    8:  string substr(size_type pos = 0, size_type n = npos) const;
    9:  size_type copy(char *s, size_type n, size_type pos = 0) const;

            注意：若at函数的参数pos无效，则抛出异常out_of_range；但如果operator[]的参数pos无效，则属于未定义行为。所以at比operator[]更加安全。

            其中，copy返回实际拷贝的字符数。

  6. 替换子串

            成员函数replace实现替换某个子串。简化函数原型如下： 

     1:  string& replace(size_type p0, size_type n0, const char *s);
     2:  string& replace(size_type p0, size_type n0, const char *s, size_type n);
     3:  string& replace(size_type p0, size_type n0, const string& str);
     4:  string& replace(size_type p0, size_type n0, const string& str, size_type pos, size_type n);
     5:  string& replace(size_type p0, size_type n0, size_type n, char c);
     6:  string& replace(iterator first0, iterator last0, const char *s);
     7:  string& replace(iterator first0, iterator last0, const char *s, size_type n);
     8:  string& replace(iterator first0, iterator last0, const string& str);
     9:  string& replace(iterator first0, iterator last0, size_type n, char c);
    10:  string& replace(iterator first0, iterator last0, const_iterator first, const_iterator last);

             这里，可能需要用到这几个函数得到整个字符序列： 

    1:  const_iterator begin() const;
    2:  iterator begin();
    3:  const_iterator end() const;
    4:  iterator end();

     

  7. 插入字符串

            成员函数insert实现在某点处插入字符串。简化函数原型如下： 

    1:  string& insert(size_type p0, const char *s);
    2:  string& insert(size_type p0, const char *s, size_type n);
    3:  string& insert(size_type p0, const string& str);
    4:  string& insert(size_type p0, const string& str, size_type pos, size_type n);
    5:  string& insert(size_type p0, size_type n, char c);
    6:  iterator insert(iterator it, char c);
    7:  void insert(iterator it, const_iterator first, const_iterator last);
    8:  void insert(iterator it, size_type n, char c);

            注意：insert函数是在插入点(p0 or it)之前插入字符串。

  8. 删除子串

            成员函数 erase实现删除某个子串。简化函数原型如下： 

    1:  iterator erase(iterator first, iterator last);
    2:  iterator erase(iterator it);
    3:  string& erase(size_type p0 = 0, size_type n = npos);

            如果指定删除的字符个数比字符串中从指定位置开始的剩余字符个数还多，那么只有这些字符被删除。


  9. 查找子串

            查找子串有六种方式，分别有五类成员函数与之应。

                    · find 查找控制字符序列中与操作字符序列匹配的第一个子串，并返回子串的起始位置；

                    · rfind 查找控制字符序列中与操作字符序列匹配的最后一个子串，并返回该子串的起始位置，相当于逆向查找；

                    · find_first_of 查找控制字符序列中第一个出现在操作字符序列中的字符的位置，并返回该位置；

                    · find_first_not_of查找控制字符序列中第一个不出现在操作字符序列中的字符的位置，并返回该位置；

                    · find_last_of 查找控制字符序列中最后一个出现在操作序列中的字符的位置，并返回该位置；

                    · find_last_not_of 查找控制字符序列中最后一个不出现在操作字符序列中的字符位置，并返回该位置；

             如果这些函数查找失败，则返回string::npos。

             其中，find函数的简化函数原型如下： 

    1:  size_type find(char c, size_type pos = 0) const;
    2:  size_type find(const char *s, size_type pos = 0) const;
    3:  size_type find(const char *s, size_type pos, size_type n) const;
    4:  size_type find(const string& str, size_type pos = 0) const;

            另外的五个函数的函数原型和find的函数原型类型类似，区别在于，如果是是逆序查找的函数(rfind, find_last_of, find_last_not_of），则pos参数默认值为npos。


  10. 其它成员函数和友元函数 

     1:  size_type capacity() const;   // 返回当前字符串的存储空间大小>=size()
     2:  void reserve(size_type n = 0);// 预留n个元素的存储空间，保证capacity()>=n
     3:  bool empty() const;           // 若字符串为空，返回true
     4:  size_type size() const;       // 返回字符串长?
     5:  size_type length() const;     // 等于size()
     6:  size_type max_size() const;   //返回string类中字符串的最大长度
     7:  void resize(size_type n, char c = ' '); //若长度不够，则用c填充加长的部分；保证size()返回n
     8:  void swap(string& str);      //两string对象交换，能在常数时间内完成（必须是使用相同allocator的两对象，这里都使用的默认的）
     9:  
    10:  // 其它非成员函数
    11:  istream& getline(istream& is, string& str);
    12:  istream& getline(istream& is, string& str, char delim);
    13:  ostream& operator<<(ostream& os, const string& str);
    14:  istream& operator>>(istream& is, const string& str);

            其中，istream& getline(istream& is, string& str); 相当于 istream& getline(istream& is, string& str, char delim = '\n');

            getline函数在下列三种情况下结束提取：

                    1）遇到文件结束符；

                    2）遇到分隔符delim。如果第一个就是分隔符，str为空串（并且该分隔符被从流中读出丢弃），但istream测试为真；

                    3）如果已经提取了istream.max_size()个字符，那么提取结束，并且将调用istream.setstate(ios_base::failbit)，即此时返回的istream测试为假。

            如果函数没有提取到字符（包括分隔符），那么将调用istream.setstate(failbit)，此时测试istream为假。

            默认情况下， istream& operator>>(istream& is, const string& str);在下列三种情况下结束提取：
                    1）遇到文件结束符；
                    2）遇到空白字符（空格、Tab、换行）；
                    3）如果已经提取了is.max_size()个字符，或者提取了is.width()（非0情况下）个字符。
            如果没有提取到任何非文件结束符的字符（包括空白字符），那么将调用istream.setstate(failbit)，此时测试istream为假。

            例如，看看下面的循环：

    1:  while(cin >> word) 
    2:  { 
    3:      cout << "word read is: " << word << '\n'; 
    4:  }

     

            要中止上面的循环应该用文件结束符： 
                    Win——Ctrl+Z              Unix——Ctrl+D
            并且，应该是输入行的第一个字符就是文件结束符，然后回车才能结束循环。


星空金
关注
C++string类型的使用总结
07-03
### C++ `string` 类型的使用总结 在C++编程语言中，`string` 类是一种非常重要的数据结构，用于处理文本数据。本篇总结旨在详细介绍`string` 类的构造方法、常用操作方法及其功能特性。 #### 一、`string` 类对象...
const string 与const string&（C++中的引用）
热门推荐
yyangzhenjie的博客
06-26 2万+
引用作为函数参数进行传递时，实质上传递的是实参本身，即传递进来的不是实参的一个拷贝，因此对形参的修改其实是对实参的修改，所以在用引用进行参数传递时，不仅节约时间，而且可以节约空间。
函数传参数时，const string&和 const string 的区别
qq_38392229的博客
06-14 1万+
const string 是值传递 const string& 是引用传递 值传递：是将要传递的值复制一遍传过来，也就是将实参拷贝到形参处，形成实参的副本，在修改副本的时候实参是不会有任何变化的，如果实参数据过大，那么对时间和空间的消耗会很大 引用传递：是将实参的地址拷贝到形参处，像指针一样，修改形参的内容，实参也会改变，地址所用占得内存较小，资源消耗较小 一般使用引用传递比较快捷方便 ...
没有躲过的坑--string中的c_str()陷阱
一蓑烟雨任平生 也无风雨也无晴
11-16 1万+
string.c_str是Borland封装的String类中的一个函数，它返回当前字符串的首字符地址。c_str函数的返回值是const char*的，不能直接赋值给char*，所以就需要我们进行相应的操作转化。#include <iostream> #include <string> int main() { std::string s = "Chelse"; c
const string &和string const &的区别
weixin_35754676的博客
01-30 721
"const string" 是 C++ 中的一种字符串常量类型，表示不可更改的字符串。
string 与 const string&的区别
最新发布
cangqiongxiaoye的博客
07-08 1003
string 与 const string&的区别
浅谈C++中的string 类型占几个字节
09-05
在C++中，`std::string` 是一个非常重要的数据类型，它被用来方便地处理字符串。`std::string` 类型是C++标准库的一部分，位于 `<string>` 头文件中。它提供了许多用于创建、操作和管理字符串的功能，比如插入、删除...
C++中String类的实现
12-22
String是C++中的重要类型，程序员在C++面试中经常会遇到关于String的细节问题，甚至要求当场实现这个类。只是由于时间关系，可能只要求实现构造函数、析构函数、拷贝构造函数等关键部分。 　String的实现涉及很多...
c++中的string常用函数用法总结
09-05
在C++编程中，`std::string`是一个非常重要的数据类型，它提供了处理文本字符串的高效和方便的方式。本文将对C++中的`std::string`常用函数进行详细讲解。 首先，要使用`std::string`，需要包含`<string>`头文件，...
const、&、方法返回类型区分(c++)
叶
05-30 1457
const、&、方法返回类型区分(c++)
c++中const、引用笔记
qq_43050258的博客
12-26 543
C++
c++ 函数传参 string string& const string &三者的区别
weixin_44727250的博客
01-14 1万+
1.string做参数： #include <bits/stdc++.h> using namespace std; void test(string s){ s="shit"; } int main(){ string s{"test"}; test(s); cout<<s<<endl; } 打印结果： test 2.str...
C++学习与实践（一）：const引用与string类型
时间文盲的记事板
10-19 2175
前言 即将开展的任务主打C++，不敢说以前没有接触，但实在都是零散的了解（与能参与项目开发还有非常大差距），所以打算从头开始C++的学习与实践，在此记录过程。 知识重点 昨天通过一道题目的练习，基本理解并掌握以下几个知识点：
传参时 const string& 相对 const string 有哪些优势？
liuyu的博客
03-18 426
传参时 const string& 相对 const string 有哪些优势？ C++中值传递和引用传递的方式。 C++的值传递（pass-by-value）,是从调用的地方把值复制一遍传给函数，这样做有两个问题，第一，需要将实参拷贝到形参处，形成实参的副本，有时间和空间的开销，若实参为结构体或者类的话,那么时空开销将会非常大；第二、函数中对实参副本的修改并不会影响到函数调用位置实参的值。 C++的引用传递（pass-by-reference）,一方面，参数传递的是把实参的地址拷贝到形参，这样形参
【C/C++】深入理解C与C++中的const关键字
crr411422的博客
06-07 855
本文介绍了在C和C++中const关键字的使用方法和注意事项。const关键字可以用于变量、函数、指针和类成员，具有保护数据不被修改、提高代码可读性和安全性的作用。尽管C和C++共享相同的关键字，但在实现时存在一些不同。在实际编程中，需要根据需要选择合适的const用法，并注意区别C和C++中的实现差异。
重学C++ String类
不才的专栏
04-25 802
//源代码来自《C++ 程序员教程》 #ifndef STRING_H #define STRING_H #include using std::ostream; using std::istream; class String { //将流插入和流提取运算符重载为友元 friend ostream &operator<<(ostream &,const String &); frie
const string&有什么优点
m0_61629312的博客
06-29 567
2024年6月29日，周日晚上。
const string &str是什么意思
weixin_42612405的博客
01-30 1964
"const string" 是指在 C++ 编程语言中的一种定义字符串的方式，它表示该字符串是常量，不能被修改。
C++ string类型详解：构造与操作
"C++中的string类型是一个非常重要的数据结构，用于处理文本字符串。这篇总结涵盖了string类型的构造函数、操作方法以及比较和连接字符串的方式。" 在C++中，`std::string` 类型是一个用于存储可变长度字符序列的类...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值