STL::string简单介绍

目录

1、什么是STL

STL6大组件:仿函数、算法、容器、空间配置器、迭代器、配接器

推荐文档(必须学会看文档)

2、string常用接口

 a、初始化


1、什么是STL


标准模板库 STL(Standard Template Library),主要是数据结构和算法的框架,是模板库的一部分,STL是一个规范,是一个实现要求,但是并没有要求实现细节.

STL6大组件:仿函数、算法、容器、空间配置器、迭代器、配接器

推荐文档(必须学会看文档)

string - C++ Reference (cplusplus.com)icon-default.png?t=N7T8https://legacy.cplusplus.com/reference/string/string/?kw=string

2、string常用接口

 a、初始化

哎呀,这部分,再写一遍很没有必要,所以就不写了。毕竟文档介绍的已经足够清晰,不会就查看文档,单词不会就查。主要的是要懂得底层的实现,懂得底层实现的细节,就能够更好的使用。而不仅仅只是一个接口工程师。
string - C++ Reference (cplusplus.com)icon-default.png?t=N7T8https://legacy.cplusplus.com/reference/string/string/?kw=string

string提供的接口非常多,也很冗余。但是不影响,只要用主要的几个就好。

返回值不同不构成函数重载

3、string底层简单实现

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include<iostream>
#include<assert.h>
#include<string.h>
using namespace std;

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;
        typedef const char* const_iterator;

    public:

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

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

        //s2(s1)拷贝
        string(const string& s) 
        {
           /* _size = s._size;
            _capacity = _size;
            _str = new char[_capacity + 1];
            strcpy(_str,s._str);*/
            //这里的将s1交s2,同理,也可以直接使用swap交换
            //但是s是一个const,需要拷贝一份非const
            string tmp(s._str);
            swap(tmp);

        }
        //s2 = s1
        string& operator=( string& s)
        {
            /*_size = s._size;
            _str = new char[_size];
            strcpy(_str,s._str);
            _capacity = s._capacity;*/
            string tmp(s);
            swap(tmp);
            return  *this;
        }

        //析构
        ~string()
        {
            delete[] _str;
            _size = _capacity = 0;
        }

      const  char* c_str()const
        {

            return _str;
        }

            //

            // iterator

        iterator begin()
        {
            return _str;
        }

        iterator end()
        {
            return _str + _size;
        }

        const_iterator begin() const
        {
            return _str;
        }

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

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


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


            /

            //modify

        string& push_back(char c)
        {
          /*  if (_size == _capacity )
            {
                char* tmp = new char[_capacity = _capacity == 0 ? 4 : _capacity * 2];
            }

            _str[_size] = c;
            ++_size;
          */
            insert(_size,c);
            return *this;
        }

     
             string& operator+=(char c)
             {
                 insert(_size,c);
                 return *this;

             }
             string& operator+=(const char* str)
             {
                 insert(_size, str);
                 return *this;
             }

        string& append(const char* str)
        {
            insert(_size,str);
            return *this;
        }


        void clear()
        {
            delete[] _str;
            _capacity = _size = 0;
            _str = nullptr;
        }

        ///
        // capacity

        size_t size()const
        {
            return _size;
        }

        size_t capacity()const
        {
            return _capacity;
        }

        bool empty()const
        {
            return _size == 0;
        }

        void resize(size_t n, char ch = '\0')
        {
            if (n <= _size)
            {
                _str[n] = '\0';
                _size = n;
            }
            else
            {
                reserve(n);
                for (size_t i =_size;i<n;++i)
                {
                    _str[i] = ch;
                }
                _str[n] = '\0';
                _size = n;
                 
            }
        }

        void reserve(size_t n)
        {
            if (n > _capacity )
            {
                char* tmp = new char[n + 1];
                strcpy(tmp,_str);
                delete[] _str;
                _str = tmp;
                _capacity = n;

            }
        }


        /

        // 返回c在string中第一次出现的位置

        size_t find(char c) const
        {
            size_t  i = 0;
            while (i < _size)
            {
                if (_str[i] == c)
                {
                    return i;
                }
                ++i;
            }
        }

        // 返回子串s在string中第一次出现的位置

        size_t find(const char* s) const
        {
            char* cur = strstr(this->_str,s);
            size_t len = cur - _str;
            return len;
        }

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

        size_t insert(size_t pos, char c)
        {
            assert(pos <= _size );

            if (_size <=  _capacity )
            {
               //char* tmp = new char[_capacity == 0 ? 4 : _capacity * 2];//扩容两倍
                reserve(_capacity == 0 ? 4 : _capacity * 2);
            }

            size_t end = _size + 1;//把\0也往后移动
            while(end > pos)//当end到pos下一个位置,正好把pos位置往后移动
            {
                _str[end] = _str[end - 1];
                --end;
            }
            _str[pos] = c;
            _size++;
            return pos;
        }

        void insert(size_t pos, const char* str)
        {
            assert(pos <= _size);
            if (strlen(str ) + _size > _capacity)
            {
                reserve(_size + strlen(str));
            }

            //往后移动len位置,插入str
            size_t len = strlen(str);
            size_t end = len + _size;
            while (end >= pos + len )
            {
                _str[end] = _str[end - len];
                --end;
            }
            
            //不能把\0粘贴进来
            strncpy(_str + pos, str,len);
            _size += len;
        }



        // 删除pos位置上的元素,并返回该元素的下一个位置
        size_t erase(size_t pos, size_t len  = 1)
        {
            assert(pos < _size);
            //删除pos位置以后的值
            //如果n等于超过size,删完,不管
            //小于,往前挪动覆盖即可
            if ( len  >= _size - pos )
            {
                _str[len] = '\0';
                _size = pos;
            }
            else
            {
                //从pos位置开始,往后len个位置,往前覆盖
                strcpy(_str + pos, _str + pos + len);
                _size -= len;
            }
            return pos + 1;
        }


        void print()
        {
            for (auto e : *this)
            {
                cout << e ;
            }
            cout << endl;
        }

        public:
            static const int npos;//声明

    private:

        char* _str;

        size_t _capacity;

        size_t _size;

    };

    //创建
    const int string::npos = -1;

    //relational operators直接利用strcmp函数返回值,而不是自己遍历对比

    bool operator<(const string& s1, const string& s2)
    {
        int ret =  strcmp(s1.c_str(), s2.c_str()) ;
        return ret < 0;
    }

    bool operator>(const string& s1, const string& s2)
    {
        int ret = strcmp(s1.c_str(), s2.c_str());
        return ret > 0;
    }

    bool operator<=(const string& s1, const string& s2)
    {
        return !(s1 > s2);
    }

    bool operator>=(const string& s1, const string& s2)
    {
        return !(s1 < s2);
    }

    bool operator==(const string& s1, const string& s2)
    {
       int ret =  strcmp(s1.c_str(), s2.c_str()) ;
       return ret == 0;
    }

    bool operator!=(const string& s1, const string& s2)
    {
        return !(s1 == s2);
    }



     ostream& operator<<(ostream& _cout, const bit::string& s)
    {
         for (size_t  i = 0; i < s.size();++i)
         {
             _cout << s.c_str()[i];
         }
         return _cout;
    }

     istream& operator>>(istream& _cin, bit::string& s)
    {
         
         for (size_t i = 0; i<s.size();++i)
         {
             _cin >> s._str[i];
         }
         return _cin;
    }



    void test1()
    {
        string s0;
        string s1("hello world");
        const string s2("hello Linux");
        s0 = s1;

       const  string s3 = s2;

      for (auto e : s3)
      {
          cout << e;
      }
      cout << endl;
    }

    void test2()
    {
        string s("hello world");
        s.reserve(5);
        cout << s.capacity() << endl;;
        s.reserve(20);
        cout << s.capacity() << endl;
        s.print();
    }


    void test3()
    {
        string s("hello world");
        //s.resize(5);
        //s.print();
        //cout << s.size() << endl;
        s.resize(30,'x');
        s.print();
        cout << s.size() << endl;
        cout << s[29] << endl;
    }

    void test4()
    {
        string s1("abc");
        string s2("def");
        cout << (s1 == s2) << endl;
        cout << (s1 != s2) << endl;
        cout << (s1>s2) << endl;
        cout << (s1 <= s2) << endl;
        cout << (s1 >= s2) << endl;
    }

    void test5()
    {
        string s1("abcxxxxxxxxxxxxxxxxxxxxx");
       s1.erase(1,100);
       // s1.erase(1);
        s1.print();
    }

    void test6()
    {
        string s("hello world");
        //s.insert(11,"xxxxx");
        s.insert(11,"abbbb");
        cout << s.capacity() << endl;
        cout << s.size() << endl;

       s.print();
    
    }

    void test7()
    {
        string s1("aaabbbccc");
        //size_t add = s1.find('b');
        size_t add = s1.find("ccc");
        cout << add << endl;
    }

    void test8()
    {
        string s("hello world");
        s.push_back('a');
        s.append("xxxx");
        s += 'w';
        s += "oooooo";
        
        //cout << s << endl;
        s.print();
    }

    void test9 ()
    {
        //string s("hello world ");
        //cout << s;
        string s1;
        //int a;
        //cin >> a;
        //cout << a;

        //"hello" >> s1.c_str;
        cout<<s1;
    }



};

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

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

