【C++初阶】string类

【C++初阶】string类

🥕个人主页:开敲🍉

🔥所属专栏:C++🥭

🌼文章目录🌼

1. 为什么学习string类?

    1.1 C语言中的字符串

    1.2 实际中

2. 标准库中的string类

    2.1 string类

    2.2 auto和范围for

    2.3 string类常用接口说明

3. string类的模拟实现

    3.1 经典的string类问题

        3.1.1 浅拷贝

       3.2.2 深拷贝

    3.2 string类模拟实现

1. 为什么学习string类?
    1.1 C语言中的字符串

  C语言中,字符串是以'\0'结尾的一些字符的集合,为了操作方便,C标准库中提供了一些str系列
的库函数,但是这些库函数与字符串是分离开的,不太符合OOP的思想,而且底层空间需要用户
自己管理,稍不留神可能还会越界访问。

    1.2 实际中

  在我们日常的刷题中,有关字符串的题目基本上是以string的形式出现的,并且在日常的生活当中,为了简单、方便快捷,基本上也都是使用的string,很少有人使用C标准库中的字符串操作函数。

2. 标准库中的string类
    2.1 string类

  string - C++ Reference (cplusplus.com)

  这里面有关于string类的详细说明,包括它的每个接口的功能以及接口的使用环境等。其中比较重要的接口有:operator=、iterators有关的begin、end的所有接口(自己实现时子需要实现begin、end即可,后面的rbegin和rend等理解即可)、size、resize、capacity、reserve、clear、empty、operator[]、operator+=、append、push_back、insert、erase、swap、c_str、find、find_first_of

    2.2 auto和范围for

auto关键字:

  在这里补充两个C++11的小语法,方便我们后面的学习

  ① 在早期C/C++中auto的含义是:使用auto修饰的变量,是具有自动存储器的局部变量,后来这个不重要了。C++11中,标准委员会变废为宝赋予了auto全新的含义即:auto不再是一个存储类型
指示符,而是作为一个新的类型指示符来指示编译器,auto声明的变量必须由编译器在编译时期
推导而得,
也就是说,auto能够自动识别对象的类型

   用auto声明指针类型时,用auto和auto*没有任何区别,但用auto声明引用类型时则必须加&

   当在同一行声明多个变量时,这些变量必须是相同的类型,否则编译器将会报错,因为编译器实际只对第一个类型进行推导,然后用推导出来的类型定义其他变量。

  auto不能作为函数的参数,可以作为返回值,但是建议谨慎使用

  auto不能直接用来声明数组

  看到这里你可能觉得auto没什么作用,我知道我想要的是什么类型的我为什么还要它自动识别。别着急,后面你就会明白auto是有多好用。

范围for:

   对于一个有范围的集合而言,由程序员来说明循环的范围是多余的,有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ :”分为两部分:第一部分是范围内用于迭代的变量,第二部分则表示被迭代的范围,自动迭代,自动取数据,自动判断结束。

for(auto+变量 : 迭代范围)

{

        //循环体
}

  ② 范围for可以作用到数组和容器对象上进行遍历

  范围for看似非常智能很厉害,实际上底层就是迭代器(迭代器是什么后面会讲,此处记住即可)

    2.3 string类常用接口说明

1. string的常见构造函数:

2. string类对象的容量(Capacity)操作:

size(重点):返回字符串有效字符长度

length:返回字符串有效字符长度

capacity:返回所开空间总大小

empty(重点):检查字符串是否为空

clear(重点):仅删除数据,而不销毁空间

reserve(重点):为字符串预留一块空间,可以数据量小时可以省去开辟空间的消耗

rsize(重点):将有效的字符减为n(自己传)个,如果是增加,则多加的字符改为c(自己传)

注:

   size()与length()方法底层实现原理完全相同,引入size()的原因是为了与其他容器的接
口保持一致,一般情况下基本都是用size()。

   clear()只是将string中有效字符清空,不改变底层空间大小。

   resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个,不
同的是当字符个数增多时:resize(n)用0来填充多出的元素空间,resize(size_t n, char
c)用字符c来填充多出的元素空间。注意:resize在改变元素个数时,如果是将元素个数
增多,可能会改变底层容量的大小,如果是将元素个数减少,底层空间总大小不变。

  ④ reserve(size_t res_arg=0):为string预留空间,不改变有效元素个数,当reserve的参
