【C++】使用类来模拟string

已于 2022-10-26 10:40:24 修改
阅读量424 收藏 1
点赞数 1
分类专栏： C++深入学习 文章标签： c++ 开发语言 java
于 2022-10-25 23:32:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52958292/article/details/127524012
版权

文章目录

第一步：构建简单的构造函数和析构函数

class String
{
private:
    char* str;
public:
    String(char* p, int)
    {
        str = p;
    }
    //构造函数
    String(const char* p = NULL) :str(NULL)
    {
        if (p != NULL)//要传的字符串不为空
        {
            //申请堆空间
            str = new char[strlen(p) + 1];
            strcpy_s(str, strlen(p) + 1, p);
        }
        else
        {
            str = new char[1];
            *str = '\0';
        }
        cout << "Create String:" << this << endl;
    }
     //析构函数
    ~String()
    {
        if (str != NULL)
        {
            delete[]str;
        }
        str = NULL;
        cout << "Destory String" << this << endl;
    }
};

1.1 模拟输出（operator<<）

避免友元函数，需要在类外写一个输出函数

   ostream& operator<<(ostream& out)const
    {  //this->str
        if (str != NULL)
        {
            out << str;   
        }
        return out;
    }

为了避免使用友元：在类外在定义再写一个输出函数：

ostream& operator<<(ostream& out,const String &s)
{                            //类外没有this指针，需要在定义一个对象s
        s << out;  //<<调用类中的 s.operator<<() 
        return out;
  
}


int main()
{
   String s{ "baiU" };
   cout << s << endl;//直接调用输出运算符，输出对象
}

请添加图片描述

1.2 拷贝构造函数

String(const String& s)
    {
        //避免浅拷贝
        str = new char[strlen(s.str) + 1];;
        strcpy_s(str, strlen(s.str) + 1, s.str);
        cout << "copy String" << this << endl;
    }

int main()
{
   String s{ "baiU" };
   String s1(s);
}

请添加图片描述

1.3 赋值运算符重载

String& operator = (const String& s)
    {
        if (this != &s)
        {
            delete[]str;
            str = new char[strlen(s.str) + 1];
            strcpy_s(str, strlen(s.str) + 1, s.str);
        }
        cout << "operator =" << this << endl;
        return *this;
    }

注意点：防止自赋值，防止内存泄漏，防止浅拷贝

int main()
{
   String s{ "baiU" };
   String s1(s);
   String s2{"shiqianyu"};
   s2 = s;
}

请添加图片描述

1.4 加法运算符重载

因为返回时要构造一个对象，需要在重载一个构造函数，作为私有成员。

 String(char* p, int)//int 占位符
    {
        str = p;
    }

1.4.1对象和对象相加

 String operator+(const String& s)
    {
        int len = strlen(str) + strlen(s.str) + 1;
        char* p = new char[len];
        strcpy_s(p, len, str);
        strcat_s(p,len,s.str);
        cout << "Object+object" << endl;
        return String(p, 1);
    }

1.4.2字符串和对象相加

String operator+(const char* p, const String& s)
{
    cout << "char* + Object" << endl;
    return String(p) + s;
}

int main()
{
   String s{ "baiU" };
   String s2{"shiqianyu"};
    s = s + s2;
  //  s2 = "love" + s2;
    String s3;
    s3 = fun();
    return 0;
}

请添加图片描述

1.5 移动构造函数

String(String&&s)
    {
        cout << "move construct:" << this<<endl;
        str = s.str;
        s.str = NULL;
    }

1.6 移动赋值运算符重载在整个程序执行的过程中，只对堆内存空间new了一次，