如何带好一个开发小团队?

俗话说&#xff1a;授人以鱼不如授人以渔&#xff0c;这句话强调的是教会别人解决问题的方法比单纯给予一次性帮助更有价值。提倡教育和培养团队成员&#xff0c;使其具备自我解决问题的能力。带领一个开发小团队需要综合考虑管理、沟通和技术能力等方面。以下是一些建议&#…

2024年电子商务与大数据经济国际会议 (EBDE 2024)

2024年电子商务与大数据经济国际会议 (EBDE 2024) 2024 International Conference on E-commerce and Big Data Economy 【会议简介】 2024年电子商务与大数据经济国际会议即将在厦门召开。本次会议旨在汇聚全球电子商务与大数据经济领域的专家学者&#xff0c;共同探讨电子商务…

实验五 Spark SQL编程初级实践

Spark SQL编程初级实践 Spark SQL基本操作 将下列JSON格式数据复制到Linux系统中&#xff0c;并保存命名为employee.json。 { "id":1 , "name":" Ella" , "age":36 } { "id":2, "name":"Bob","a…

STM32学习和实践笔记(21):定时器中断实验

通用定时器配置步骤如下&#xff1a; 第一步&#xff1a;使能定时器时钟 RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4,ENABLE);//使能TIM4时钟 第二步&#xff1a;初始化定时器参数,包含自动重装值&#xff0c;分频系数&#xff0c;计数方式等 voidTIM_TimeBaseInit(TIM_T…

