- 使用 Spring Initializr 创建 Spring Boot 应用程序
- 在Spring Boot中配置Cassandra
- 在 Spring Boot 上配置 Tomcat 连接池
- 将Camel消息路由到嵌入WildFly的Artemis上
前言:模拟实现string类之前先思考下需要实现哪些接口功能呢?
1.string类的迭代器。
2.string类的构造函数、析构函数、拷贝构造函数、赋值运算符重载。
3.管理字符串的数组,可以增删查改,具体包括reverse、resize、push_back、append、insert、erase、find、clear、getline接口的实现。
4.[]、+=、<、<=、==、>、>=、!=、<<、>>运算符重载。
提示:重点是string类的四个默认成员函数以及增删查改的实现。
class string
{
public:
private:
char* _str;
size_t _size;
size_t _capacity;
static const size_t npos;
};
补充下npos是什么,简单理解就是无符号整型中的-1
这里string类的迭代器完全可以简单理解成指针实现、包括vector也是类似,但是到了后边的容器会有所不同。
这里只需要注意一下end( )代表什么:
class string
{
public:
typedef char* iterator;
typedef const char* const_iterator;
iterator begin()
{
return _str;
}
const_iterator begin() const
{
return _str;
}
iterator end()
{
return _str + _size;
}
const_iterator end() const
{
return _str + _size;
}
};
string(const char* str = "")
{
_size = strlen(str);
_capacity = _size;
_str = new char[_capacity + 1];//给_str一个strlen(s)+1长度的空间
strcpy(_str, str);//拷贝
}
~string()
{
delete[] _str;
_str = nullptr;
_size = 0;
_capacity = 0;
}
传统和现代两种写法
// s1.swap(s2);
void swap(string& s)
{
//交换_s和tmp._s,就相当于给this->_s开辟了一块空间,当拷贝函数结束,tmp就会被自动释放
::swap(_str, s._str);
::swap(_size, s._size);
::swap(_capacity, s._capacity);
}
//传统写法
//s2(s1)
string(const string& s)
:_str(new char[strlen(s._str)+1])
{
strcpy(_str, s._str);
}
// s2(s1) 现代写法
string(const string& s)
:_str(nullptr)//必须置空,因为_str开始是个随机数,交换给tmp._str后,释放会引起问题
, _size(0)
, _capacity(0)
{
string tmp(s._str);//直接利用构造函数,给tmp对象开辟了一块空间
//this->swap(tmp);
swap(tmp);
}
传统和现代两种写法
// s1 = s3 传统写法
string& operator=(const string& s)
{
if (this != &s) // s1 = s1
{
delete[] _str;
_str = new char[strlen(s._str) + 1];
strcpy(_str, s._str);
}
return *this;
}
// s1 = s3 现代写法
string& operator=(string s)
{
swap(s);//这个swap是咱们自己写的哦
return *this;
}
具体包括reverse( )、resize( )、push_back( )、append( )、insert( )、erase( )、find( )、clear( )、getline( )、size( )、c_str( )接口的实现。
// 开空间,扩展capacity
void reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n + 1];//注意哦~,这里必须要多开一个空间存储\0
strncpy(tmp, _str, _size + 1);//多开的那个空间存储位置
delete[] _str;
_str = tmp;
_capacity = n;
}
}
resize( ) 分为三种情况
\0
,最后size等于n,// 开空间+初始化,扩展capacity 并且初始化空间。size也要动
void resize(size_t n, char val = '\0')
{
if (n < _size)
{
_size = n;
_str[_size] = '\0';
}
else
{
if (n > _capacity)
{
reserve(n);
}
for (size_t i = _size; i < n; ++i)
{
_str[i] = val;
}
_str[n] = '\0';
_size = n;
}
}
push_back( ) 针对的是字符
void push_back(char ch)
{
if (_size == _capacity)
{
//这一步是为了防止_capacity如果为0,开不了空间
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
_str[_size] = ch;
_str[_size + 1] = '\0';//给字符串末尾加\0
++_size;
//insert(_size, ch); //或者直接调用insert()
}
append( )针对的是字符串
void append(const char* str)
{
/*size_t len = _size + strlen(str);
if (len > _capacity)
{
reserve(len);
}
strcpy(_str + _size, str);
_size = len;*/
insert(_size, str);
}
包括字符和字符串的插入,需要写两个版本。
//插入字符
string& insert(size_t pos, char ch)
{
assert(pos <= _size);
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
// 类型强制转换成int,使用size_t的话,就永远走不出循环了(因为无符号整型的-1)
/*int end = _size;
while (end >= (int)pos)
{
_str[end + 1] = _str[end];
--end;
}*/
char* end = _str + _size;
while (end >= _str + pos)
{
*(end + 1) = *end;
--end;
}
_str[pos] = ch;
_size++;
return *this;
}
//在pos位置之前插入字符串
string& insert(size_t pos, const char* str)
{
assert(pos <= _size);
size_t len = strlen(str);
if (_size + len > _capacity)
{
reserve(_size + len);
}
// 挪动数据
char* end = _str + _size;
while (end >= _str + pos)
{
*(end + len) = *end;
--end;
}
strncpy(_str + pos, str, len);
_size += len;
return *this;
}
从pos
位置开始删除,len
个,如果len
不写,末尾删除pos
后的全部
string& erase(size_t pos, size_t len = npos)
{
assert(pos < _size);
size_t leftLen = _size - pos;
// 1、剩余的字符长度小于要删的长度 (后面全部删完)
// 2、剩余的字符长度大于要删的长度
if (len >= leftLen)
{
_str[pos] = '\0';
_size = pos;
}
else
{
strcpy(_str + pos, _str + pos + len);
_size -= len;
}
return *this;
}
包括字符和字符串的查找,需要写两个版本。
size_t find(char ch, size_t pos = 0)
{
assert(pos < _size);
for (size_t i = pos; i < _size; ++i)
{
if (_str[i] == ch)
{
return i;
}
}
return npos;
}
size_t find(const char* str, size_t pos = 0)
{
assert(pos < _size);
const char* ret = strstr(_str + pos, str);
if (ret)
{
return ret - _str;
}
else
{
return npos;
}
}
void clear()
{
_size = 0;
_str[0] = '\0';
}
istream& getline(istream& in, string& s)
{
s.clear();
char ch;
ch = in.get();
while (ch != '\n')
{
s += ch;
ch = in.get();
}
return in;
}
size_t size() const
{
return _size;
}
const char* c_str() const
{
return _str;
}
在c++中,string的operator[]有两个重载,分别是:
char& operator[] (size_t pos);
//支持读和写const char& operator[] (size_t pos) const;
//只支持读// 读
const char& operator[](size_t i) const
{
assert(i < _size);
return _str[i];
}
// 可读,可写
char& operator[](size_t i)
{
assert(i < _size);
return _str[i];
}
inline bool operator==(const string& s1, const string& s2)
{
return strcmp(s1.c_str(), s2.c_str()) == 0;
}
// s1 += 'x' 针对字符
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
// s1 += "xxxxx" 针对字符串
string& operator+=(const char* str)
{
append(str);
return *this;
}
inline bool operator<(const string& s1, const string& s2)
{
return strcmp(s1.c_str(), s2.c_str()) < 0;
}
inline bool operator<=(const string& s1, const string& s2)
{
return s1 < s2 || s1 == s2;
}
inline bool operator>(const string& s1, const string& s2)
{
return !(s1 <= s2);
}
inline bool operator>=(const string& s1, const string& s2)
{
return !(s1 < s2);
}
inline bool operator!=(const string& s1, const string& s2)
{
return !(s1 == s2);
}
ostream& operator<<(ostream& out, const string& s)
{
for (auto ch : s)
{
out << ch;
}
return out;
}
istream& operator>>(istream& in, string& s)
{
s.clear();
char ch;
ch = in.get();
while (ch != ' ' && ch != '\n')
{
s += ch;
ch = in.get();
}
return in;
}
小结一下:
感谢您的阅读!!!如果内容对你有帮助的话,记得给我三连(点赞、收藏、关注)——做个手有余香的人。
背景: 我最近一直在使用 JPA,我为相当大的关系数据库项目生成持久层的轻松程度给我留下了深刻的印象。 我们公司使用大量非 SQL 数据库,特别是面向列的数据库。我对可能对这些数据库使用 JPA 有一
我已经在我的 maven pom 中添加了这些构建配置,因为我希望将 Apache Solr 依赖项与 Jar 捆绑在一起。否则我得到了 SolarServerException: ClassNotF
interface ITurtle { void Fight(); void EatPizza(); } interface ILeonardo : ITurtle {
我希望可用于 Java 的对象/关系映射 (ORM) 工具之一能够满足这些要求: 使用 JPA 或 native SQL 查询获取大量行并将其作为实体对象返回。 允许在行(实体)中进行迭代,并在对当前
好像没有,因为我有实现From for 的代码, 我可以转换 A到 B与 .into() , 但同样的事情不适用于 Vec .into()一个Vec . 要么我搞砸了阻止实现派生的事情,要么这不应该发
在 C# 中,如果 A 实现 IX 并且 B 继承自 A ,是否必然遵循 B 实现 IX?如果是,是因为 LSP 吗?之间有什么区别吗: 1. Interface IX; Class A : IX;
就目前而言,这个问题不适合我们的问答形式。我们希望答案得到事实、引用资料或专业知识的支持,但这个问题可能会引发辩论、争论、投票或扩展讨论。如果您觉得这个问题可以改进并可能重新打开,visit the
我正在阅读标准haskell库的(^)的实现代码: (^) :: (Num a, Integral b) => a -> b -> a x0 ^ y0 | y0 a -> b ->a expo x0
我将把国际象棋游戏表示为 C++ 结构。我认为,最好的选择是树结构(因为在每个深度我们都有几个可能的移动)。 这是一个好的方法吗? struct TreeElement{ SomeMoveType
我正在为用户名数据库实现字符串匹配算法。我的方法采用现有的用户名数据库和用户想要的新用户名,然后检查用户名是否已被占用。如果采用该方法,则该方法应该返回带有数据库中未采用的数字的用户名。 例子: “贾
我正在尝试实现 Breadth-first search algorithm , 为了找到两个顶点之间的最短距离。我开发了一个 Queue 对象来保存和检索对象,并且我有一个二维数组来保存两个给定顶点
我目前正在 ika 中开发我的 Python 游戏,它使用 python 2.5 我决定为 AI 使用 A* 寻路。然而,我发现它对我的需要来说太慢了(3-4 个敌人可能会落后于游戏,但我想供应 4-
我正在寻找 Kademlia 的开源实现C/C++ 中的分布式哈希表。它必须是轻量级和跨平台的(win/linux/mac)。 它必须能够将信息发布到 DHT 并检索它。 最佳答案 OpenDHT是
我在一本书中读到这一行:-“当我们要求 C++ 实现运行程序时,它会通过调用此函数来实现。” 而且我想知道“C++ 实现”是什么意思或具体是什么。帮忙!? 最佳答案 “C++ 实现”是指编译器加上链接
我正在尝试使用分支定界的 C++ 实现这个背包问题。此网站上有一个 Java 版本:Implementing branch and bound for knapsack 我试图让我的 C++ 版本打印
在很多情况下,我需要在 C# 中访问合适的哈希算法,从重写 GetHashCode 到对数据执行快速比较/查找。 我发现 FNV 哈希是一种非常简单/好/快速的哈希算法。但是,我从未见过 C# 实现的
目录 LRU缓存替换策略 核心思想 不适用场景 算法基本实现 算法优化
1. 绪论 在前面文章中提到 空间直角坐标系相互转换 ,测绘坐标转换时,一般涉及到的情况是:两个直角坐标系的小角度转换。这个就是我们经常在测绘数据处理中,WGS-84坐标系、54北京坐标系
在软件开发过程中,有时候我们需要定时地检查数据库中的数据,并在发现新增数据时触发一个动作。为了实现这个需求,我们在 .Net 7 下进行一次简单的演示. PeriodicTimer .
二分查找 二分查找算法,说白了就是在有序的数组里面给予一个存在数组里面的值key,然后将其先和数组中间的比较,如果key大于中间值,进行下一次mid后面的比较,直到找到相等的,就可以得到它的位置。
我是一名优秀的程序员,十分优秀!