数小于string的底层空间总大小时,reserver不会改变容量大小(Linux环境下会改变,但不会影响数据的存储)。

3. string类对象的访问及遍历操作:

operator[](重点):返回pos位置字符的引用(方便修改),const string类调用

begin+end(重点):begin获取字符串开头第一个字符的迭代器+end获取最后一个字符下一个位置的迭代器

//后面还有rbegin+rend、crbegin+crend、cbegin+cend等迭代器,这里不一一赘述

4. string类对象的修改操作:

push_back(重点):在字符串后尾插一个字符

append(重点):在字符串后尾插一个字符串

operator+=(重点):重载+=运算符,可以完成尾插操作

c_str(重点):返回字符串地址

find+npos(重点):从字符串pos位置开始往后查找所要字符,并返回其所在位置。如果遍历完字符串也找不到,则返回npos

rfind:从字符串pos位置开始往前查找所要字符,并返回其所在位置。如果找不到,则返回npos

substr:从字符串pos位置开始截取n个字符并返回

注:

  ① 在string尾部追加字符时,s.push_back(c) / s.append(1, c) / s += 'c'三种的实现方式差
不多,一般情况下string类的+=操作用的比较多,+=操作不仅可以连接单个字符,还可
以连接字符串。

  ② 对string操作时,如果能够大概预估到放多少字符,可以先通过reserve把空间预留
好,这样可以节剩开辟空间的效率消耗。

5. string类非成员函数

operator+:尽量少用,因为传值返回,导致深拷贝,导致效率降低

operator<<(重点):输入运算符重载,用于方便输出string字符串中的内容

operator>>(重点):输入运算符重载

getline(重点):获取一行字符串,遇到'\0'才会停止获取,在OJ的字符串题中很常用

relational operators(重点):大小比较,重载了各种类型的比较运算符

3. string类的模拟实现
    3.1 经典的string类问题
        3.1.1 浅拷贝

  浅拷贝:也称位拷贝,编译器只是将对象中的拷贝过来。如果对象中管理资源,最后就会导致
多个对象共享同一份资源,当一个对象销毁时就会将该资源释放掉,而此时另一些对象不知道该
资源已经被释放,以为还有效,所以当继续对资源进项操作时,就会发生发生了访问违规。

  例如:一个家庭中有两个孩子,但父母只买了一份玩具,两个孩子愿意一块玩,则万事大吉,万一不想分享就你争我夺,玩具损坏。

       3.2.2 深拷贝

  如果一个类中涉及到资源的管理,其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给
出。一般情况都是按照深拷贝方式提供。

    3.2 string类模拟实现

//string.h头文件的声明

#pragma once


#include <iostream>
#include <assert.h>
using namespace std;


namespace gjk
{
    class string
    {
    public:

        typedef char* iterator;


        string(const char* s = "")
        {
            _str = new char[strlen(s) + 1];
            strcpy(_str, s);
            _size = strlen(s);
            _capacity = _size;
        }

        char& operator[](size_t pos)
        {
            assert(pos < _size);
            return _str[pos];
        }

        const char& operator[](size_t pos) const
        {
            assert(pos < _size);
            return _str[pos];
        }

        size_t size()
        {
            return _size;
        }

        const size_t size() const
        {
            return _size;
        }

        size_t capacity()
        {
            return _capacity;
        }

        const size_t capacity() const
        {
            return _capacity;
        }

        
        char* c_str()
        {
            return _str;
        }

        //迭代器
        iterator begin()
        {
            return _str;
        }

        const iterator begin() const
        {
            return _str;
        }

        iterator end()
        {
            return _str + _size;
        }

        const iterator end() const
        {
            return _str + _size;
        }

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

        //扩容
        void dilatancy(int newcapacity);
        //预留空间
        void reserve(size_t n);
        //改变有效字符数
        void rsize(size_t n, char ch = '\0');
        //尾插
        void push_back(char ch);
        //尾插字符串
        void append(const char* s);
        //指定插入字符
        void insert(size_t pos, char ch);
        //指定删除n字符
        void erase(size_t pos,size_t n = npos);
        //指定插入字符串
        void insert(size_t pos, const char* s);
        //清除数据
        void clear();
        //判空
        bool empty();

