string

已于 2023-04-12 16:52:24 修改
阅读量90 收藏
点赞数
分类专栏： C++ 文章标签： c++
于 2023-03-23 12:03:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44041312/article/details/129728072
版权

浅拷贝与深拷贝

浅拷贝的string类

写string类的时候，不写拷贝构造，系统生成的就是浅拷贝（值拷贝）

测试

结果

 原因如下

浅拷贝只进行值拷贝，导致s2跟s1指向同一块内存。当s1使用完执行析构时，那块内存将被释放第一遍。s2再使用时，就会出错。

深拷贝及数种写法

深拷贝实现了如图的效果，各自独立使用不同的内存，不会出现在浅拷贝遇到的问题。

 1.传统写法。

初始化列表开辟空间，利用cpy复制

	class string
	{
	public:
		string(const char* str = "")
		{
			if (nullptr == str)
			{
				assert(false);
				return;
			}
			_str = new char[strlen(str) + 1];
			strcpy(_str, str);
		}
	
		string& operator=(const string& s)
		{
			if (this != &s)
			{
				char* pStr = new char[strlen(s._str) + 1];
				strcpy(pStr, s._str);
				delete[] _str;
				_str = pStr;
			}
			return *this;
		}

///传统拷贝//
		string(const string& s)
			:_str(new char[strlen(s._str)+1])
		{
			strcpy(_str, s._str);
		}


///分割线//
		~string()
		{
			if (_str)
			{
				delete[] _str;
				_str = nullptr;
			}
		}

		const char* c_str() const
		{
			return _str;
		}

		size_t size()const
		{
			return _size;
		}
	private:
		char* _str;
		size_t _capacity;
		size_t _size;
	};
}

赋值操作符

跟拷贝构造类似

模拟实现

#include "5.string.h"
#include <assert.h>
namespace bit

{

    class string

    {

        friend ostream& operator<<(ostream& _cout, const bit::string& s)
        {

        }

        friend istream& operator>>(istream& _cin, bit::string& s)
        {

        }

    public:

        typedef char* iterator;

    public:

        string(const char* str = "")
        {
            if (str == nullptr)
            {
                assert(false);
                return;
            }
            _str = new char[strlen(str) + 1];
            strcpy(_str, str);
        }

        //两种写法：1.就相当于再写个传参构造
        //string(const string& s)
        //{
        //    //同样先开辟空间
        //    _str = new char[s.size() + 1];
        //    //同样直接复制
        //    strcpy(_str, s._str);

        //}
        //2.先传参构造，再交换
        string(const string& s)
            :_str(nullptr), _size(0), _capacity(0)
        {
            string tmp(s._str);
            this->swap(tmp);
        }

        string& operator=(const string& s)
        {
            if (this != &s)

            {

                string temp(s);

                this->swap(temp);

            }

            return *this;
        }

        ~string()
        {
            delete[] _str;
            _str = nullptr;
            _size = _capacity = 0;
        }



        //

        // iterator

        iterator begin()

        {

            return _str;

        }

        iterator end()

        {

            return _str + _size;

        }



            /

            // modify

        void push_back(char c) {

            if (_size == _capacity)
                reserve(_capacity * 2);

            _str[_size++] = c;

            _str[_size] = '\0';


        }

        string& operator+=(char c)
        {
            push_back(c);

            return *this;
        }

        void append(const char* str)
        {

        }

        string& operator+=(const char* str);

        void clear()
        {
            _size = 0;
            _str[_size] = '\0';
        }

        void swap(string& s)
        {
            std::swap(_str, s._str);

            std::swap(_size, s._size);

            std::swap(_capacity, s._capacity);
        }

        const char* c_str()const
        {
            return _str;
        }



        /

        // capacity

        size_t size()const

        {

            return _size;

        }

        size_t capacity()const

        {

            return _capacity;

        }

        bool empty()const

        {

            return _size == 0;

        }
        void resize(size_t newSize, char c = '\0')

        {

            if (newSize > _size)

            {

                // 如果newSize大于底层空间大小，则需要重新开辟空间

                if (newSize > _capacity)

                {

                    reserve(newSize);

                }

                memset(_str + _size, c, newSize - _size);

            }

            _size = newSize;

            _str[newSize] = '\0';

        }
        void reserve(size_t newCapacity)

        {

            // 如果新容量大于旧容量，则开辟空间

            if (newCapacity > _capacity)

            {

                char* str = new char[newCapacity + 1];

                strcpy(str, _str);

                // 释放原来旧空间,然后使用新空间

                delete[] _str;

                _str = str;

                _capacity = newCapacity;

            }

        }



        /

        // access

    // access

        char& operator[](size_t index)

        {

            assert(index < _size);

            return _str[index];

        }

        const char& operator[](size_t index)const

        {

            assert(index < _size);

            return _str[index];

        }


        /

        //relational operators

