C++实现string类

已于 2024-01-30 13:59:28 修改
阅读量398 收藏 6
点赞数 7
分类专栏： C++ 文章标签： c++
于 2024-01-25 16:19:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cliu1_16/article/details/135816078
版权
本文详细介绍了如何在C++中实现一个自定义的string类，包括默认构造函数、含参构造函数、析构函数、拷贝构造函数、赋值运算符和加法运算符的实现，以及内存管理的注意事项，如防止内存泄漏和深拷贝。
摘要由CSDN通过智能技术生成

C++实现string类

string类

写一个string类，能够完成string类的操作：

  1. 构造函数，能使用=构造，构造函数传入的参数为const char* 类型
  2. 拷贝构造函数
  3. 析构函数
  4. operator =
  5. operator +
  6. operator +=
  7. operator <<
  8. 从string类型转换成const char*类型，data()方法
  9. 将string转成int类型
  10. 统计string的长度，也就是size()方法
  11. 清空字符串
  12. 判断字符串是否为空
  13. 追加append函数，类似于+=

数据成员

  • char* ptr：指向堆内存空间，从堆内存申请空间。
  • int len：记录字符串实际长度，不包含结束符。

默认构造函数

默认构造函数中，为ptr申请一个字节的堆内存，这样任何情况下，ptr都不为nullptr，避免了ptr是否为nullptr的情况，在随时访问的时候，就可以少写很多if判断。

myString::myString(){
    ptr = (char*)malloc(1); //为ptr申请一个字节的堆内存
    memset(ptr,0,1);
    len = 0; //字符串实际长度为0
}

含参构造函数

  1. 传入一个const char* r，让构造函数接受字符串字面量作为参数，因为字符串字面量在C++中是const char[]类型的，自然会转换为const char*类型。
  2. 先为ptr申请字符串r长度+1的内存空间，多一个字节是为了保存结束符’\0’。
  3. 再将r所指的内存空间中的内容，拷贝给ptr所指的内存空间，使用memmove，memmove被用来将字符串从一个内存位置复制到另一个位置。
  4. 在实际的调用中，用一个“=”赋值的时候，就会调用含餐构造函数。
myString::myString(const char* r){
// 先为ptr申请字符串r长度+1的内存空间，多一个字节是为了保存结束符'\0'
    len = strlen(r);
    ptr = (char*)malloc(len+1);
    memset(ptr,0,len+1);
// 将r所指的内存空间中的内容，拷贝给ptr所指的内存空间，为了避免内存泄漏，使用memmove
    memmove(ptr,r,len+1);
}

析构函数

  1. 释放ptr指向的内存空间
myString::~myString(){
    free(ptr);
}

拷贝构造函数

  1. 因为有指针进行new堆内存操作，需要重写拷贝构造函数进行深拷贝。
  2. 如果不重写拷贝构造函数的话，会调用系统默认的拷贝构造。
  3. 默认的拷贝构造是浅拷贝，在包含堆内存操作的类中，会出现重复释放，造成段错误。
// 拷贝构造，深拷贝
myString::myString(const myString& r){
    //free(ptr);
    len = r.len;
    ptr = (char*)malloc(len+1);
    memset(ptr,0,len+1);// 为p的ptr申请独立的空间
// 将r中的ptr拷贝给p的ptr
    memmove(ptr,r.ptr,len+1); // 拷贝数据
}

赋值运算符

  • 防止自赋值
  • 注意对原本非空指针的释放
myString myString::operator= (const myString& r){
    if(this != &r) { // 防止自赋值
        if(ptr != nullptr)
            free(ptr);
        len = r.len;
        ptr = (char*)malloc(len+1);
        memset(ptr, 0, len+1);
        memmove(ptr, r.ptr, len+1);
    }
    return *this; // 应该返回对象的引用
}

加号运算符和+=运算符

  • p1 = p1+“hello”
  • p1 = p1+p2; 两种都有可能，要写全参数类型
  • +=运算符和+类似
// p1 = p1+"hello";
myString myString::operator+(const char* r){
    // 创建新的对象，新对象的长度以及ptr指向内存空间是this+r的总和
    myString newStr;
    free(newStr.ptr); //这里要把newStr.ptr指向的内存进行释放，否则会出现内存泄漏
    newStr.len = this->len+strlen(r);
    newStr.ptr = (char*)malloc(newStr.len+1);
    memset(newStr.ptr,0,newStr.len+1);
    memmove(newStr.ptr,ptr,len);
    strcat(newStr.ptr,r);
    return newStr;
}