        //+=一个字符运算符重载
        string& operator+=(char ch);
        //+=字符串运算符重载
        string& operator+=(const char* s);


        //比较运算符重载
        bool operator==(const string& s);

        bool operator>(const string& s);

        bool operator<(const string& s);

        bool operator>=(const string& s);

        bool operator<=(const string& s);

        bool operator!=(const string& s);


        //找到字符第一次出现的位置
        int find(char ch,size_t pos = 0);

        //找到字符串第一次出现的位置
        int find(const char* s, size_t pos = 0);

    private:
        char* _str;
        size_t _size;
        size_t _capacity;

        const static size_t npos   = -1;
    };
}

//string.cpp文件的定义

#define _CRT_SECURE_NO_WARNINGS 1


#include "string.h"


namespace gjk
{
    //扩容
    void string::dilatancy(int newcapacity)
    {
        char* tmp = new char[newcapacity + 1];
        strcpy(tmp, _str);
        delete[] _str;
        _str = tmp;
        _capacity = newcapacity;
    }


    //预留空间
    void string::reserve(size_t n)
    {
        if (n > _capacity)
        {
            char* tmp = new char[n + 1];
            strcpy(tmp, _str);
            delete[] _str;
            _str = tmp;
            _capacity = n;
        }
    }

    //改变有效字符数
    void string::rsize(size_t n, char ch)
    {
        if (n <= _size)
        {
            _size = n;
            _str[_size] = '\0';
        }
        else
        {
            while (_size != n)
            {
                if (_size == _capacity)
                    dilatancy(_capacity == 0 ? 4 : 2 * _capacity);
                _str[_size++] = ch;
            }
            _str[_size] = '\0';
        }
    }

    //尾插
    void string::push_back(char ch)
    {
        if (_size == _capacity)
            dilatancy(_capacity == 0 ? 4 : 2 * _capacity);
        _str[_size++] = ch;
        _str[_size] = '\0';
    }


    //尾插字符串
    void string::append(const char* s)
    {
        int len = strlen(s);
        if (_size + strlen(s) > _capacity)
            dilatancy(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);
        strcpy(_str + _size, s);
        _size += len;
    }


    //指定插入字符
    void string::insert(size_t pos, char ch)
    {
        assert(pos <= _size);
        if (_size == _capacity)
            dilatancy(_capacity == 0 ? 4 : 2 * _capacity);
        size_t end = _size + 1;
        while (end > pos)
        {
            _str[end] = _str[end - 1];
            end--;
        }
        _str[pos] = ch;
        _size++;
    }


    //指定删除n个字符
    void string::erase(size_t pos,size_t n)
    {
        assert(pos < _size);
        if (n >= _size - pos||n == npos)
        {
            _str[pos] = '\0';
            _size -= (_size - pos);
        }
        else
        {
            size_t end = pos + n;
            while (end <= _size)
            {
                _str[pos++] = _str[end++];
            }
            _size -= n;
        }
    }

    //指定插入字符串
    void string::insert(size_t pos, const char* s)
    {
        assert(pos <= _size);
        int len = strlen(s);
        if (_size + strlen(s) > _capacity)
            dilatancy(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);
        size_t end = _size + len + 1;
        while (end - len > pos)
        {
            _str[end] = _str[end - len - 1];
            end--;
        }
        memcpy(_str + pos, s, len);
        _size += len;
    }


    //清除数据
    void string::clear()
    {
        _str[0] = '\0';
        _size = 0;
    }


    //判空
    bool string::empty()
    {
        return _size == 0;
    }


    //+=一个字符运算符重载
    string& string::operator+=(char ch)
    {
        push_back(ch);
        return *this;
    }


    //+=字符串运算符重载
    string& string::operator+=(const char* s)
    {
        append(s);
        return *this;
    }


    //比较运算符重载
    bool string::operator==(const string& s)
    {
        return strcmp(_str, s._str) == 0;
    }

    bool string::operator>(const string& s)
    {
        return strcmp(_str, s._str) > 0;
    }


    bool string::operator<(const string& s)
    {
        return !(*this == s || *this > s);
    }


