【数据结构】string（C++模拟实现）

🕗 发布于 2024-10-12 11:26 数据结构 c++ 算法

string构造


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

// s2(s1)
string::string(const string& s)
{
_str = new char[s._capacity + 1];
strcpy(_str, s._str);
_size = s._size;
_capacity = s._capacity;
}

// s1 = s3
// s1 = s1
string& string::operator=(const string& s)
{
if (this != &s)
{
char* tmp = new char[s._capacity + 1];
strcpy(tmp, s._str);
delete[] _str;
_str = tmp;
_size = s._size;
_capacity = s._capacity;
}

return *this;
}

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

string容量操作

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

size_t string::size() const
{
return _size;
}

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

_str = tmp;
_capacity = n;
}
}

string类对象的访问和遍历操作

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

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

const size_t string::npos = -1;

string::iterator string::begin()
{
return _str;
}

string::iterator string::end()
{
return _str + _size;
}

string::const_iterator string::begin() const
{
return _str;
}

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

size_t string::find(char ch, size_t pos)
{
for (size_t i = pos; i < _size; i++)
{
if (_str[i] == ch)
{
return i;
}
}

return npos;
}

size_t string::find(const char* sub, size_t pos)
{
char* p = strstr(_str + pos, sub);
return  p - _str;
}

string类对象的修改操作

void string::push_back(char ch)
{
/*if (_size == _capacity)
{
size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
reserve(newcapacity);
}

_str[_size] = ch;
_str[_size + 1] = '\0';
++_size;*/

insert(_size, ch);
}

// "hello"  "xxxxxxxxxxxxx"
void string::append(const char* str)
{
/*size_t len = strlen(str);
if (_size + len > _capacity)
{
reserve(_size + len);
}

strcpy(_str+_size, str);
_size += len;*/

insert(_size, str);
}

string& string::operator+=(char ch)
{
push_back(ch);

return *this;
}

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

return *this;
}

void string::insert(size_t pos, char ch)
{
assert(pos <= _size);

if (_size == _capacity)
{
size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
reserve(newcapacity);
}

/*int end = _size;
while (end >= (int)pos)
{
_str[end + 1] = _str[end];
--end;
}*/

size_t end = _size + 1;
while (end > pos)
{
_str[end] = _str[end - 1];
--end;
}

_str[pos] = ch;
++_size;
}

void string::insert(size_t pos, const char* str)
{
assert(pos <= _size);

size_t len = strlen(str);
if (_size + len > _capacity)
{
reserve(_size + len);
}

/*int end = _size;
while (end >= (int)pos)
{
_str[end + len] = _str[end];
--end;
}*/

size_t end = _size + len;
while (end > pos + len - 1)
{
_str[end] = _str[end - len];
--end;
}

memcpy(_str + pos, str, len);
_size += len;
}

// 17:10
void string::erase(size_t pos, size_t len)
{
assert(pos < _size);

// len大于前面字符个数时，有多少删多少
if (len >= _size - pos)
{
_str[pos] = '\0';
_size = pos;
}
else
{
strcpy(_str + pos, _str + pos + len);
_size -= len;
}
}
// s1.swap(s3)
void string::swap(string& s)
{
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}

string string::substr(size_t pos, size_t len)
{
// len大于后面剩余字符，有多少取多少
if (len > _size - pos)
{
string sub(_str + pos);
return sub;
}
else
{
string sub;
sub.reserve(len);
for (size_t i = 0; i < len; i++)
{
sub += _str[pos + i];
}

return sub;
}
}

其他函数


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

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

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

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

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

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

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

istream& operator>> (istream& is, string& str)
{
str.clear();
char ch = is.get();
while (ch != ' ' && ch != '\n')
{
str += ch;
ch = is.get();
}

return is;
}

ostream& operator<< (ostream& os, const string& str)
{
for (size_t i = 0; i < str.size(); i++)
{
os << str[i];
}

return os;
}

总结

string.h

#pragma once

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