// p1 = p1+p2
myString myString::operator+(const myString& r){
    myString newStr;
    free(newStr.ptr); //这里要把newStr.ptr指向的内存进行释放，否则会出现内存泄漏
    newStr.len = this->len+r.len;
    newStr.ptr = (char*)malloc(newStr.len+1);
    memset(newStr.ptr,0,newStr.len+1);
    memmove(newStr.ptr,ptr,len);
    strcat(newStr.ptr,r.ptr);
    return newStr;
}

myString myString::operator+=(const char* r){
    char* temp = ptr;
    int l = len; // 保存原来的ptr和len
    this->len = this->len+strlen(r);
    this->ptr = (char*)malloc(this->len+1); //ptr指向新的内存空间
    memset(ptr,0,len+1);
    memmove(ptr,temp,l); // 把原来的ptr内容拷贝给新的ptr
    strcat(ptr,r);
    free(temp);
    return *this;
}


myString myString::operator+=(const myString& r){
    char* temp = ptr;
    int l = len;
    len = len+r.len;
    ptr = (char*)malloc(len+1);
    memset(ptr,0,len+1);
    memmove(ptr,temp,l);
    strcat(ptr,r.ptr);
    free(temp); //temp记得free
    return *this;
}

代码

#include<iostream>
#include <string.h>

using std::cout;
using std::endl;

/**
 * 当myString对象没有保存任何字符串的时候，应该至少为该对象中的ptr申请至少一个字节的空间
 * 这样任何情况下，ptr都不为nullptr，避免了ptr是否为nullptr的情况，在随时访问的时候，
 * 就可以少写很多if判断。
 *  · 无参构造函数要重写。
 *  · 因为有指针进行new堆内存操作，默认的拷贝构造是浅拷贝，需要重写拷贝构造，否则会出现重复释放，造成段错误。
*/
class myString{
public:
    myString(); //无参构造函数
    myString(const char* r); //单参构造函数
    myString(const myString& r); //单参构造函数
    ~myString();
    void show(){cout<<ptr<<endl;}
    int size(){return len;}
    void clear();
    bool empty();
    myString operator= (const myString& r);
    myString operator+ (const char* r);
    myString operator+(const myString& r);
    myString operator+= (const char* r);
    myString operator+= (const myString& r);
    char operator[](int n);

    void append(const char* r);
    void append(const myString& r);

    friend std::ostream& operator<< (std::ostream& out, const myString& r);
    friend std::istream& operator>> (std::ostream& in, myString& r);

    const char* data(){return this->ptr;};
    int toInt();
private:
    char* ptr; //指向堆内存空间
    int len; // 字符串实际长度，不包含结束符
};

myString::myString(){
    ptr = (char*)malloc(1); //为ptr申请一个字节的堆内存
    memset(ptr,0,1);
    len = 0;
}

myString::myString(const char* r){
// 先为ptr申请字符串r长度+1的内存空间，多一个字节是为了保存结束符'\0'
    len = strlen(r);
    ptr = (char*)malloc(len+1);
    memset(ptr,0,len+1);
// 将r所指的内存空间中的内容，拷贝给ptr所指的内存空间，为了避免内存泄漏，使用memmove
    memmove(ptr,r,len+1);
}

// 拷贝构造，深拷贝
myString::myString(const myString& r){
    len = r.len;
    ptr = (char*)malloc(len+1);
    memset(ptr,0,len+1);// 为p的ptr申请独立的空间
// 将r中的ptr拷贝给p的ptr
    memmove(ptr,r.ptr,len+1); // 拷贝数据
}

myString::~myString(){
    free(ptr);
}

void myString::clear(){
    free(ptr);
    ptr=(char*) malloc(1);
    memset(ptr,0,1);
    len = 0;
}

bool myString::empty(){
    return !len;
}

myString myString::operator= (const myString& r){
    if(this != &r) { // 防止自赋值
        if(ptr != nullptr)
            free(ptr);
        len = r.len;
        ptr = (char*)malloc(len+1);
        memset(ptr, 0, len+1);
        memmove(ptr, r.ptr, len+1);
    }
    return *this; // 应该返回对象的引用。
}

