即日起在codingBlog上分享您的技术经验即可获得积分,积分可兑换现金哦。

string类的简易实现(深拷贝,浅拷贝)

编程语言 gogogo_sky 14℃ 0评论
本文目录
[隐藏]

1.一、前言

▶在c语言中我们来描述一个字符串是用const char* p=”abcdef”;然后我们也学习了许多关于字符串的操作函数。


▶那么,在学习了面向对象的c++语言之后,我们可以定义一个字符(string),这个类可以定义一个字符串对象;并且可以对该对象内存储的字符串进行各种操作;


▶接下来,我们模拟实现一个简单的string类;只需要实现★构造,★拷贝构造和★赋值运算符重载★析构函数即可;

2.二、各部分函数精讲

2.1.(1)成员变量

因为只需要保存字符串,所以写一个字符类指针指向字符串即可保存:

char* _str;

2.2.(2)构造函数

①常见错误写法

String(const char* str)//构造函数
        :_str(str)
    {

    }

分析:


这样写构造函数不对,因为传进来的str指针的值是一个常量字符串的首地址,然后把这个首地址给类中的_str这样会导致类的_str指针也指向常量字符串的首地址,那么如果用这个常量字符串再次构造一个string类对象时,就会让两个类中的指针同时指向一块空间,如果一个类先释放了空间,第二个类再次是释放时,就会释放NULL;程序出错;


▏见图(1)▏


这里写图片描述

②正确写法

String(const char* str="")//构造函数
        :_str(new char[strlen(str)+1])
    {
        strcpy(_str,str);
    }

分析:


先给_str开辟一段和常量字符串长度+1相等的空间,然后把常量字符串的内容(包含\n)拷贝到_str指向的新开辟的空间,这样,每个对象的数据成员都有属于自己的空间存放字符串,释放的时候自己释放自己空间;不会出现一块内存被多次释放造成的错误;


(▌特别说明▌,当构造对象的时候没有传参时,此时的str默认为只有一个字符的字符串”\0”空字符串;因为字符串的最后一个字符”\0”不写出来,系统默认加在后面,所以就写成”“,特别注意,不能写成默认为空,如果默认我空NULL;那么要是用这个对象来拷贝构造另一个对象时,在开辟空的时候使用strlen函数的时候,会出错,因为对空指针解引用是错误的)


▏见图(2)▏


这里写图片描述

2.3.(3)拷贝构造函数

2.4.①浅拷贝(值拷贝)

String(const String& s)//拷贝构造函数---浅拷贝(值拷贝)
    {
        _str=s._str;
    }

分析:


▌在没有引用计数时这样写拷贝构造函数不对▌▶因为这样是把一个对象的_str的地址赋给的另一个对象的_str;这样会出现两个类的_str指向同一块常量的内存空间;这样会出现两个错误


★当一个类对自己的字符串进行操作时,就算另一个类什么也没做,他的字符串也会被改变;


★当释放一个对象的_str所指向的空间之后,根据析构函数的写法,释放另一个类的对象的_str的时候,此时这个类的_str不为空,值为常量字符串的地址,但是进去释放的时候,这块空间已经被前一个类的析构函数释放了,这样就会一块内存被两次释放,出现错误;


▏见图(3)▏


这里写图片描述

2.5.②深拷贝

String(const String& s)//拷贝构造函数---深拷贝
        :_str(new char[strlen(s._str)+1])
    {
        strcpy(_str,s._str);
    }

分析:


为了解决浅拷贝的不足,那我们就用身拷贝;所谓深拷贝,就是说,每次用对象str1构造对象str2的时候;我们不是只把str1的_str给str2的_str,而是给str2重新开辟一段大小相等的空间;然后,把str1的_str里面的内容拷贝到str2的_str中去,这样每个类的对象的数据成员都有自己空间存放字符串;自己释放自己的空间;不争不抢;


▏见图(4)▏


这里写图片描述

2.6.(4)赋值运算符重载

①常规写法

String&  operator=(const String& s)//赋值运算符重载
    {
        if (this!=&s)
        {
            delete[] _str;
            _str=new char[strlen(s._str)+1];
            strcpy(_str,s._str);
        }

    }

分析:


赋值运算符的重载,是拿一个对象赋值给另一个对象;比如说str3=str2;就是将str2赋值给str3;


首先;我们先要判断是不是对象自己给自己赋值,如果是自己给自己赋值,直接返回对象自己;为什么要判断呢?因为如果不判断遇到这种情况str3=str3就会出错;如果说自己给自己赋值,那么delete[] _str后,对象的数据成员所对应的空间已经被释放而且_str=NULL;这时候在进行下一步开辟空间时_str=new char[strlen(s._str)+1];因为此时 s._str=NULL;用空指针左strlen的参数时,会报错;


然后,如果不是自己给自己赋值,那么就是两个不同的对象赋值;然后开辟空间,拷贝字符串,返回对象;


▏见图(5)▏


这里写图片描述

②现代写法:

String& operator=(String s)//赋值运算符重载---现代写法
    {
        std::swap(_str,str._str);
        return *this;
    }

分析:


首先,现代写法的赋值运算符重载函数形参不能带引用;因为引用的含义是一个变量的别名,这个别名和原对象指的同一块内存;如果将对象以引用的方式接收,那么在函数内部进行std::swap(_str,str._str)操作时;虽然这个时候,要赋值的对象的_str确实指向了字符串的空间,但是这个时候,用来赋值的对象的内容却改变了;变为了要赋值的对象里面的内容;这样做没有达到赋值操作的目的;

当我们用值传递的方式传进来参数时;这时,这个用来赋值的对象会调用类的拷贝构造函数,重新构造一个临时对象s;这个对象因为是调用拷贝构造函数得来的;所以里面也会有一个_str,这个_str也会有自己的空间,存放字符串;当进std::swap(_str,str._str)操作时,swap会将两个指针的值进行交换;这两个指针的值就是各自指向的字符串内存的首地址;当赋值函数调用完成的时候,因为s是一个临时变量;所以在出函数的时候,临时变量String类的对象s会调用String类的析构函数将自己的数据成员指向的内存释放(其实就是被赋值的对象原始的空间),并将自己的_str置空(避免成为野指针);

★个人觉得现代写法的赋值运算符重载函数就想一个强盗,把别人的东西拿来自己用,还把自己不好的东西让别人丢掉;最后在让这个人消失★


▏见图(6)▏


这里写图片描述

2.7.(5)析构函数

    ~String()
    {
       if (NULL!=_str)
       {
           delete[] _str;
           _str=NULL;
       }
    }

分析:略

三、代码实现

#pragma once
#include
using namespace std;
#include

class String
{
    friend ostream& operator<<(ostream& os,String& s);
public:
    String(const char* str="")//构造函数
        :_str(new char[strlen(str)+1])//strlen统计字符串字符个数(不包括"\0")
    {
        strcpy(_str,str);//strcpy从字符串第一个字符开始,一直到"\0"结束(包括"\0")
    }
    String(const String& s)//拷贝构造---深拷贝
        :_str(new char[strlen(s._str)+1])
    {
        strcpy(_str,s._str);
    }
    String& operator=(const String& s)//赋值操作符重载---常规写法
    {
        if (this!=&s)
        {
            delete[] _str;
            _str=new char[strlen(s._str)+1];
            strcpy(_str,s._str);
        }

        return *this;
    }

    /*
    String& operator=(String s)//赋值操作符重载---现代写法
    {
        std::swap(_str,s._str);
        return *this;
    }*/

    ~String()
    {
        if (NULL!=_str)
        {
            delete[] _str;
            _str=NULL;
        }
    }
public:
    char* _str;
};
//因为模拟实现的string不是内置类型,所以要重载输出运算符,才能输出String类对象的内容
ostream& operator<<(ostream& os,String& s)
{
      os<return os;
}

测试代码:

void Test()
{ 
     String s1("abcdef");
     String s2("ABCDEF");
     String s3(s1);
     String s4;
     s4=s1;
     cout<<"s1->"<"s2->"<"s3->"<"s4->"<

四、运行结果


这里写图片描述

后面会写到引用计数器的写时拷贝的实现;

O(∩_∩)O

转载请注明:CodingBlog » string类的简易实现(深拷贝,浅拷贝)

喜欢 (0)or分享 (0)
发表我的评论
取消评论

*

表情