C++学习：string用法


功能
函数原型
说明

构造函数
string(const char *s);
用C风格字符串s初始化

string(int n,char c);
用n个字符c初始化

默认构造函数

复制构造函数

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

char &operator[](int n);

const char &at(int n)const;

char &at(int n);

C风格字符串操作
const char *data()const;
返回一个非null终止的c字符数组

const char *c_str()const;
返回一个以null终止的c字符串

int copy(char *s, int n, int pos = 0) const;
把当前串中以pos开始的n个字符拷贝到以s为起始位置的字符数组中，返回实际拷贝的数目

特征描述
int capacity()const;
返回当前容量（即string中不必增加内存即可存放的元素个数）

int max_size()const;
返回string对象中可存放的最大字符串的长度

int size()const;
返回当前字符串的大小

int length()const;
返回当前字符串的长度

bool empty()const;
当前字符串是否为空

void resize(int len,char c);
把字符串当前大小置为len，并用字符c填充不足的部分

输入输出
重载运算符operator>>
用于输入

重载运算符operator<<
用于输出

getline(istream &in,string &s);
用于从输入流in中读取字符串到s中，以换行符‘\n‘分开。

赋值
string &operator=(const string &s);
把字符串s赋给当前字符串

string &assign(const char *s);
用c类型字符串s赋值

string &assign(const char *s,int n);
用c字符串s开始的n个字符赋值

string &assign(const string &s);
把字符串s赋给当前字符串

string &assign(int n,char c);
用n个字符c赋值给当前字符串

string &assign(const string &s,int start,int n);
把字符串s中从start开始的n个字符赋给当前字符串

string &assign(const_iterator first,const_itertor last);
把first和last迭代器之间的部分赋给字符串

连接
string &operator+=(const string &s);
把字符串s连接到当前字符串的结尾

string &append(const char *s);
把c类型字符串s连接到当前字符串结尾

string &append(const char *s,int n);
把c类型字符串s的前n个字符连接到当前字符串结尾

string &append(const string &s);
同operator+=()

string &append(const string &s,int pos,int n);
把字符串s中从pos开始的n个字符连接到当前字符串的结尾

string &append(int n,char c);
在当前字符串结尾添加n个字符c

string &append(const_iterator first,const_iterator last);
把迭代器first和last之间的部分连接到当前字符串的结尾

比较
bool operator==(const string &s1,const string &s2)const;
比较两个字符串是否相等，运算符">","<",">=","<=","!="均被重载用于字符串的比较

int compare(const string &s) const;
比较当前字符串和s的大小

int compare(int pos, int n,const string &s)const;
比较当前字符串从pos开始的n个字符组成的字符串与s的大小

int compare(int pos, int n,const string &s,int pos2,int n2)const;
比较当前字符串从pos开始的n个字符组成的字符串与s中pos2开始的n2个字符组成的字符串的大小

int compare(const char *s) const;
与C风格的字符串进行比较。compare函数在>时返回1，<时返回-1，==时返回0

int compare(int pos, int n,const char *s) const;

int compare(int pos, int n,const char *s, int pos2) const;

子串
string substr(int pos = 0,int n = npos) const;
返回pos开始的n个字符组成的字符串

交换
void swap(string &s2);
交换当前字符串与s2的值

查找
int find(char c, int pos = 0) const;
从pos开始查找字符c在当前字符串的位置，查找成功时返回所在位置，失败返回string::npos的值

int find(const char *s, int pos = 0) const;
从pos开始查找字符串s在当前串中的位置，查找成功时返回所在位置，失败返回string::npos的值

int find(const char *s, int pos, int n) const;
从pos开始查找字符串s中前n个字符在当前串中的位置，查找成功时返回所在位置，失败返回string::npos的值

int find(const string &s, int pos = 0) const;
从pos开始查找字符串s在当前串中的位置，查找成功时返回所在位置，失败返回string::npos的值

int rfind(char c, int pos = npos) const;
从pos开始从后向前查找字符c在当前串中的位置

int rfind(const char *s, int pos = npos) const;
从pos开始从后向前查找字符串s在当前串中的位置，成功返回所在位置，失败时返回string::npos的值