String fun()
{
    String s2("yangyu");
    return s2;
}
```cpp
  int main()
{
    String s1;  //调用默认构造申请对象空间
    s1 = fun();
    return 0;
}
  1. String s1;

调用构造函数申请对象空间
请添加图片描述
2. String s2{yangyu}; 调用构造函数，申请空间，创建对象，并对对象进行初始化。
请添加图片描述
3. return s2
调用移动构造函数，创建将亡值对象，并让将亡值对象指向s2.（str = s.str;）。并把s2中str置为空（s.str = NULL;)
请添加图片描述
4. 析构s2
请添加图片描述
5. s1 = fun() 调用Release()完成数据交换。 s.str = Release(s.str);·请添加图片描述

重点：

  1. 首先s2调用构造函数完成对str的初始化，也就是s2指向为字符串“baiU”开辟的堆空间。
  2. return s2时，返回调用点处（调用的是移动构造函数）创建将亡值对象，指向 s2申请的空间，
  3. s2析构。
  4. 将亡值移动赋值给s1过程。

请添加图片描述

char* Release(char* p)
    {
        char* old = str;
        str = p;
        return old;
    }

重点：

Release()函数实现了资源的交换，让s1指向s2申请的空间，将亡值指向s1申请的空间，函数结束。将亡值值被析构，s1成功拿到了原s2的资源，

    //优先调用
    String& operator = (String&&s)
    {
        if (this != &s)
        {
            s.str = Release(s.str); //将str = s.str 并将str原本的值释放掉。
        }
        cout << "operator =&&" << this << endl;
        return *this;
    }

完整代码：

class String
{
private:
    char* str;
public:
    String(char* p, int)
    {
        str = p;
    }
    //构造函数
    String(const char* p = NULL) :str(NULL)
    {
        if (p != NULL)//要传的字符串不为空
        {
            //申请堆空间
            str = new char[strlen(p) + 1];
            strcpy_s(str, strlen(p) + 1, p);
        }
        else
        {
            str = new char[1];
            *str = '\0';
        }
        cout << "Create String:" << this << endl;
    }
    //拷贝构造函数
    String(const String& s)
    {
        //避免浅拷贝
        str = new char[strlen(s.str) + 1];;
        strcpy_s(str, strlen(s.str) + 1, s.str);
        cout << "copy String" << this << endl;
    }
    //移动构造函数
    String(String&&s)
    {
        cout << "move construct:" << this<<endl;
        str = s.str;
        s.str = NULL;
    }

    //析构函数
    ~String()
    {
        if (str != NULL)
        {
            delete[]str;
        }
        str = NULL;
        cout << "Destory String" << this << endl;
    }
    //避免友元函数，需要在类外写一个输出函数
    ostream& operator<<(ostream& out)const
    {  //this->str
        if (str != NULL)
        {
            out << str;   
        }
        return out;
    }
    //赋值运算符重载
    String& operator = (const String& s)
    {
        if (this != &s)
        {
            delete[]str;
            str = new char[strlen(s.str) + 1];
            strcpy_s(str, strlen(s.str) + 1, s.str);
        }
        cout << "operator =" << this << endl;
        return *this;
    }
    char* Release(char* p)
    {
        char* old = str;
        str = p;
        return old;
    }
    //优先调用
    String& operator = (String&&s)
    {
        if (this != &s)
        {
            s.str = Release(s.str); //将str = s.str 并将str原本的值释放掉。
        }
        cout << "operator =&&" << this << endl;
        return *this;
    }
    //加法运算符重载
    //对象和对象相加

    String operator+(const String& s)
    {
        int len = strlen(str) + strlen(s.str) + 1;
        char* p = new char[len];
        strcpy_s(p, len, str);
        strcat_s(p,len,s.str);
        cout << "Object+object" << endl;
        return String(p, 1);
    }
   
    
};
String fun()
{
    String s2("yangyu");
    return s2;
}

ostream& operator<<(ostream& out,const String &s)
{                            //类外没有this指针，需要在定义一个对象s
        s << out;  //<<调用类中的 s.operator<<() 
        return out;
  
}
String operator+(const char* p, const String& s)
{
    cout << "char* + Object" << endl;
    return String(p) + s;
}
int main()
{
   // String s{ "baiU" };
   // cout << s << endl;//直接调用输出运算符，输出对象s
   // String s1(s);
   // String s2{"shiqianyu"};
   // s2 = s;
    s = s + s2;
  //  s2 = "love" + s2;
    String s3;
    s3 = fun();
    return 0;
}
白糖熊
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++初级--string的用法
qq_53413129的博客
03-02 573
1.string类简介 2.String类的常用接口说明 string类对象的常见构造 string类的容量操作 string的访问及遍历 string类对象的修改操作 string类对象的扩容 reserve和resize的区别 c_str string类的增删查改 查 插入和删除
C++中string类的模拟实现
02-23
该资源中模拟实现了C++中string类的一些常用接口，包括resize、reserve、insert、erase等等，重载了流插入和流提取操作符以实现对string类对象的输出和输入。其中还关注了深拷贝的问题（由于string类中涉及内存资源...
C++：使用类来模拟 string（方法一）
Sauron7i的博客
03-09 326
使用类 模拟 string 实现运算符重载 将亡值 实现移动构造 实现移动赋值
C++ string functions
toby's fanatic zone
07-05 1146
C++ string functions（Ｃ＋＋里面比较常用的ＳＴＲＩＮＧ函数） strings may be manipulated without using the　sta
C++之const std::string& s（传参时 const string& 相对 const string 的优势）
热门推荐
qq_34706266的博客
03-14 2万+
class DepthViewer : public OpencvViewer { public: DepthViewer(const std::string&amp; win); virtual void show(const cv::Mat&amp; depthImage); virtual void onMouseCallback(cv::Mat&amp; img, ...
深入了解C++的string，这一篇就够了
零碎@流年絮语 的博客
03-22 281
1.简介： string是C++标准库的一个重要的部分，主要用于字符串处理，在使用时，务必添加头文件  。 2.string常用函数： （1）构造函数： 生成一个空字符串str： string str; 拷贝构造函数,生成str的复制品： string s(str); 将字符串str中从下标strbegin开始、长度为strlen的部分作为字符串初值： string s(str, st...
C++中string的模拟实现
09-01
在 C++ 的标准库中，`std::string` 提供了 `push_back()` 成员函数来实现这个功能，但在我们的模拟实现中，我们需要自己创建这个功能： ```cpp void String::Push_Back(char c) { if (_sz == _capacity) { // 如果...
C++手动模拟String底层与深浅拷贝
最新发布
06-05
超全的思维导图
详解C++中String类模拟实现以及深拷贝浅拷贝
12-31
字符串是一个应用很广泛的类型，也是很基础的类型，C语言并没有直接处理字符串的操作而是采用字符指针和字符串数组进行操作，而在C++中标准库为我们封装了一个字符串的类供我们使用，使用需要#inlcude <string>...
STL库string类的模拟实现
02-28
4. string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_traits 和allocator作为basic_string的默认参数(根于更多的模板信息请参考basic_string)。 5. 注意，这个类独立于所...
自己模拟写C++中的String类型实例讲解
08-29
但是，在这里，我们将模拟实现一个自己的String类型，来展示C++中类的设计和实现。 构造函数 在我们的String类型中，我们定义了多个构造函数，包括： * 默认构造函数`String()`：用于创建一个空的字符串对象 * ...
使用C++的string实现高精度加法运算的实例代码
12-31
本文讨论借助C++的string来实现高精度的运算。 首先输入的量直接存储为string，设为s1和s2。 接下来设计一个反转函数，用于把整个字符串反转（为了方便后续计算）。 string reverseStr(string input){ string ...
STL中string类模拟实现源码
08-06
内容简介，涵盖内容广泛。源码实现参照STL源码。
C++中的模拟class string类的代码 cpp
08-02
//一个C++初学者的string类，恳请朋友们多多指点 //特殊功能：- 取负数运算符代表将字符串翻转 函数头： class string{ friend int len(string &); friend const string & operator+(const string &s1,const ...
C++模拟键盘输入
05-20
以下是一个简单的C++类`SimulateInputString`的实现，它封装了`SendInput`函数来模拟键盘输入字符串： ```cpp #include "SimulateInputString.h" class SimulateInputString { public: void sendString(const std...
String类
海月的博客
02-23 585
描述 实现以下String类并测试这个类。 class String { private: char * s; public: String(); String(const char *); String(const String &); ~String(); String & operator=(const char *); String ...
C++实现String类
gfgdsg的专栏
07-22 362
#include #include #include using namespace std; class String { private: char *str; int len; static int num_strings; public: String(); String(const char *s); String(const String &); ~String();
for(string& str: strs)和for(string str: strs)遍历容器
m0_57449361的博客
04-27 1593
这里的strs定义为：vector<string> strs;直接看例子，该例子来源于力扣49官方题解。
c++简单String类实现
weixin_30553837的博客
05-23 42
#include <iostream> #include <string> using namespace std; class String { public: String(const char* str = NULL);//通用构造函数,String("abc") String(const String &str);...
c++string类的模拟实现
04-20
好的，我可以回答这个问题。C++中的string类是一个动态数组，其中包含了一些操作字符串的方法，例如查找、替换、截取等等。为了模拟实现这个类，您需要创建一个动态数组来存储字符串，同时实现一些方法来操作它。比如说，您可以创建一个构造函数来初始化字符串，实现一个拼接方法来将两个字符串合并，还可以实现一个查找方法来搜索字符串中的特定字符或子串。这些都是模拟实现string类的基本步骤。希望这个回答对您有所帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值