namespace bit
{
class string
{
public:
typedef char* iterator;
typedef const char* const_iterator;

iterator begin();
iterator end();

const_iterator begin() const;
const_iterator end() const;

//string();
string(const char* str = "");
string(const string& s);
string& operator=(const string& s);
~string();

const char* c_str() const;

size_t size() const;
char& operator[](size_t pos);
const char& operator[](size_t pos) const;

void reserve(size_t n);

void push_back(char ch);
void append(const char* str);

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

void insert(size_t pos, char ch);
void insert(size_t pos, const char* str);
void erase(size_t pos = 0, size_t len = npos);

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

void swap(string& s);
string substr(size_t pos = 0, size_t len = npos);

bool operator<(const string& s) const;
bool operator>(const string& s) const;
bool operator<=(const string& s) const;
bool operator>=(const string& s) const;
bool operator==(const string& s) const;
bool operator!=(const string& s) const;
void clear();
private:
// char _buff[16];
char* _str;

size_t _size;
size_t _capacity;

//  
//const static size_t npos = -1;

// ?
//const static double N = 2.2;

const static size_t npos;
};

istream& operator>> (istream& is, string& str);
ostream& operator<< (ostream& os, const string& str);
}

string.cpp


//string::string()
//{
//_str = new char[1]{'\0'};
//_size = 0;
//_capacity = 0;
//}

string::iterator string::begin()
{
return _str;
}

string::iterator string::end()
{
return _str + _size;
}

string::const_iterator string::begin() const
{
return _str;
}

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


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

// s2(s1)
string::string(const string& s)
{
_str = new char[s._capacity + 1];
strcpy(_str, s._str);
_size = s._size;
_capacity = s._capacity;
}

// s1 = s3
// s1 = s1
string& string::operator=(const string& s)
{
if (this != &s)
{
char* tmp = new char[s._capacity + 1];
strcpy(tmp, s._str);
delete[] _str;
_str = tmp;
_size = s._size;
_capacity = s._capacity;
}

return *this;
}

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

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

size_t string::size() const
{
return _size;
}

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

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

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::push_back(char ch)
{
/*if (_size == _capacity)
{
size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
reserve(newcapacity);
}

_str[_size] = ch;
_str[_size + 1] = '\0';
++_size;*/

insert(_size, ch);
}

// "hello"  "xxxxxxxxxxxxx"
void string::append(const char* str)
{
/*size_t len = strlen(str);
if (_size + len > _capacity)
{
reserve(_size + len);
}

strcpy(_str+_size, str);
_size += len;*/

insert(_size, str);
}

string& string::operator+=(char ch)
{
push_back(ch);

return *this;
}

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

return *this;
}

void string::insert(size_t pos, char ch)
{
assert(pos <= _size);

if (_size == _capacity)
{
size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
reserve(newcapacity);
}

/*int end = _size;
while (end >= (int)pos)
{
_str[end + 1] = _str[end];
--end;
}*/

size_t end = _size + 1;
while (end > pos)
{
_str[end] = _str[end - 1];
--end;
}

_str[pos] = ch;
++_size;
}

void string::insert(size_t pos, const char* str)
{
assert(pos <= _size);

size_t len = strlen(str);
if (_size + len > _capacity)
{
reserve(_size + len);
}

/*int end = _size;
while (end >= (int)pos)
{
_str[end + len] = _str[end];
--end;
}*/

size_t end = _size + len;
while (end > pos + len - 1)
{
_str[end] = _str[end - len];
--end;
}

memcpy(_str + pos, str, len);
_size += len;
}

// 17:10
void string::erase(size_t pos, size_t len)
{
assert(pos < _size);

// len大于前面字符个数时，有多少删多少
if (len >= _size - pos)
{
_str[pos] = '\0';
_size = pos;
}
else
{
strcpy(_str + pos, _str + pos + len);
_size -= len;
}
}

size_t string::find(char ch, size_t pos)
{
for (size_t i = pos; i < _size; i++)
{
if (_str[i] == ch)
{
return i;
}
}

return npos;
}

