手写 string 类

最新推荐文章于 2024-08-13 15:35:17 发布
最新推荐文章于 2024-08-13 15:35:17 发布
阅读量573 收藏
点赞数
分类专栏： c、c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012979457/article/details/119710427
版权 
// 头文件
#ifndef MYSTRING_H
#define MYSTRING_H
#include <iostream>
#include <cstring>
#include <cstdlib>
using namespace std;

class myString
{
    friend ostream & operator<<(ostream & out, myString &) ;
    friend istream & operator>>(istream & in, myString &) ;


    public:
        myString();  // 默认构造
        virtual ~myString();


        myString(const char *); // 由字符串构造
        myString(const myString &); // 拷贝构造函数

        myString & operator=(const myString &);   // 拷贝赋值运算符
        myString & operator=(const char *);   // 由字符串构造


        myString(myString &&) noexcept;  // 移动构造函数
        myString & operator=(myString &&) noexcept;  // 移动赋值运算符



        int getLength() const;
        int getCapacity() const;
        const char * getStr() const;  // 获取 C 字符串


        char & operator[](int);  // 获取 第 i 位字符
        bool operator==(const myString& str); // 判断两个字符串是否相等

        void append(char c);  // 追加一个字符
        void append(const char * s); // 追加一个字符串

        myString  operator+(const char * s);  // 拼接字符串
        myString  operator+(const myString & s2);  // 拼接字符串
        myString & operator+=(const char * s); // 追加字符串
        myString & operator+=(const myString & s); // 追加字符串

    protected:

    private:
        char * str;
        int length;
        int capacity;
};

#endif // MYSTRING_H

#include "MyString.h"

myString::myString()
{
    this->length = 0;
    this->capacity = 15;
    this->str = (char *)malloc(sizeof(char) * this->capacity);// 默认分配一个长度为15的字符数组,初始化为空串
    this->str[0] = '\0';
}


myString::~myString()
{
    //dtor
    if(this->str != nullptr) {
        free(this->str);
    }
}

myString::myString(const char * s)
{
    if(s != nullptr) {
        int sz = strlen(s);
        this->length = sz;
        this->capacity = sz+1;
        this->str = (char * ) malloc(sizeof(char) * this->capacity);  // 按字符串大小复制
        strcpy(this->str,s);
    } else {
        this->length = 0;
        this->capacity = 15;
        this->str = (char *)malloc(sizeof(char) * this->capacity);// 默认分配一个长度为15的字符数组,初始化为空串
        this->str[0] = '\0';
    }
}

myString::myString(const myString & s)
{
    this->length = s.getLength();
    this->capacity = s.getCapacity();
    this->str = (char * ) malloc(sizeof(char) * this->capacity);  // 按字符串大小复制
    strcpy(this->str,s.getStr());

}

// 移动构造函数
myString::myString(myString && s) noexcept {
    this->length = s.length;
    this->capacity = s.capacity;
    this->str = s.str;

    s.length = 0;
    s.capacity = 0;
    s.str = nullptr;

}

myString & myString::operator=(myString && s) noexcept {
    if(this != & s) {   // 是否自赋值
        free(this->str);
        this->length = s.length;
        this->capacity = s.capacity;
        this->str = s.str;
        s.length = 0;
        s.capacity = 0;
        s.str = nullptr;
    }

    return *this;
}


myString & myString::operator=(const myString & s) {  // 拷贝赋值运算符
    if(this != &s) {  // 检查自赋值
        int sz = s.getLength();
        if(sz < this->capacity) { // 如果原字符串容量够，那么直接拷贝
            this->length = sz;
            strcpy(this->str,s.getStr());
        } else { // 容量不够，释放掉原有内存，重新申请
            free(this->str);  // 释放掉原有的字符串
            this->length = s.getLength();
            this->capacity = s.getCapacity();
            this->str = (char * ) malloc(sizeof(char) * this->capacity);  // 按字符串大小复制
            strcpy(this->str,s.getStr());
        }
    }
    return *this;
}


myString & myString::operator=(const char * s) {  // 字符串构造
    if(s != nullptr) {
        int sz = strlen(s);
        if(sz < this->capacity) {  // 如果原字符串容量够，那么直接拷贝
            this->length = sz;
            strcpy(this->str,s);
        } else {  // 容量不够，释放掉原有内存，重新申请
            free(this->str);
            this->length = sz;
            this->capacity = sz+1;
            this->str = (char *)malloc(sizeof(char) * this->capacity);
            strcpy(this->str,s);
        }

    } else {
        this->length = 0;
        this->capacity = 15;
        this->str = (char *)malloc(sizeof(char) * this->capacity);// 默认分配一个长度为15的字符数组,初始化为空串
        this->str[0] = '\0';
    }
    return *this;
}