    bool string::operator>=(const string& s)
    {
        return !(*this < s);
    }


    bool string::operator<=(const string& s)
    {
        return !(*this > s);
    }


    bool string::operator!=(const string& s)
    {
        return !(*this == s);
    }

    //找到字符第一次出现的位置
    int string::find(char ch,size_t pos)
    {
        assert(pos < _size);
        while (_str[pos] != ch && pos < _size)
        {
            pos++;
        }
        if (pos == _size)
            return -1;
        return pos;
    }


    //找到字符串第一次出现的位置
    int string::find(const char* s, size_t pos)
    {
        assert(pos < _size);
        int len = strlen(s);
        while (_str[pos] != s[0] && pos < _size)
        {
            pos++;
        }
        if (pos == _size||_size-pos < len)
            return -1;
        int ret = memcmp(_str + pos, s, len);
        if (!ret)
            return pos;
        return -1;
    }
}

   

                                                 创作不易,点个赞呗,蟹蟹啦~             

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/diannao/50035.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

Web响应式设计———1、Grid布局

1、网格布局 Grid布局 流动网格布局是响应式设计的基础。它通过使用百分比而不是固定像素来定义网格和元素的宽度。这样&#xff0c;页面上的元素可以根据屏幕宽度自动调整大小&#xff0c;适应不同设备和分辨率。 <!DOCTYPE html> <html lang"en"> &l…

并发线程学习(Java)

消费者生产者模型 package thread;import java.util.LinkedList; import java.util.Queue;public class ProducerConsumer {private static final int MAX_SIZE 5;private final Queue<Integer> buffer new LinkedList<>();public synchronized void producer(i…

element表单disabled功能失效问题

element表单disabled功能失效问题 场景:当需要根据商品状态来判断是否开启disabled来禁用表单时, disabled绑定了对应的值, 但无论商品是哪种状态, 表单都能操作, disabled失效 <el-form-item label"商品分类"><el-selectv-model"form.packagesTypeI…

二叉树---二叉搜索树的最近公共祖先

题目&#xff1a; 给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。 百度百科中最近公共祖先的定义为&#xff1a;“对于有根树 T 的两个结点 p、q&#xff0c;最近公共祖先表示为一个结点 x&#xff0c;满足 x 是 p、q 的祖先且 x 的深度尽可能大&#xff08;一…

Unable to connect to Redis] with root cause

Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Request processing failed: org.springframework.data.redis.RedisConnectionFailureException: Unable to connect to Redis] with root cause springboot运行不了&#xff0c…

Object.entries()解析出来的数组顺序乱了,健是string类型

现象: 从后端哪里拿到了一长串数据 const obj {"2023-07-01":10,"2023-09-18":2,"2023-10-10":3,"2024-01-10":1,"2024-01-12":1,"2024-02-20":4,"2024-07-01":4,... }; 比如上面的数据有一年的 并…

Mysql-索引视图

目录 1.视图 1.1什么是视图 1.2为什么需要视图 1.3视图的作用和优点 1.4创建视图 1.5更新视图 1.6视图使用规则 1.7修改视图 1.8删除视图 2.索引 2.1什么是索引 2.2索引特点 2.3索引分类 2.4索引优缺点 2.5创建索引 2.6查看索引 2.7删除索引 1.视图 1.1什么是…

go中map

文章目录 Map简介哈希表与Map的概念Go语言内建的Map类型Map的声明Map的初始化Map的访问Map的添加和修改Map的删除Map的遍历 Map的基本使用Map的声明与初始化Map的访问与操作Map的删除Map的遍历Map的并发问题实现线程安全的Map 3. Map的访问与操作3.1 访问Map元素代码示例&#…

释疑 803-(1)概述 精炼提纯版

目录 习题 1-01计算机网络可以向用户提供哪些服务? 1-02 试简述分组交换的要点。 1-03 试从多个方面比较电路交换、报文交换和分组交换的主要优缺点。 1-05 互联网基础结构的发展大致分为哪几个阶段?请指出这几个阶段最主要的特点。 1-06 简述互联网标准制定的几个阶段…

web网站组成

