string类（详细描述）

最新推荐文章于 2024-03-17 23:38:58 发布
最新推荐文章于 2024-03-17 23:38:58 发布
阅读量1.9k 收藏 20
点赞数 10
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55610255/article/details/132947932
版权

目录

一、简介：

二、string的构造函数

三、string的赋值操作

四、string的取值和修改操作

4.1、string的取值和修改操作

 4.2、字符串的取值和修改操作之at方法和重载operator[]方法的区别

五、string的拼接操作

六、string的查找和替换操作

七、string的比较操作

八、string的子串、插入和删除操作

九、string的C风格和C++风格

一、简介：

string中文意思是字符串，string是一个类，在C++语言中，string类型不属于基础类型，string是一个模板类，实例化就是一个对象。也可以理解为他是一个可以操作字符串的类。

基础类型有八种：byte、boolean、char、short、int、float、long、double

string模板类原型：

template <class CharT, class Traits = std::char_traits<CharT>, class Allocator = std::allocator<CharT>>
class basic_string;

        定义了一个名为basic_string的模板类，它有三个模板参数：CharT、Traits和Allocator。这些参数分别指定了字符类型、字符特性和分配器类型用于分配内存。

CharT参数表示字符类型，通常使用char来表示普通的字符串。Traits参数表示字符操作的特性，比如比较、复制等。Allocator参数表示内存分配器类型，用于在运行时分配和释放内存。

 

二、string的构造函数

string类

 * string();//默认无参构造函数
 * string(const string &str);//默认拷贝构造函数
 * string(const char *str);//有一个参数的有参构造函数，使用char *类型初始化string对象
 * string(int n,char c);//有两个参数的有参构造函数，第一个参数表示使用的数量，第二个参数表示数据，即使用n个字符c 初始化string对象

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

/*
 * string();//默认无参构造函数
 * string(const string &str);//默认拷贝构造函数
 * string(const char *str);//有一个参数的有参构造函数，使用char *类型初始化string对象
 * string(int n,char c);//有两个参数的有参构造函数，第一个参数表示使用的数量，第二个参数表示数据，即使用n个字符c 初始化string对象
 */

void test(){

    string str1("hello,world!");//有一个参数的有参构造函数，string类的对象是str1
    cout<<str1<<endl;//可以直接把对象当做字符串遍历

    string str2(9,'H');//有两个参数的有参构造函数。string类的对象是str2
    cout<<str2<<endl;

    string str3(str1);//拷贝构造函数
    cout<<str3<<endl;

    const char *str4="hello,string类";
    string str5(str4);//一个参数的有参构造函数
    cout<<str5<<endl;
}

int main()
{
    test();//调用函数
    return 0;
}

输出结果：

注意 char *str4="hello,string类";虽然编译通过，但是会报警告，因为这是错误的写法，"hello，string类"是一个常量，而char *str4是一个指针类型变量，正确的写法应该是 加const修饰，修饰指针不可更改，即const *str4="hello,string类";

三、string的赋值操作

   string &operator=(const char *s);//重载赋值运算符，使用c风格的字符串类型赋值给当前对象
    string &operator =(const string &str);//把str对象赋值给当前对象
    string &operator =(char c);//字符赋值给当前对象
    string &assign(const char *s);//把字符串赋值给当前对象
    string &assign(const char *s,int n);//把字符串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个字符赋值给当前对象
  

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