int myString::getLength() const
{
    return this->length;
}

int myString::getCapacity() const
{
    return this->capacity;
}

const char * myString::getStr() const  // 不允许修改 str
{
    return this->str;
}



char & myString::operator[](int i)
{
    if(i < 0 || i > this->length) {
        cout << "index out of range!" << endl;
        return this->str[this->length];     // 返回最后一个字符，也就是'\0'
    }
    return this->str[i];
}

bool myString::operator==(const myString & s)
{
    if(this->length != s.getLength()) return false;
    return strcmp(this->str,s.getStr()) == 0;
}

void myString::append(char c)
{
    int sz = 1 + this->length;
    if(sz  >= this->capacity) {  // 追加后字符大于字符数组长度
        while(this->capacity <= (sizeof(char) * sz)) this->capacity = (this->capacity + this->capacity >> 1);   // 容量变为1.5，直到大于拼接字符串的长度
        char * newStr = (char *)malloc(this->capacity);
        strcpy(newStr,this->str);
        newStr[sz] = c;
        newStr[sz+1] = '\0';
        free(this->str);
        this->str = newStr;
        this->length = sz;
    } else {
        this->str[sz] = c;
        this->str[sz+1] = '\0';
        this->length = sz;
    }

}

void myString::append(const char * s)
{
    int sz = strlen(s) + this->length;
    if(sz  >= this->capacity) {  // 追加后字符串大于字符数组长度
        while(this->capacity <= (sizeof(char) * sz)) this->capacity = (this->capacity + this->capacity / 2);   // 容量变为1.5，直到大于拼接字符串的长度
        char * newStr = (char *)malloc(this->capacity);
        strcpy(newStr,this->str);
        newStr = strcat(newStr,s);
        free(this->str);
        this->str = newStr;
        this->length = sz;
    } else {
        this->str = strcat(this->str, s);
        this->length = sz;
    }

}

myString myString::operator+(const char * s)  // 拼接字符串
{
    myString res(this->str);
    res += s;
    return res;
}

myString myString::operator+(const myString & s)  // 拼接字符串
{
    this->append(s.getStr());
    return *this;
}

myString & myString::operator+=(const char * s) // 追加字符串
{
    this->append(s);
    return *this;
}

myString & myString::operator+=(const myString & s) // 追加字符串
{
    this->append(s.getStr());
    return *this;
}

ostream & operator<<(ostream & out, myString & myStr)
{
    out << (myStr.str) ;
    return out;
}

istream & operator>>(istream & in, myString & myStr)
{
    in >> myStr.str;
    return in;
}

#include <iostream>
#include "myString.h"
using namespace std;

int main()
{
    myString str1("hello world!");
    cout << str1.getLength() << endl;
    cout << str1.getCapacity() << endl;
    cout << str1 << endl;
    str1.append(" I am Chinese!");
    cout << str1.getLength() << endl;
    cout << str1.getCapacity() << endl;
    cout << str1 << endl;
    str1.append(" 2021!");
    cout << str1.getLength() << endl;
    cout << str1.getCapacity() << endl;
    cout << str1 << endl;

    myString str2;
    str2 += "I am a dog.";
    cout << str2.getLength() << endl;
    cout << str2.getCapacity() << endl;
    cout << str2 << endl;

    cout << (str1 == str2) << endl;

    myString str3(str2);
    str3 += str1;
    cout << str3.getLength() << endl;
    cout << str3.getCapacity() << endl;
    cout << str3 << endl;

    myString str4 = str2 + str3;
    cout << str4.getLength() << endl;
    cout << str4.getCapacity() << endl;
    cout << str4 << endl;

    myString str5 = str2 + " 2021 next travel!";

    cout << str5.getLength() << endl;
    cout << str5.getCapacity() << endl;
    cout << str5 << endl;


    str5[10] = 'a';
    str5[8] = 'h';
    str5[16] = 'l';
    cout << str5.getLength() << endl;
    cout << str5.getCapacity() << endl;
    cout << str5 << endl;

    cout << endl;
    str5 = std::move(str5);
    cout << str5.getLength() << endl;
    cout << str5.getCapacity() << endl;
    cout << str5 << endl;

    cout << endl;
    myString str6 = std::move(str5);
    cout << str5.getLength() << endl;
    cout << str5.getCapacity() << endl;
    cout << str5 << endl;

    cout << str6.getLength() << endl;
    cout << str6.getCapacity() << endl;
    cout << str6 << endl;


    return 0;
}