size_t string::find(const char* sub, size_t pos)
{
char* p = strstr(_str + pos, sub);
return  p - _str;
}

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

string string::substr(size_t pos, size_t len)
{
// len大于后面剩余字符，有多少取多少
if (len > _size - pos)
{
string sub(_str + pos);
return sub;
}
else
{
string sub;
sub.reserve(len);
for (size_t i = 0; i < len; i++)
{
sub += _str[pos + i];
}

return sub;
}
}

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

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

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

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

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

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

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

istream& operator>> (istream& is, string& str)
{
str.clear();
char ch = is.get();
while (ch != ' ' && ch != '\n')
{
str += ch;
ch = is.get();
}

return is;
}

ostream& operator<< (ostream& os, const string& str)
{
for (size_t i = 0; i < str.size(); i++)
{
os << str[i];
}

return os;
}

原文地址：https://blog.csdn.net/Sakura_ding/article/details/142850894

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：SQL Injection | MySQL 数据库概述
下一篇：数据结构——树和二叉树

开发指南072-图片热点
/处理跳转： area.getAttribute('href');平台支持使用图像导航界面，例如展示如下一张图，用户点击对应位置触发对应动作。热点数据通过后台接口获取（注意处理权限，没有权限的热点不生
阅读更多2024-10-13
使用机器学习边缘设备的快速目标检测
这项机器学习研究探讨了一种低成本的边缘设备，该设备与具有计算机视觉功能的嵌入式系统集成，以提高目标检测和分类的推理时间和精度。研究的主要目标是减少推理时间并降低功耗，以支持一个竞技型类人机器人的嵌入式
阅读更多2024-10-13
【Windows】【DevOps】Windows Server 2022 安装ansible，基于powershell实现远程自动化运维部署入门到放弃！
文件URL：https://www.python.org/ftp/python/3.13.0/python-3.13.0-amd64.exe。直接拿linux主机测试ansible连接windows
阅读更多2024-10-13
C# 中循环的应用说明
一循环的概念说明二、循环类型三、循环控制语句四、无限循环
阅读更多2024-10-13
Linux `vmstat` 命令详解
vmstat（Virtual Memory Statistics）是 Linux 系统中的一个监控工具，用于报告系统的虚拟内存、进程、CPU 活动等信息。它能帮助用户了解系统的整体性能状况，尤其是内存
阅读更多2024-10-13
Linux下多任务编程（网络编程2）
本文介绍解决accpet和recv相互阻塞的问题，可以用多线程并发外也可以用epoll I/O多路复用的方式解决。
阅读更多2024-10-13
[单master节点k8s部署]37.微服务（一)springCloud 微服务
微服务架构的一个重要特点是，它与开发中使用的具体或无关。每个微服务都可以使用最适合其功能需求的语言或技术来实现。例如，一个微服务可以用Java编写，另一个微服务可以用Python、Go、Node.js
阅读更多2024-10-13
Zynq(3)使用外设MIO/EMIO
使用MIO/EMIO实现流水灯，着重介绍Zynq IP核的配置，解读vitis中的c语言程序，介绍MIO与EMIO的区别。
阅读更多2024-10-13
笔试算法总结
思路很简单，但是当时做题提交的时候，通过率总是18%。不知道为啥，后面我改成了Long类型，然后就通过了全部用例。（易错1：第一次提交没考虑0的情况）使用 StringBuilder 模拟栈的行为，通
阅读更多2024-10-13
快速学习一个算法，Transformer模型架构
它的主要思想是在同一时间通过多个独立的注意力头（Attention Head）来关注序列中不同部分的信息，然后将这些信息综合起来，生成更丰富的表示。自注意力机制的目的是对输入序列中的每个元素计算一个输
阅读更多2024-10-13

【数据结构】string（C++模拟实现）

string构造

string容量操作

string类对象的访问和遍历操作

string类对象的修改操作

其他函数

总结

string.h

string.cpp

相关文章