int rfind(const char *s, int pos = npos, int n) const;
从pos开始从后向前查找字符串s中前n个字符组成的字符串在当前串中的位置，成功返回所在位置，失败时返回string::npos的值

int rfind(const string &s,int pos = npos) const;
从pos开始从后向前查找字符串s在当前串中的位置，成功返回所在位置，失败时返回string::npos的值

int find_first_of(char c, int pos = 0) const;
从pos开始查找字符c第一次出现的位置

int find_first_of(const char *s, int pos = 0) const;
从pos开始查找当前串中第一个s出现的位置。查找失败返回string::npos

int find_first_of(const char *s, int pos, int n) const;
从pos开始查找当前串中第一个在s的前n个字符组成的数组里的字符的位置。查找失败返回string::npos

int find_first_of(const string &s,int pos = 0) const;
从pos开始查找当前串中第一个s出现的位置。查找失败返回string::npos

int find_first_not_of(char c, int pos = 0) const;
从pos开始查找第一个不在当前串中出现字符c的位置，失败返回string::npos

int find_first_not_of(const char *s, int pos = 0) const;
从pos开始查找第一个不在当前串中出现字符串s的位置，失败返回string::npos

int find_first_not_of(const char *s, int pos,int n) const;
从pos开始查找第一个不在当前串中出现由s的前n个字符组成的字符串的位置，失败返回string::npos

int find_first_not_of(const string &s,int pos = 0) const;
从pos开始查找第一个不在当前串中出现字符串s的位置，失败返回string::npos

int find_last_of(char c, int pos = npos) const;
find_last_of和find_last_not_of与find_first_of和find_first_not_of相似，只不过是从后向前查找

int find_last_of(const char *s, int pos = npos) const;

int find_last_of(const char *s, int pos, int n = npos) const;

int find_last_of(const string &s,int pos = npos) const;

int find_last_not_of(char c, int pos = npos) const;

int find_last_not_of(const char *s, int pos = npos) const;

int find_last_not_of(const char *s, int pos, int n) const;

int find_last_not_of(const string &s,int pos = npos) const;

替换
string &replace(int p0, int n0,const char *s);
删除从p0开始的n0个字符，然后在p0处插入串s

string &replace(int p0, int n0,const char *s, int n);
删除p0开始的n0个字符，然后在p0处插入字符串s的前n个字符

string &replace(int p0, int n0,const string &s);
删除从p0开始的n0个字符，然后在p0处插入串s

string &replace(int p0, int n0,const string &s, int pos, int n);
删除p0开始的n0个字符，然后在p0处插入串s中从pos开始的n个字符

string &replace(int p0, int n0,int n, char c);
删除p0开始的n0个字符，然后在p0处插入n个字符c

