模拟实现string类

最新推荐文章于 2021-04-01 11:19:12 发布
最新推荐文章于 2021-04-01 11:19:12 发布
阅读量116 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xinrui_z/article/details/106930293
版权

模拟实现string类

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 = "")；

string(const string& s)；

string& operator=(const string &s)；

~string()；



//

// iterator

iterator begin()；

iterator end()；



/

// modify

void PushBack(char c);

string& operator+=(char c);

void Append(const char* str);

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

void clear();

void swap(string& s);

const char* c_str()const;



/

// capacity

size_t size()const

size_t capacity()const

bool empty()const

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

void reserve(size_t newCapacity);



/

// access

char& operator[](size_t index);

const char& operator[](size_t index)const;



/

//relational operators

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);



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

size_t find (char c, size_t pos = 0) const;

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

size_t find (const char* s, size_t pos = 0) const;

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

string& insert(size_t pos, char c);

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

 

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

string& erase(size_t pos, size_t len);

private:

char* _str;

size_t _capacity;

size_t _size;

}

}；

namespace bit

{

  class string

  {

  public:

    typedef char* iterator;

  public:

    string(const char* str = "")

    {

      _size = strlen(str);

      _capacity = _size;

      _str = new char[_capacity+1];

      strcpy(_str, str);

    }

    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()

    {

      if (_str)

      {

        delete[] _str;

        _str = nullptr;

      }

    }



    //

    // 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

    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);

}

//移数据

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:

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

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

  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;

}
8585858
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
[STL]: 模拟实现String类
何如是
09-04 143
string类是什么 string是表示字符串的字符串类 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。 string在底层实际是：basic_string模板类的别名，typedef basic_string<char, char_traits, allocator> string; 不能操作多字节或者变长字符的序列。 string类的接口实...
模拟实现string类深浅拷贝
01-08
从构造，析构以及拷贝构造的方面理解string类的底层实现。 源代码获取： https://github.com/akh5/C-/blob/master/STL/Mystring.cpp string的底层通过字符指针char*通过构造函数申请对应大小的空间，并将指针指向其...
使用alloctor模板来实现string类
a314138918的博客
07-12 154
虽然以前做过更复杂的各种数据结构，不过那只是在看完c++prime7章后做的，没有考虑到类的拷贝体现出来是类值还是类指针，于是写了一些半成品类，不过那些主要是练数据结构，不想再改，于是就想办法模仿了下string，以前都是使用new和delete，虽然简单，但是不够灵活，于是就刻意使用alloctor模板来管理内存，这样可以将“内存分配”与“对象构造分开”，因为对象并不是指针这类管理外部...
模板类string
qq_45035125的博客
06-10 352
string 类的常用构造函数 string()：构造空的string类对象，即空字符串 string(const char* s)：用C-string来构造string类对象 string(size_t n, char c)：string类对象中包含n个字符c string(const string&s)：拷贝构造函数 int main() { string s1; // 构造空的string类对象s1 string s2("hello bit"); // 用C格式字符串构造string类
C++STL标准模板库——string类的模拟实现
04-01 327
一、string类的模拟实现 1.1 string类的传统写法 //传统版的string类 namespace mystring { class string { public: //string构造函数 string(const char* str = "") { assert(str); //如果str为nullptr直接报错 _str = new char[strlen(str) + 1]; strcpy(_str, str); } string(const
【模板】c++ template模板实现string到Num的转换
weixin_34179968的博客
09-03 290
一、文章来由 很早以前就写了这个简单的函数模板，但是没写成博客，方便以后自己找 二、代码 /* * * funtion: stringToNum模板类 * * Date:2015-6-6 * * Author: Bill Wang */ #pragma once #include <iostream&g...
模拟实现string以及一些接口
02-27
模拟实现string以及一些接口
string类的模拟实现
04-29
string类的模拟实现
C++中string类的模拟实现
02-23
该资源中模拟实现了C++中string类的一些常用接口，包括resize、reserve、insert、erase等等，重载了流插入和流提取操作符以实现对string类对象的输出和输入。其中还关注了深拷贝的问题（由于string类中涉及内存资源...
STL库string类的模拟实现
02-28
3. string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信 息，请参阅basic_string)。 4. string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类...
【C++】模拟实现一个string类
今天你AC了吗
03-25 923
这里写目录标题一级目录二级目录三级目录 一级目录 二级目录 三级目录
string类及其简单模拟实现
weixin_45231718的博客
03-13 244
一.string类 1.string是表示字符串的类。该类的接口与常规容器基本相同，再添加了一些专门用来操作字符串的操作。 二.string类常见的对象构造 1.string():构造空的字符串。 2.string（const char *s）:用c-string来构造string类对象 3.string (const string &s):拷贝构造函数 三.string类常用操作 1.s...
模板类——string类方法总结
蘇丶的博客
11-10 868
string类 string类是C++标准库的一个重要的部分,也是字符串的一种数据类型，相对于char*字符串它更方便强大，我们不必担心内存是否足够、字符串长度等等，而且作为一个泛型类出现，他集成的操作函数足以完成我们大多数情况下的需要。我们可以用 = 进行赋值操作，== 进行比较，+ 做串联等 基本赋值方法 有以下赋值方式： string name(&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;q
C++ 模板函数实现string类型与数值类型(int,float)互转
向往天空的鱼
09-06 1432
C++中string类型与int、float互相转换运用模板函数实现，代码如下： /* filename : test.cpp author : lijd data : 2019-09-06 */ #include <iostream> #include <string> #include <sstream> using namespace st...
C++ 泛型程序设计（三）： 类模板之String类
CSDN
06-08 807
string类 string类是一个模板类，它的定义如下： typedef basic_string<char> string; 使用string类要包含头文件 <string> string对象的初始化: string s1("Hello"); // 一个参数的构造函数 string s2(8, ‘x’); // 两个参数的构造函数;8代表字符出现的次数 string...
String类的实现
qq_26105397的博客
05-31 5489
1.常见的面试的时候经常被问到有关string的实现过程，其中包括拷贝构造函数，赋值函数，以及析构函数等，本次如下实现过程加了几个运算符的重载过程。 class String{ friend ostream& operator<< (ostream&,String&);//重载<<运算符 friend istream& ...
NC57供应商管理.pdf
最新发布
07-11
NC57供应商管理
c++string类的模拟实现
04-20
好的，我可以回答这个问题。C++中的string类是一个动态数组，其中包含了一些操作字符串的方法，例如查找、替换、截取等等。为了模拟实现这个类，您需要创建一个动态数组来存储字符串，同时实现一些方法来操作它。比如说，您可以创建一个构造函数来初始化字符串，实现一个拼接方法来将两个字符串合并，还可以实现一个查找方法来搜索字符串中的特定字符或子串。这些都是模拟实现string类的基本步骤。希望这个回答对您有所帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值