mingxiaoshan
关注
专栏目录
手写string类
shi_xiao_xuan的博客
04-17 2384
手写string类1.题目：实现string类2.分析（1）设计类（2）构造函数（2）拷贝构造函数（3）拷贝赋值函数（4）析构函数（5）operator+（6）operator+=（7）operator==（8）operator[ ]（9）operator<<3.完整代码 1.题目：实现string类 包含构造函数、拷贝构造函数、析构函数、拷贝赋值 扩展：重载+、重载+=、重载==、重...
手写基本的String类
AIxiaoming1105的博客
05-07 432
String类是C++模板库中的一个方法类，书写其基本方法是考研C++初学者一个很经典的考题，注意细节，写的完美的话也不是那么容易的，写个博客加强一下记忆。 //基本String类方法 class String { public : String(const char* str = NULL); String(const String &other); ~String();...
【基础】【面试】手写一个String的构造函数，拷贝构造，赋值运算符
最新发布
zhangqiling
08-13 99
【代码】【基础】【面试】手写一个String的构造函数，拷贝构造，赋值运算符。
手写简单的string类
njustzj001的专栏
05-20 3366
在C++面试中关于的面向对象知识点的考察中，面试官很可能会直接让你实现一个简单的类。而是实现一个系统中已经存在的类比如String更是可能性很高，笔者就遇到了这种情况。一个简单的类包含了面向对象中的诸多细节，不失为一种很好的考察形式。除了基本的构造函数，析构函数，访问级别控制外，复制构造函数，赋值操作符，友元，异常安全性的了解与使用也是非常重要的方面。下面是我自己实现的一个简单的String类，以后有空再持续完善。
C++面试常见问题：手写String类
include的背后是微不足道的开始
11-04 346
C++面试常见问题：手写String类
C++面试题--手写String类
weixin_36299192的博客
04-02 855
这个题目是面试中很常见的，对考查C++基础知识来说非常好。 首先我们应该想到，一个类最基本的构成有构造函数，析构函数。 对于这个题目，字符串类，我们先写出它类的定义 含有指针成员变量的类：我们必须重载他的构造函数，析构函数，以及赋值函数。 class String { public : String(const char *str = NULL);//重载构造函数 String(const S...
【C++】手写String类
weixin_41646851的博客
09-22 232
手写String类 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20200921200357938.png#pic_center #include<iostream> #include<cstring> class String{ private: int m_len; char* m_data; public: const int length() const; const char* c_str() cons
手写C++ string类
weixin_45867382的博客
05-31 1235
手写的 string 类包含构造函数、拷贝构造函数、移动构造函数、拷贝赋值函数、析构函数以及重载输出操作符。
java string类的实现
01-08
用于课程设计String类的实现，上传了String类设计的发布软件，审核通过后再发布程序源代码
手写C++的String类
dongyu_1989的博客
05-14 617
class String { public: String(const char* str=NULL);//普通的构造函数 String(const String&amp; other); //拷贝构造函数 ~String(); String&amp; operate = (const String&amp; other);//复制构造 private: char* m_data;//...
手写string类-class
weixin_45794299的博客
03-08 267
class String { private: char *data; public: //可以充当默认构造函数 String(const char *p = nullptr) { if (p == nullptr) { data = nullptr; } else { data = new char[strlen(p) + 1];
【面试】手写String类
Hustle Everyday
05-09 415
类的构造函数、析构函数、拷贝构造函数、拷贝赋值运算符函数 #include<cstring> #include<cstdio> class CMyString { public: CMyString(char* pData = nullptr); CMyString(const CMyString& str); ~CMyString(v...
自己动手用C++写个String类
07-02 503
前天去一家公司面试。笔试最后一题是让我用C++自己写一个String类。这个是很经典的题目，被很多公司考过。不过我是第一次被考到。这里先写一个异常简单的，不足之处请大虾指正。 #include stdlib.h>#include string.h>#include iostream>class MyString{     friend MyString operat
自己动手写string类(一)
jifeishufan的专栏
04-17 714
前面说到了string类，为什么她就能够那么方便呢？ 其实这是有原因的，因为它的背后有很多愿意默默奉献的英雄们在大力支持~~~今天就让我们来初窥其神秘的面纱（其实也只是冰山一角）! !          我们都知道string对象可以直接进行输入，输出，赋值，相加，比较等等，其实说到底就是string类中对大量的运算符进行了重载。那什么是运算符重载呢？ 这个是C++重要的一部分内容，今天就一起来
c++ 手写string 类
qq_36743440的博客
08-20 778
类的基本函数 默认构造函数 基本构造函数 拷贝构造函数 赋值操作符 析构函数 Class Mystring { public: //Mystring(void); Mystring(const char* str = NULL); Mystring(const Mystring& str); Mystring& operator = (con...
手写string字符串
05-10
下面是一个简单的手写字符串实现，可以用来存储和操作字符串： ```c++ #include class String { public: // 构造函数 ...在实际开发中，我们通常会使用标准库提供的字符串类（如 C++ 中的 std::string）。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值