string &replace(iterator first0, iterator last0,const char *s);
把[first0，last0）之间的部分替换为字符串s

string &replace(iterator first0, iterator last0,const char *s, int n);
把[first0，last0）之间的部分替换为s的前n个字符

string &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）之间的字符串

插入
string &insert(int p0, const char *s);
在p0位置插入字符串s中pos开始的前n个字符

string &insert(int p0, const char *s, int n);

string &insert(int p0,const string &s);

string &insert(int p0,const string &s, int pos, int n);

string &insert(int p0, int n, char c);
此函数在p0处插入n个字符c

iterator insert(iterator it, char c);
在it处插入字符c，返回插入后迭代器的位置

void insert(iterator it, const_iterator first, const_iterator last);
在it处插入[first，last）之间的字符

void insert(iterator it, int n, char c);
在it处插入n个字符c

删除
string& erase ( size_t pos = 0, size_t n = npos );
删除从pos开始的n个字符，返回修改后的字符串

iterator erase(iterator it);
删除it指向的字符，返回删除后迭代器的位置

iterator erase ( iterator first, iterator last );
删除从first到last之间的字符（first和last都是迭代器），返回删除后迭代器的位置

迭代器
const_iterator begin()const;
返回string的起始位置。用string::iterator或string::const_iterator声明迭代器变量，const_iterator不允许改变迭代的内容

iterator begin();

const_iterator end()const;
返回string的最后一个字符后面的位置

iterator end();

const_iterator rbegin()const;
返回string的最后一个字符的位置。rbegin和rend用于从后向前的迭代访问，通过设置迭代器string::reverse_iterator,string::const_reverse_iterator实现

iterator rbegin();

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

iterator rend();

流处理
通过定义ostringstream和istringstream变量实现，#include <sstream>头文件中
时间： 2024-10-13 12:11:41

C++学习：string用法的相关文章

C#中string用法实例详解

在进行C#程序设计时,用的最多的莫过于string了,但有些时候由于不仔细或者基础的不牢固等因素容易出错,今天本文就来较为详细的总结一下C#中string的用法.具体如下: 1.string是一个引用类型,平时我们比较string对象,比较的是对象的值而不是对象本身 如下面代码所示: string strA="abcde"; string strB="abc"; string strC="de"; Console.WriteLine(strA =

JDK1.8源码学习-String

JDK1.8源码学习-String 目录 一.String简介 String类是Java中最常用的类之一,所有字符串的字面量都是String类的实例,字符串是常量,在定义之后不能被改变. 二.定义 public final class String implements java.io.Serializable, Comparable<String>, CharSequence{} 1.String类是由final修饰的,表明String类不能被继承,并且String类中的成员方法都默认是fi

学习string,stringBuffer时遇到的问题

今天学习string和stringBuffer.了解了两者的区别,然后去看java api都有啥方法.stringBuffer类有indexOf方法,于是写了下面的代码 String str = "abc"; StringBuffer strBuffer = new StringBuffer(); strBuffer.append("abc"); System.out.println(strBuffer.toString()); System.out.println

JDK源码学习--String篇(二) 关于String采用final修饰的思考

JDK源码学习String篇中,有一处错误,String类用final[不能被改变的]修饰,而我却写成静态的,感谢CTO-淼淼的指正. 风一样的码农提出的String为何采用final的设计,阅读JDK源码的时候,有粗略的思考过,今天下班后又把<Thinking in Java>中关于final的内容重新看了一遍,对此写下一些关于自己的理解和想法. String类中final关键字的使用 final关键字,用来描述一块数据不能被改变,两种可能理由:设计.效率 final使用的三种情况:数据.方

学习:record用法

详情请参考官网:http://www.erlang.org/doc/reference_manual/records.html http://www.erlang.org/doc/programming_examples/records.html 1. record本质上是tuple. 2.获取record的结构相关的信息的函数: To each module using records, a pseudo function is added during compilation to obta

C++ string 用法详解

/////////////////////////////////////////////////////////////////////////////////// 任何人对本文进行引用都要标明作者是Nicolai M.Josuttis /////////////////////////////////////////////////////////////////////////////////// C++ 语言是个十分优秀的语言,但优秀并不表示完美.还是有许多人不愿意使用C或者C++,为什

c++ std::string 用法

std::string用法总结 在平常工作中经常用到了string类,本人记忆了不好用到了的时候经常要去查询.在网上摘抄一下总结一下,为以后的查询方便: string类的构造函数: string(const char *s);    //用c字符串s初始化string(int n,char c);     //用n个字符c初始化 string类的字符操作: const char &operator[](int n)const; const char &at(int n)const; cha

函数的学习以及用法

  浅谈函数应用 函数存在的意义:  把main函数中复杂的逻辑进行拆分,由一个一个单独的函数来处理一个单独的模块,main函数只是起到宏观调控作用 我们可以自己编写一些函数,实现某些功能,把函数的声明放在.h文件里,把函数的定义即实现放在.m文件里,然后在main.m文件里的main函数里调用实现,但是调用之前一定不要忘记把自己写的文件导入即导入头文件,导入自己编写的头文件用#import "",导入系统头文件用#import <> 此外,一个函数最多不要超过60行代码,

python学习--string

1\string are immutable, which means you can't change an existing string. >>>greeting = 'Hello world!' >>>greeting[0] = 'J' TypeError: object does not support item assignment 2\The world in is a boolean operator that takes two strings and

python string用法学习ing

#!/usr/bin/env python #-*- coding:UTF-8 -*- ##################################################### # Author: sunfx   [email protected] # Last modified:  2014/11/11 # Filename:  string.py # Q  Q  群:  236147801 ##########################################