C++编译器如何实现 const(常量)?

C编译器如何实现 const&#xff08;常量&#xff09;&#xff1f; 表面上看&#xff0c;我们在讨论 “编译器怎么保证一个常量不会被程序员强行改变呢&#xff1f;”&#xff1b;其实&#xff0c;我们说的是&#xff1a;如果你表明自己就是要强行修改一个常量&#xff0c;那么…

每日一题:托普利茨矩阵

给你一个 m x n 的矩阵 matrix 。如果这个矩阵是托普利茨矩阵&#xff0c;返回 true &#xff1b;否则&#xff0c;返回 false 。 如果矩阵上每一条由左上到右下的对角线上的元素都相同&#xff0c;那么这个矩阵是 托普利茨矩阵 。 示例 1&#xff1a; 输入&#xff1a;matrix…

【原创教程】EPLAN如何制作专属的封面

想要给EPLAN制作专属封面吗?没问题,我来给你支个招。在EPLAN设计电气图纸时,封面就是第一印象,得好好弄。咱们以口罩机项目为例,来看看怎么做吧! 首先,得新建个封面。在项目属性里找到表格名称,点那个数值下拉菜单,选择“查找”。在弹出的表格里挑个你喜欢的模版,点击…

【IC设计】边沿检测电路(上升沿、下降沿、双沿,附带源代码和仿真波形)

文章目录 边沿检测电路的概念上升沿检测电路下降沿检测电路双边沿检测电路代码和仿真RTL代码Testbench代码仿真波形 参考资料 边沿检测电路的概念 边沿检测指的是检测一个信号的上升沿或者下降沿&#xff0c;如果发现了信号的上升沿或下降沿&#xff0c;则给出一个信号指示出来…

OurBMC开源大赛高校获奖队伍专访来啦!

精彩纷呈的 OurBMC 开源大赛已告一段落&#xff0c;经历为期四个月的实战&#xff0c;各个参赛队伍也积淀了丰富的实践经验与参赛心得。本期&#xff0c;社区特别邀请 OurBMC 开源大赛获奖高校团队分享「走进OurBMC开源大赛&#xff0c;共同践行开放包容、共创共赢的开源精神」…

【春秋云境】文件上传漏洞合集