web网站由四部分组成&#xff1a;浏览器 前端服务器 后端服务器 数据库服务器 流程&#xff1a; 1.浏览器输入网站后&#xff0c;向前端服务器发送请求&#xff0c;前端服务器响应&#xff0c;静态的数据给浏览器。 2.前端代码中script中有url,这个是向后台发送请求的网…

手撕数据结构---------顺序表和链表

1.线性表 线性表&#xff08;linear list&#xff09;是n个具有相同特性的数据元素的有限序列。 线性表是⼀种在实际中⼴泛使 ⽤的数据结构&#xff0c;常⻅的线性表&#xff1a;顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构&#xff0c;也就说是连续的⼀条直…

git 回退远端的分支

要将 Git 远端的 分支&#xff08;例如dev-windows&#xff09;回退到特定的提交&#xff08;例如 61e836f3bfc04688a56fc6dca601c7d56c395cc8 (通过 git log 可以查看)&#xff09;&#xff0c; 可以按照以下步骤操作&#xff1a; 1. 回退到指定提交并更新本地分支 首先&…

Python研究生毕业设计,数据挖掘、情感分析、机器学习

最近在学校毕业了&#xff0c;其中有很多毕业论文使用到的代码&#xff0c;如数据挖掘、情感分析、机器学习、数据预测处理、划分数据集和测试集&#xff0c;绘制分类任务&#xff0c;词汇表示&#xff1a;使用TF-IDF向量化器&#xff0c;线性回归、多元线性回归、SVR回归模型&…

0 Redis简介

Redis是key-value存储系统&#xff0c;是跨平台的非关系型数据库。 Redis通常被称为数据结构服务器&#xff0c;是一个开源的内存数据库&#xff0c;常用于缓存、消息队列、会话存储等应用场景。 Redis 与其他 key-value 存储有什么不同&#xff1f; 丰富的数据类型&#xf…

ecshop网站部署

目录 步骤1 ecshop网站的部署 一、安装环境 二、设置开机启动 ​三、 测试php ​四、上传安装包 五、安装ecshop 步骤1 ecshop网站的部署 一、安装环境 yum install -y httpd mariadb-server php php-devel php-mysql 浏览器访问&#xff1a;192.168.30.2 二、设置开机启…

LeetCode 415.字符串相加 C++写法

LeetCode 415.字符串相加 C写法 思路&#x1f914;&#xff1a; 首先不能用stoi和tostring来做&#xff0c;如果给一个很大的数那一定存不下。我们可以从后往前一位一位的取&#xff0c;创建一个变量存储进位用于计算下一位数&#xff0c;之后取模得到当前数字&#xff0c;每一…

k8s部署rabbitmq集群

1 部署集群 1.1 安装 # 创建一个中间件的命名空间 kubectl create namespace middleware # 创建ConfigMap,包含RabbitMQ的配置文件内容 kubectl apply -f rabbitmq-configmap.yaml # 配置用于存储RabbitMQ数据的PersistentVolume&#xff08;PV&#xff09;和PersistentVolum…

iPhone 17系列取消17 Plus版本?新一代苹果手机迎来新变革

随着科技的飞速发展&#xff0c;苹果公司再次准备刷新我们的期待&#xff0c;即将推出的iPhone 17系列携带着一系列令人兴奋的升级。今年&#xff0c;苹果打破了常规&#xff0c;将四款新机型带入市场——iPhone 17、17 Pro、17 Pro Max&#xff0c;以及一款全新的成员&#xf…

Redis 集群搭建

Redis集群搭建 7.2.5 文章目录 1. 环境介绍2. 环境前准备工作&#xff08;所有机器&#xff09;3. 安装 Redis 7.2.54. redis 配置修改4.1 node-01主机添加配置信息4.2 node-02主机添加配置信息4.3 node-03主机添加配置信息 5. 制作脚本5.1 编写脚本5.2 测试脚本 6. 启动Redis…

React前端面试每日一试 3.状态(State)和属性(Props)的区别是什么?

加粗样式先简单介绍一下Props和State的特点 Props&#xff08;属性&#xff09; Props&#xff08;Properties&#xff09;是React组件间传递数据的一种方式。它们是从父组件传递给子组件的只读数据&#xff0c;子组件不能修改这些数据。Props主要用于配置组件&#xff0c;使…