// p1 = p1+"hello";
myString myString::operator+(const char* r){
    // 创建新的对象，新对象的长度以及ptr指向内存空间是this+r的总和
    myString newStr;
    free(newStr.ptr); //这里要把newStr.ptr指向的内存进行释放，否则会出现内存泄漏
    newStr.len = this->len+strlen(r);
    newStr.ptr = (char*)malloc(newStr.len+1);
    memset(newStr.ptr,0,newStr.len+1);
    memmove(newStr.ptr,ptr,len);
    strcat(newStr.ptr,r);
    return newStr;
}

// p1 = p1+p2
myString myString::operator+(const myString& r){
    myString newStr;
    free(newStr.ptr); //这里要把newStr.ptr指向的内存进行释放，否则会出现内存泄漏
    newStr.len = this->len+r.len;
    newStr.ptr = (char*)malloc(newStr.len+1);
    memset(newStr.ptr,0,newStr.len+1);
    memmove(newStr.ptr,ptr,len);
    strcat(newStr.ptr,r.ptr);
    return newStr;
}

myString myString::operator+=(const char* r){
    char* temp = ptr;
    int l = len; // 保存原来的ptr和len
    this->len = this->len+strlen(r);
    this->ptr = (char*)malloc(this->len+1); //ptr指向新的内存空间
    memset(ptr,0,len+1);
    memmove(ptr,temp,l); // 把原来的ptr内容拷贝给新的ptr
    strcat(ptr,r);
    free(temp);
    return *this;
}


myString myString::operator+=(const myString& r){
    char* temp = ptr;
    int l = len;
    len = len+r.len;
    ptr = (char*)malloc(len+1);
    memset(ptr,0,len+1);
    memmove(ptr,temp,l);
    strcat(ptr,r.ptr);
    free(temp); //temp记得free
    return *this;
}

char myString::operator[](int n){
    return ptr[n];
}

void myString::append(const char* r){
    char* temp = ptr;
    int l = len; // 保存原来的ptr和len
    this->len = this->len+strlen(r);
    this->ptr = (char*)malloc(this->len+1); //ptr指向新的内存空间
    memset(ptr,0,len+1);
    memmove(ptr,temp,l); // 把原来的ptr内容拷贝给新的ptr
    strcat(ptr,r);
    free(temp);
}

void myString::append(const myString& r){
    char* temp = this->ptr;
    int l = len;
    len = len+r.len;
    ptr = (char*)malloc(len+1);
    memset(ptr,0,len+1);
    memmove(ptr,temp,l);
    strcat(ptr,r.ptr);
    free(temp); //temp记得free
}

std::ostream& operator<< (std::ostream& out, const myString& r){
    out<<r.ptr;
    return out;
}

std::istream& operator>> (std::ostream& in, myString& r){
    char buf[1024];
    std::cin>>buf;
    free(r.ptr);
    r.len = strlen(buf);
    r.ptr = (char*)malloc(r.len+1);
    memset(r.ptr,0,r.len+1);
    memmove(r.ptr,buf,r.len+1);

}

int myString::toInt(){
    return atoi(this->ptr);
}