        bool operator<(const string& s)const

        {

            int res = strcmp(_str, s._str);

            if (res < 0)

                return true;

            return false;

        }

        bool operator<=(const string& s)const

        {

            return !(*this > s);

        }
        bool operator>(const string& s)const

        {

            int res = strcmp(_str, s._str);

            if (res > 0)

                return true;

            return false;

        }

        bool operator>=(const string& s)const

        {

            return !(*this < s);

        }

        bool operator==(const string& s)const

        {

            int res = strcmp(_str, s._str);

            if (res == 0)

                return true;

            return false;

        }

        bool operator!=(const string& s)const

        {

            return !(*this == s);

        }


        // 返回c在string中第一次出现的位置
        size_t find(char c, size_t pos = 0) const

        {

            for (size_t i = pos; i < _size; ++i)

            {

                if (_str[i] == c)

                    return i;//找到，返回下标

            }

            return -1;//未找到

        }

        // 返回子串s在string中第一次出现的位置
        size_t find(const char* s, size_t pos = 0) const

        {

            assert(s);

            assert(pos < _size);



            const char* src = _str + pos;

            while (*src)

            {

                const char* match = s;//如果不匹配，返回子串起始处重新查找

                const char* cur = src;

                while (*match && *match == *cur)//结束条件

                {

                    ++match;

                    ++cur;

                }

                if (*match == '\0')//找到子串

                {

                    return src - _str;//返回下标

                }

                else

                {

                    ++src;

                }

            }

            return -1;//未找到

        }

        // 在pos位置上插入字符c/字符串str，并返回该字符的位置

        string& insert(size_t pos, char c)

        {

            assert(pos <= _size);

            if (_size > _capacity)

            {

                //扩容

                char* newstr = new char[_capacity * 2 + 1];//开空间

                strcpy(newstr, _str);

                delete[] _str;

                _str = newstr;

                _capacity *= 2;



                //Expand(_capacity * 2);

            }
            //size 9,10 capa 11  pos 5
            //移数据



            for (int i = _size; i >= (int)pos; --i)

            {

                _str[i + 1] = _str[i];

            }


            _str[pos] = c;

            _size++;

            return *this;

        }

        string& insert(size_t pos, const char* str)

        {

            size_t len = strlen(str);

            if (_size + len > _capacity)//扩容

            {

                //扩容

                char* newstr = new char[_capacity * 2 + 1];//开空间

                strcpy(newstr, _str);

                delete[] _str;

                _str = newstr;

                _capacity *= 2;

                //Expand(_size + len);

            }

            //后移数据

            for (int i = _size; i >= (int)pos; --i)

            {

                _str[len + i] = _str[i];

            }

            //拷贝字符串

            while (*str != '\0')

            {

                _str[pos++] = *str++;

            }

            _size += len;

            return *this;

        }

        // 删除pos位置上的元素，并返回该元素的下一个位置

        string& erase(size_t pos, size_t len)

        {

            assert(pos < _size);

            if (pos + len >= _size)//pos位置之后全为0

            {

                _str[pos] = '\0';

                _size = pos;

            }

            else

            {

                strcpy(_str + pos, _str + pos + len);

                _size -= len;

            }

            return *this;

        }

    private:

        char* _str;

        size_t _capacity;

        size_t _size;

    };

}

istream& bit::operator>>(istream& _cin, bit::string& s)

{

    //预分配100个空间

    char* str = (char*)malloc(sizeof(char) * 100);

    char* buf = str;

    int i = 1;

    //预处理：跳过流里面的所有空格和回车

    while ((*buf = getchar()) == ' ' || (*buf == '\n'));



    for (; ; ++i)

    {

        if (*buf == '\n') //回车跳出

        {

            *buf = '\0';

            break;

        }

        else if (*buf == ' ') //空格跳出

        {

            *buf = '\0';

            break;

        }

        else if (i % 100 == 0) //空间不足

        {

            i += 100; //追加100个空间

            str = (char*)realloc(str, i);

        }

        else  //每次getchar()一个值

        {

            buf = (str + i);//为了避免realloc返回首地址改变，不使用++buf，而是用str加上偏移.

            //每次读取一个字符

            *buf = getchar();

        }

    }

    //输入完成,更新s

    s._str = str;

    s._capacity = s._size = i;



    return _cin;

}

//输出流重载

ostream& bit::operator<<(ostream& _cout, const bit::string& s)

{

    for (size_t i = 0; i < s.size(); ++i)

    {

        _cout << s[i];

    }

    return _cout;

}