CVE-2022-30887 1.题目简介 2.CVE-2022-30887简介 使用工具&#xff1a; 蚁剑 burpsuite 一句话木马 3.渗透测试 输入用户名密码进行抓包 猜测账号密码 无有用信息&#xff0c;根据页面现有信息找到作者邮箱&#xff1a; mayuri.infospacegmail.com&#xff0c;猜测密码为&a…

每日一题:跳跃游戏II

给定一个长度为 n 的 0 索引整数数组 nums。初始位置为 nums[0]。 每个元素 nums[i] 表示从索引 i 向前跳转的最大长度。换句话说&#xff0c;如果你在 nums[i] 处&#xff0c;你可以跳转到任意 nums[i j] 处: 0 < j < nums[i] i j < n 返回到达 nums[n - 1] 的最…

YOLOv3没有比这详细的了吧

YOLOv3&#xff1a;目标检测基于YOLOv2的改进 在目标检测领域&#xff0c;YOLO&#xff08;You Only Look Once&#xff09;系列以其出色的性能和速度而闻名。YOLOv3作为该系列的第三个版本&#xff0c;不仅继承了前身YOLOv2的优势&#xff0c;还在多个方面进行了创新和改进。…

机器学习理论基础—支持向量机的推导(一)

机器学习理论基础—支持向量机的推导 算法原理 SVM:从几何角度&#xff0c;对于线性可分数据集&#xff0c;支持向量机就是找距离正负样本都最远的超平面&#xff0c;相比于感知机&#xff0c;其解是唯一的&#xff0c;且不偏不倚&#xff0c;泛化性能更好。 超平面 n维空间…

如何拿取 macOS 系统中的图标文件

如何拿取 macOS 系统中的图标文件 比如在 Finder 中看到这个文件夹图标很好看&#xff0c;想用一下&#xff0c;就是不知道它在什么位置&#xff0c;我来告诉你。 它在系统中的位置是 /System/Library/CoreServices/CoreTypes.bundle/Contents/Resources/如何打开这个位置&am…

计算机网络物理层思维导图+大纲笔记

大纲笔记&#xff1a; 物理层的基本概念 解决如何在连接各种计算机的传输媒体上传输数据比特流&#xff0c;而不是具体的传输媒体 主要任务 确定与传输媒体接口有关的一些特性 机械特性 电气特性 功能特性 规程特性信道上传送的信号 基带信号 来自信源的信号&#xff0c;直接表…

【CLI命令行接口和Java连接openLooKeng查询数据 】

CLI命令行接口和Java连接openLooKeng查询数据 一、摘要二、正文0. 环境说明1. CLI命令行工具的使用2. Java API 的使用三、小结一、摘要 通过CLI命令行接口工具连接openLooKeng,可帮助初学者能够使用SQL语句的方式快速操作openLooKeng,任何只要熟悉SQL的人都可以快速切换到op…

解决 uniapp uni.getLocation 定位经纬度不准问题

【问题描述】 直接使用uni.getLocation获取经纬度不准确&#xff0c;有几百米的偏移。 【解决办法】 加偏移量 //加偏移 let x longitude let y latitude let x_pi (3.14159265358979324 * 3000.0) / 180.0 let z Math.sqrt(x * x y * y) 0.00002 * Math.sin(y * x_pi)…

ArcGIS Pro专题地图系列教程

专题地图系列是ArcGIS Pro3.2的新功能。之前&#xff0c;如果要做8张相同区域的专题图&#xff0c;可能需要新建8个布局&#xff0c;分别进行排版&#xff0c;再导出。现在&#xff0c;一幅地图&#xff0c;一个布局&#xff0c;就可以完成这个流程。 原理是&#xff0c;根据单…

Swift-24-集合对象

概述 在了解正式内容之前可以先回顾下objectiveC中提供的集合特性。 它的特点是&#xff0c;拿NSArray举例&#xff0c;包含NSArray 和 NSMutableArray两个API&#xff0c;前者是不可变数组&#xff0c;一旦创建其值和数量就不能改变了&#xff1b;NSMutableArray是可变数组&…

tableau基础学习——添加标靶图、甘特图、瀑布图

标靶图 添加参考线 添加参考分布 甘特图 创建新的字段 如设置延迟天数****计划交货日期-实际交货日期 为正代表提前交货&#xff0c;负则代表延迟交货 步骤&#xff1a;创建——计算新字段 把延迟天数放在颜色、大小里面就可以 瀑布图 两个表按照地区连接 先做个条形图&…