void test1(){
    /*
    string &operator=(const char *s);//重载赋值运算符，使用c风格的字符串类型赋值给当前对象
    string &operator =(const string &str);//把str对象赋值给当前对象
    string &operator =(char c);//字符赋值给当前对象
    string &assign(const char *s);//把字符串赋值给当前对象
    string &assign(const char *s,int n);//把字符串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 str1;
    str1="hello,stringC风格赋值操作";
    string str2;
    str2=str1;//对象赋值
    string str3;
    str3='H';//字符赋值
    string str4;
    const char *str0="hello,C风格的字符串";
    str4.assign(str0);//C风格字符串通过assign函数赋值
    string str5;
    str5.assign(str0,5);//前5个字符赋值给当前对象
    string str6;
    str6.assign(str5);//把str5对象赋值给str6对象
    string str7;
    str7.assign(9,'H');//把9个H赋值给当前对象
    string str8;
    str8.assign(str4,5,4);//将str4的从第五个字符开始的4个字符赋值给当前对象
    //遍历8个对象
    cout<<str1<<endl;
    cout<<str2<<endl;
    cout<<str3<<endl;
    cout<<str4<<endl;
    cout<<str5<<endl;
    cout<<str6<<endl;
    cout<<str7<<endl;
    cout<<str8<<endl;

}

int main()
{
    test1();//调用函数
    return 0;
}

输出结果：

注意：一个汉字，占两个字符 ，这里使用的是Qt软件 编码格式使用默认的system，一般是utf8编码

四、string的取值和修改操作

4.1、string的取值和修改操作

   /*
   char &operator[](int n);//重载[]运算符，n是下标
   char &at(int n);//通过at方法获取下标为n的元素
   */

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

void test2(){
   /*
   char &operator[](int n);//重载[]运算符，n是下标
   char &at(int n);//通过at方法获取下标为n的元素
   */
    string str1="hello,string类";//赋值运算符赋值初始化，一般不建议，在这里可以用，因为是常量，不会发生隐式转换
    string str2("hello,string类");//直接赋值初始化，建议使用该方法
    str2[4]='H';//将字符串第五个元素改为H
    cout<<str2<<endl;
    cout<<str2[4]<<endl;

    str1.at(1)='E';//使用at方法取值然后修改值
    cout<<str1<<endl;
    cout<<str1[1]<<endl;

}

int main()
{
    test2();//调用函数
    return 0;
}

输出结果：

 4.2、字符串的取值和修改操作之at方法和重载operator[]方法的区别

使用重载operator[]运算符方法，下标越界不会抛出异常

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

void test2(){
   /*
   char &operator[](int n);//重载[]运算符，n是下标
   char &at(int n);//通过at方法获取下标为n的元素
   */
    string str1="hello,string类";//赋值运算符赋值初始化，一般不建议，在这里可以用，因为是常量，不会发生隐式转换
    string str2("hello,string类");//直接赋值初始化，建议使用该方法
    str2[4]='H';//将字符串第五个元素改为H
    cout<<str2<<endl;
    cout<<str2[4]<<endl;

    str1.at(1)='E';//使用at方法取值然后修改值
    cout<<str1<<endl;
    cout<<str1[1]<<endl;

    try{
        str1[100000]='H';//数组下标访问越界，使用operator[]方法不会抛出异常
    }
    catch(exception &str){
        cout<<str.what()<<endl;//接收来自try的异常

    }
    printf("hello,string测试\n");//测试

}

int main()
{
    test2();//调用函数
    return 0;
}

输出结果：

使用at方法，下标越界会抛出异常

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

void test2(){
   /*
   char &operator[](int n);//重载[]运算符，n是下标
   char &at(int n);//通过at方法获取下标为n的元素
   */
    string str1="hello,string类";//赋值运算符赋值初始化，一般不建议，在这里可以用，因为是常量，不会发生隐式转换
    string str2("hello,string类");//直接赋值初始化，建议使用该方法
    str2[4]='H';//将字符串第五个元素改为H
    cout<<str2<<endl;
    cout<<str2[4]<<endl;

    str1.at(1)='E';//使用at方法取值然后修改值
    cout<<str1<<endl;
    cout<<str1[1]<<endl;

    try{
        //str1[100000]='H';//数组下标访问越界，使用operator[]方法不会抛出异常
        str1.at(100000)='H';//抛出异常，程序不会终止
    }
    catch(exception &str){
        cout<<str.what()<<endl;//接收来自try的异常

    }
    printf("hello,string测试\n");//测试

}

int main()
{
    test2();//调用函数
    return 0;
}

输出结果：

tips:at方法抛出异常之后，程序不终止，且抛出异常提示，该大小只有14个字节，100000超过

五、string的拼接操作

  /*
    string &operator+=(const string &str);//重载+=运算符
    string &operator +=(const char *str);//c风格
    string &operator +=(const char c);
    string &append(const char *s);//append追加方法
    string &append(const char *str,int n);
    string &append(const string &s);
    string &append(const string &s,int pos,int n);
    string &append(int n,char c);
   */

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

void test3(){
    /*
    string &operator+=(const string &str);//重载+=运算符
    string &operator +=(const char *str);//c风格
    string &operator +=(const char c);
    string &append(const char *s);//append追加方法
    string &append(const char *str,int n);
    string &append(const string &s);
    string &append(const string &s,int pos,int n);
    string &append(int n,char c);
   */

    string str1="hello,string";
    string str2=",world";
    str1+=str2;//两个对象相加赋值给str1对象

    string str3="hello,baby";
    str3+="欢迎来到这个世界！";//C风格相加

    string str4("you are welcome");
    str4+='H';//字符追加

    string str5("baby");
    str5.append("hello");//append方法追加

    string str6("god");
    str6.append("hello,string",2);//前两个追加给str6对象

    string str7("luck");
    str7.append(str6);

    string str8("hi");
    str8.append(str4,3,4);

    string str9("wow");
    str9.append(9,'Q');

    //遍历
    cout<<str1<<endl;
    cout<<str2<<endl;
    cout<<str3<<endl;
    cout<<str4<<endl;
    cout<<str5<<endl;
    cout<<str6<<endl;
    cout<<str7<<endl;
    cout<<str8<<endl;
    cout<<str9<<endl;
}

int main()
{
    test3();//调用函数
    return 0;
}

输出结果：

六、string的查找和替换操作

  /*
    int find(const string &str,int pos=0) const;//查找str第一次出现的位置，从第pos位置开始查找
    int find(const char *s,int pos=0) const;//查找字符s第一次出现的位置，从pos位置开始查找
    int find(const char *s,int pos,int n) const;//从pos查找s的前n个字符在当前对象出现的位置
    int find(const char c,int pos=0) const;
    int rfind(const string &str,int pos=npos) const;//查找最后一次出现的位置
    int rfind(const char *s,int pos=npos) const;
    int rfind(const char *s,int pos,int n) const;
    int rfind(const char c,int pos=0) const;
    string &replace(int pos,int n,const string &str);//replace替换方法，从pos开始到n的位置的元素替换为str
    string &replace(int pos,int n,const char *s);
    */

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


void test4(){
    /*
    int find(const string &str,int pos=0) const;//查找str第一次出现的位置，从第pos位置开始查找
    int find(const char *s,int pos=0) const;//查找字符s第一次出现的位置，从pos位置开始查找
    int find(const char *s,int pos,int n) const;//从pos查找s的前n个字符在当前对象出现的位置
    int find(const char c,int pos=0) const;
    int rfind(const string &str,int pos=npos) const;//查找最后一次出现的位置
    int rfind(const char *s,int pos=npos) const;
    int rfind(const char *s,int pos,int n) const;
    int rfind(const char c,int pos=0) const;
    string &replace(int pos,int n,const string &str);//replace替换方法，从pos开始到n的位置的元素替换为str
    string &replace(int pos,int n,const char *s);
    */
    string str1="helllo,string";
    string str2="lll";
    int find1=str1.find(str2);
    int find2=str1.find("lll");
    int find3=str1.find("good",2,3);
    int find4=str1.find('h');
    int rfind5=str1.rfind(str2);//最后一次出现的位置，其实就是逆序查找
    int rfind6=str1.rfind("lll");
    int rfind7=str1.rfind("wow",1,2);
    int rfind8=str1.rfind('l');

    //替换replace
    string str3="replace functions";
    string str4="#########";
    str3.replace(2,4,str4);//从下标为2开始的元素到下标为4结尾的元素替换为str4的元素

    string str5="good study";
    str5.replace(2,4,"嗨");

    string str6="http://www.good.sex.666.sex.age.999.age.com.cn";//将sex和age敏感词屏蔽，sex用*,age用#
    while (1) {
       int ret=str6.find("sex");
       int ret1=str6.find("age");
       if(ret==-1&&ret1==-1){
           break;
       }
       str6.replace(ret,3,"***");
       str6.replace(ret1,3,"###");
    }

   //遍历
    cout<<find1<<endl;
    cout<<find2<<endl;
    cout<<find3<<endl;
    cout<<find4<<endl;
    cout<<rfind5<<endl;
    cout<<rfind6<<endl;
    cout<<rfind7<<endl;
    cout<<rfind8<<endl;

    cout<<str3<<endl;
    cout<<str5<<endl;
    cout<<str6<<endl;

}

int main()
{
    test4();//调用函数
    return 0;
}

输出结果：

七、string的比较操作

 /*
    compare方法在>返回1，<返回-1，==返回0;
    字符比较根据ASCII码表进行比较
    int compare(const string &s) const;
    int compare(const char *s) const;
    */ 

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



void test5(){
    /*
    compare方法在>返回1，<返回-1，==返回0;
    字符比较根据ASCII码表进行比较
    int compare(const string &s) const;
    int compare(const char *s) const;
    */

    string str1("hello,string");
    string str2("helllo,string");
    if(str1.compare(str2)==0){
        cout<<"相等"<<endl;
    }
    else if(str1.compare(str2)>0){
        cout<<"str1大于str2"<<endl;
    }
    else{
        cout<<"str1小于str2"<<endl;
    }

    if(str2.compare("hello")==0){
         cout<<"相等"<<endl;
    }
    else if(str2.compare("hello")>0){
        cout<<"str2大于'hello'"<<endl;
    }
    else{
        cout<<"str2小于'hello'"<<endl;
    }


}

int main()
{
    test5();//调用函数
    return 0;
}

输出结果：

 tips:通过输出结果可知compare方法是逐个字符进行比较

八、string的子串、插入和删除操作

 /*
    string substr(int pos=0,int n=npos) const;//返回由pos开始的到n组成的字符串
    string &insert(int pos,const char *s);//从pos位置插入s
    string &insert(int pos,const string &str);
    string &insert(int pos,int n,char c);//指定的位置pos插入n个c
    string &erase(int pos,int n=npos);//删除从pos开始的n个元素
    */

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


void test6(){
    /*
    string substr(int pos=0,int n=npos) const;//返回由pos开始的到n组成的字符串
    string &insert(int pos,const char *s);//从pos位置插入s
    string &insert(int pos,const string &str);
    string &insert(int pos,int n,char c);//指定的位置pos插入n个c
    string &erase(int pos,int n=npos);//删除从pos开始的n个元素
    */
    string str1="hello,string";
    string str2=str1.substr(2,3);
    cout<<str2<<endl;

    string str3="hello,you are welcome in my eye you are beautiful";
    int s=0;
    while (1) {
       int ret=str3.find(" ",s);//find方法如果查找到了，返回下标位置，查找不到返回-1
       if(ret==-1){
           cout<<str3.substr(s,str3.size()-s)<<endl;
           break;
       }
       cout<<str3.substr(s,ret-s)<<endl;
       s=ret+1;
    }

    string str4="hello,string";
    str4.insert(3,"######");
    cout<<str4<<endl;
    str4.insert(1,str1);
    cout<<str4<<endl;
    str4.insert(2,4,'H');
    cout<<str4<<endl;

    string str5="good,good,stud";
    str5.erase(3,4);//删除3到4位置的元素
    cout<<str5<<endl;
}

int main()
{
    test6();//调用函数
    return 0;
}

输出结果：

九、string的C风格和C++风格

/*
     * c语言中是没有string类型，因为string是类，是模板类，所以c语言使用指针来使用字符串
     * c++使用了C风格的字符串就是这么来的
     */ 

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

void test7(){
    /*
     * c语言中是没有string类型，因为string是类，是模板类，所以c语言使用指针来使用字符串
     * c++使用了C风格的字符串就是这么来的
     */

    //C风格字符串
    const char *str1="hello,C_string";
    string str2=str1;
    cout<<str2<<endl;

    //c++风格字符串
    string str3="hello,C++_string";
    cout<<str3<<endl;

    //c++风格转换为c风格
    const char *str4=str3.c_str();
    cout<<str4<<endl;//使用c_str方法可以将c++对象转换为c语言风格的char指针类型
}

int main()
{
    test7();//调用函数
    return 0;
}

输出结果：

string类的使用介绍完毕啦。

真心耗时

凢曐
关注
  • 10
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C++实现String类实例代码
01-01
C++实现String类实例代码 这是一道十分经典的面试题，可以短时间内考查学生对C++的掌握是否全面，答案要包括C++类的多数知识，保证编写的String类可以完成赋值、拷贝、定义变量等功能。 #include<iostream> using namespace std; class String { public: String(const char *str=NULL); String(const String &other); ~String(void); String &operator =(const String &other); priva
JavaSE之StringBuilder类与String类
07-21
这个文件里的内容适合Java初学者，String类为引用类，不属于基本数据类型，但是String类非常的重要，在后边学习的JavaSE中，几乎使用的全是String类，这个文件里边包含了对String字符串的拆分、拼接以及怎么声明进行了详细的介绍。这也是小编在刚开学学习JavaSE时记录的一些笔记，里面的内容非常适合JavaSE入门者学习，都是浅显易懂的话语，没有太多的官方话，绝对是你初学JavaSE的宝典，针对人群：刚入门的JavaSE小白的同学们，我相信通过你们的努力学习，以后一定都会成为IT行业的大佬儿，在这里先恭喜大家啦。如果觉得不错的同学，可以赶紧关注小编或者私信小编，给大家发后面的JavaSE笔记内容，欢迎大家随时打扰小编吖~~
String类详解
热门推荐
weixin_43502661的博客
04-03 2万+
一、基本内容： 1.String类：即字符串类，其主要构造方法为： 　String(String Original)，把字符串封装成字符串对象； 　举例：String s1 = new String(“hello”); 　String(char[] value),把字符数组的数据封装成字符串对象； 　举例：char[] chs = {‘h’,‘e’,‘l’,‘l’,‘o’};　　　 　　　　Str...
string和stringbuilder
最新发布
weixin_43735634的博客
03-17 394
stringbuilder是长度可变的字符序列，创建的时候如果不带参数的话，那么默认的长度就是16，如果带参数的话，那么长度就是16+参数。string是一个长度不可变的字符序列，底层是一个被final修饰的char[]数组，所以说，任何对 String 类型进行改变的操作实际上都是重新生成了一个新的String对象，然后将指针指向新的 String 对象，这样不仅效率低下，而且大量浪费有限的内存空间，所以经常改变内容的字符串最好不要用 String。
C++重写String类
05-26
C++重写String类C++重写String类C++重写String类C++重写String类
string类的常用方法
10-31
string类的常用方法
C++string类仿写
05-30
C++编写的类似于string类，自己改动实现相关库函数功能 C++的一般编译器都定义和封装了字符串功能，请模仿定义string类的实现，可以实现并支持如下功能： （1）string s = “rubbish大学”； （2）string t = s; （3）string m； m = t； （4）m.legnth() 函数测量字符串的长度 （5）m.cat(string const &)连接字符串
String类详细介绍
xuecde的博客
04-02 3811
size计算字符串长度。
String类型（详述）
挣钱买房买车的博客
07-18 6340
String类详细讲解
String类的详解
m0_53677355的博客
09-25 1442
注意：replaceAll方法并不是在s的基础上替换的，而是将替换的结果作为一个新的字符串返回了，替换之后始终不变，因为String类在设计的时候，就严格限定了String类的对象是不可改变的，即字符串是不可变对象。2、将自定义类型的对象转换为String类型的字符串，类中需要重写Object类中的toString的方法，如果没有重写，将来转换完之后的结果：类全路径名+@+hashCode的十六进制的结果。注意：对于内置对象，==比较的是变量中的值，对于引用类型，==比较的是引用中的地址。
String类型
qq_51510549的博客
09-27 1万+
一、String类型： 1.String类型定义： Java中数据类型分为基本数据类型和引用数据类型两大类，而String类型就属于引用数据类型，但是String类型并不是字符串，而是Java的一个类，Java通过String类型来操作字符串 String类是最终类用final修饰，不能被其他类继承 2.字符串特性： 字符串是操作系统上提供的一种可用于操作和表达多个字符类型组合的一种结构 a.面值内容不可以发生改变 b.同样的元素在内存中不会出现第二次 ...
JAVA中String类与StringBuffer类的区别
08-31
主要为大家详细介绍了JAVA中String类与StringBuffer类的区别，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
string类讲解文档
11-20
该文档讲解了C++string类的各项函数,讲解详细,内容充实且举例较多
自定义String类
10-31
通过C语言实现的C++中自定义的模拟String类代码，实现基本工程操作
设计string类
05-08
1、为该类定义构造函数,析构函数和赋值操作。构造函数至少应有三个：无参构造函数、C风格字符串构造函数和复制构造函数 2、为string类提供必要的成员函数，可以参考C++类库的string类提供了那些成员函数，至少应包括下标访问，子串查找、获得C风格字符串、获得字符串长度、字符串比较这几个函数 3、利用该string类完成测试程序:统计一个文本文件中所有包含给定子串的单词，并按字典序无重复的打印输出这些单词 PS这是一道题目，本人综合了一些成果汇总成了源码
String类
12-22
String 类描述的是文本字符序列，同时 String 类被 final 关键字所修饰，意味着 String 类不能够继承，而且它的成员方法默认是 final 方法，所以当字符串一旦被创建就无法被修改。 String str1 = "小明"； String ...
W7_04_string类.pdf
04-13
里面是C++ string类的具体描述和使用介绍
string类的C++描述
09-14
用C++描述string通用类，方便调用，实现封装
详细描述java抽象类
09-23
抽象类是Java中的一种特殊类，它不能被实例化，只能作为其他类的基类或父类来被继承。抽象类的主要目的是为了提供一种通用的抽象模板，定义了一些方法的签名（包括方法名、参数和返回类型），但没有具体的实现。子类继承抽象类后，必须实现抽象方法，才能创建该子类的实例。 在Java中，我们使用`abstract`关键字来声明一个抽象类。抽象类可以包含普通方法、成员变量和构造方法，但不能包含私有的构造方法。抽象方法用`abstract`关键字来声明，并且不提供具体的实现。子类必须实现父类中的所有抽象方法，否则子类也必须声明为抽象类。 下面是一个简单的抽象类的示例： ```java abstract class Shape { protected String color; public Shape(String color) { this.color = color; } public abstract double getArea(); } class Circle extends Shape { private double radius; public Circle(double radius, String color) { super(color); this.radius = radius; } @Override public double getArea() { return Math.PI * radius * radius; } } class Square extends Shape { private double side; public Square(double side, String color) { super(color); this.side = side; } @Override public double getArea() { return side * side; } } ``` 在上面的示例中，`Shape`类是一个抽象类，它有一个抽象方法`getArea()`，并且包含一个成员变量`color`和一个构造方法。`Circle`和`Square`类继承自`Shape`类，并实现了抽象方法`getArea()`。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值