int main(){
    myString str = "hello"; // 转换构造函数，也就是单参构造函数
    myString ptr(str); // 拷贝构造
    myString atp = str; //拷贝构造
    ptr = str; //运算符 operator=
    ptr = ptr + " world";
    ptr.show(); 
    myString str2 = " world";
    str2 = str+str2;
    str += " world";
    str.show();
    ptr+=str2;
    ptr.show();
    atp.append(" world");
    atp.show();
    return 0;
}
cliu1_16
关注
  • 7
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++实现String类实例代码
01-01
C++实现String类实例代码 这是一道十分经典的面试题，可以短时间内考查学生对C++的掌握是否全面，答案要包括C++类的多数知识，保证编写的String类可以完成赋值、拷贝、定义变量等功能。 #include using namespace ...
c++学习之string实现
qq_61422622的博客
08-29 1382
这里给出标准官方的string实现，可以看到设计还是较为复杂的，有成员函数，迭代器，修饰符，容量，元素访问，字符串操作等，将字符尽可能的需求都设计出来，我们这里实现string中比较常用且重要的。
C++string的实现
qq_53558968的博客
07-03 4099
文章目录前言一、string类的特点二、string类的常用接口2.1 4大默认成员函数2.2 容量操作：2.3 string类对象的访问及遍历操作2.4 string类对象的修改操作2.5 判断的接口2.6 string类非成员函数三、string类的实现3.1 考虑成员变量该有什么3.1.1 为什么使用size_t3.2 4大默认成员函数的实现3.2.1 几个错误&&深浅拷贝3.2.2 拷贝构造和赋值现代写法3.2.3 C++11 noexcept， 移动构造和移动赋值3.
C++入门--string类的实现
m0_74288306的博客
08-10 1558
private://string类的大小//string类的存储容量char* _str;我们定义string类的成员变量有sizecapacity_str，配合我们实现插入、删除、扩容等修改操作函数，并且把我们自己实现的string类成员函数封装在命名空间里面，避免和标准库里面的string类类型、函数冲突。
C++中string类的实现
m0_65014490的博客
07-22 1447
在c++的标准库中我们处理字符串的时候需要使用string类，库中的使用接口都非常方便。为了让我们更加了解有关库中的相关函数，我们需要自己来实现一遍。
C++ string类的实现
m0_60447315的博客
08-21 3216
C++ string类实现
C++简单String类的实现
12-22
我跟很多童鞋一样，目前也在学习C++中，昨天正在学习has-a关系中的包含时，例题是将string类包含的，因为是小白嘛，嘿嘿，为了更深的理解包含以及其他相关问题，果断上机边敲代码边理解咯，既然用到了string类，自己...
C++中string类的模拟实现
02-23
该资源中模拟实现了C++中string类的一些常用接口，包括resize、reserve、insert、erase等等，重载了流插入和流提取操作符以实现对string类对象的输出和输入。其中还关注了深拷贝的问题（由于string类中涉及内存资源...
【C++】String类的实现
qq_43581644的博客
04-14 1471
模拟实现string类
C++之string的底层简单实现！（七千字长文详解）
m0_74376760的博客
11-13 1088
string底层实现详解！
C++ 实现string字符串替换全部子串
热门推荐
WYJ的博客
05-31 1万+
/* 函数说明：对字符串中所有指定的子串进行替换 参数： string resource_str //源字符串 string sub_str //被替换子串 string new_str //替换子串 返回值: string */ string subreplace(string resource_str, s...
【C++】string 类的实现
honortech的博客
05-03 917
【C++】string 类的实现
模拟实现string超详解（C++）
m0_67430750的博客
04-23 452
简易版string模拟实现超详解
C++ String类的简单实现
m0_57234892的博客
03-08 2588
在之前c语言的学习中，对于字符串我们很难像整型和其他变量那样进行比较和直接的复制或者定义去运用。但在C++中为了解决这个问题提供了一种类，String类，以类型的形式对字符串进行封装，它除了作为储存字符的容器外，可以对字序列的一系列操作。 下面我们对String类进行简单的模拟实现： namespace wjx { class string { public: private: char* _str; }; 首先，我们定义一个自己的命名空间，来实现我们的string类，定义初...
C++ 编程规范-string类型的实现
劲草浅躬行
03-30 629
1. string类型字符串存储方式的简单说明 string实现方式：比较典型的有eager-copy（贪婪拷贝）；copy-on-write（写时复制）；small string optimization（短字符串优化）方式。 string str1 = "I love China" string str2 = str1; printf("str1存储的地址：%p".str1.c_str()) printf("str2存储的地址：%p".str2.c_str()) 可以看出采用eager-copy方式
String类的实现
嘿嘿嘿呼呼嘿
10-06 344
class String{ public: String(const char* = NULL); // 构造函数 ~String(); // 析构函数 String(const String&); // 拷贝构造函数 String& operator=(const String&); // 赋值运算符 String& operator=(const char*)
c++实现string类
最新发布
02-28
C++中的string类是一个用于处理字符串的标准库类。它提供了一系列成员函数和操作符重载，使得字符串的操作更加方便和高效。 C++中的string类位于命名空间std中，因此在使用之前需要包含头文件< string >。 下面是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值