Anony_m0us
关注
专栏目录
String实例
10-24
最后，为了方便与其他类型的对象进行转换，我们可以提供`toStdString()`（返回std::string）和`fromStdString(const std::string&)`（从std::string创建String）函数： ```cpp std::string toStdString() const { ...
Android String
01-09
在Android开发中，`String`类是用于处理文本数据的核心组件。它不仅在用户界面（UI）中扮演着重要角色，如通过`TextView`呈现文本，还在应用的各个层面上广泛使用，包括资源管理、国际化（i18n）以及数据存储等。...
String.txt
07-15
String a="abc";//创建字符串方式1 String b =new String("abc"); //创建字符串方式2 System.out.println(a==b); //false，内存地址不相等 String c =new String("abc"); String d =new String...
Python string.html
02-05
Python string类型，字符串转化成整数，转化成浮点数，了解常见的转义字符，什么是切片?如何使用切片截取字符串，做好小练习
自定义String类
10-31
在C++编程中，`String`类是一种常用的用于表示和操作字符串的数据结构。虽然C++标准库中已经提供了`std::string`类，但为了学习和理解对象导向编程（OOP）以及C++的特性，有时我们会选择自定义一个`String`类。在这...
C++与QML的数据交互
qq_50679120的博客
09-11 465
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
【C++】CLion配置cout打印语句快捷键
qq_38196449的博客
09-10 238
当我们sout时，自动出现打印语句。点击Apply 和 OK 保存。
C语言从头学59——学习头文件math.h（二）
m0_72128260的博客
09-11 434
继续学习头文件的数学函数。
＜C++＞ set、map模拟实现
prodigy623的博客
09-10 873
set、map仿STL模拟实现
C++位图的实现与详解
2301_80468112的博客
09-09 662
在讲解位图之前我们先来看一道很经典的面试题。给40亿个不重复的无符号整数，没排过序。给一个无符号整数，如何快速判断一个数是否在这40亿个数中。我们有以下两种种解决方法：1. 遍历，时间复杂度O(N)。（太慢）2. 排序(O(NlogN))，利用二分查找: logN。深入分析:解题思路2是否可行，我们先算算40亿个数据大概需要多少内存。
【C++ && Qt day11】
wzj46的博客
09-11 255
2、头文件窗口文件。
C++ Qt开发：运用QJSON模块解析数据
qq_35662333的博客
09-11 1022
转载Qt 是一个跨平台C++图形界面开发库，利用Qt可以快速开发跨平台窗体应用程序，在Qt中我们可以通过拖拽的方式将不同组件放到指定的位置，实现图形化开发极大的方便了开发效率，本章将重点介绍如何运用QJson组件的实现对JSON文本的灵活解析功能。JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，它易于人阅读和编写，也易于机器解析和生成。该格式是基于JavaScript语言的一个子集，但它是一种独立于语言的数据格式，因此可以在许多不同的编程语言中使用。
C++ lambda闭包消除类成员变量
随手写下笔记和感悟
09-11 435
消除了——通过将它们闭包到lambda表达式中，然后将这个lambda存起来重复使用。如果用引用捕获，栈变量会释放导致非法访存；可以借助函数式编程思想，来消除一些不必要的类成员变量。拿到一个类，一看成员变量好几十个，就问你怕不怕？在面向对象编程时，常常要添加类成员变量。然而类成员一旦多了之后，也会带来干扰。就无法修改值捕获的变量。
C++（二）----类和对象
weixin_73579966的博客
09-11 771
众所周知，C++与C语言不同的地方就是，C++引入了类和对象，可以在兼容C语言的同时面向对象编程，同时具备了封装、继承、多态三种特点（划重点）。面向对象可以说是C++最重要的部分了，而类和对象就是面向对象的基础，所以这一节我们学习类和对象。
设计一个支持多线程写入的并发日志记录系统：C++实战指南
windowshht的博客
09-11 549
并发日志记录系统是一种能够在多线程环境中安全、高效地记录日志的系统。它需要解决多个线程同时写入日志时的数据竞争问题，确保日志的顺序和完整性。并发日志记录系统是多线程编程中的重要组成部分，通过合理使用互斥锁，可以有效地解决多线程写入日志时的数据竞争问题。本文详细介绍了如何在C++中设计一个支持多线程写入的并发日志记录系统，并提供了完整的代码示例和详细的解释。希望这篇文章能帮助你更好地理解和掌握并发日志记录技术。如果你有任何问题或需要进一步的解释，欢迎在评论区留言。祝你在多线程编程的学习和实践中取得好成绩！
C++·io流
atlanteep的博客
09-11 1011
本节内容简单，主要讲述了3种io流的用法
C语言：刷题日志(1)
zm3rttqs9f的博客
09-07 1406
阶乘计算升级版 然后是几点 求整数段和 爬动的蠕虫 龟兔赛跑
C++之数据类型
QoQ_____________的博客
09-09 439
/宏常量define（注意书写格式）//双精度：double。求数据类型所占空间大小，字节数。//const修饰变量。//单精度：float。
C++速通LeetCode简单第11题-对称二叉树
最新发布
weixin_47768406的博客
09-14 145
递归
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值