C++:模拟实现string

目录

命名空间的使用

成员变量

构造函数

析构函数

拷贝构造函数

string里的swap函数

赋值运算符重载

迭代器

数组容量

size和capacity

empty

reserve

resize

增删查改

push_back

append

+=运算符重载

clear

insert

插入字符

插入字符串

erase

substr

[]运算符重载

find

c_str

关系运算符

重载流插入、流提取


命名空间的使用

为了防止和标准库中的string出现冲突,我们可以在一个命名空间模拟实现string。

cpp 复制代码
​
namespace zh
{
    class string
    {

    };
}

​

成员变量

cpp 复制代码
​namespace zh
{
    class string
 
    {
 
     private:
        char* _str;
        size_t _size;
        size_t _capacity;
 
        static const size_t npos;
    };
    const  size_t string::npos = -1;
}



​

​

​

​

string本质上就是一个可以动态扩容字符数组,所以我们用一个char*类型的指针来代表该数组_size代表有效字符的个数_capacity代表数组最多容纳有效字符的个数,npos代表一个很大的数(用法等下会提及)。

两个需要注意的点:

1.关于_cpacity的理解,_cpacity != 字符数组的大小。

我们都知道字符串是以'\0'为结束标记的,也要占用空间,而_capacity代表数组最多容纳有效字符的个数,'\0'不是有效字符,所以字符数组的大小是要比_capacity大(字符数组大小 == _capacity + 1) ,我们在写构造函数动态申请空间的时候,要开辟(_capacity + 1)个字节的空间。

2.有关nops的注意事项。

nops的类型是const size_t,是一个静态成员变量。我们都知道静态成员变量是不能在类成员变量声明里给缺省值的,因为静态成员变量不走初始化列表,要走声明定义分离

但是对于对于静态的const size_t,是可以在类里给缺省值的,可以看做定义,如下。

cpp 复制代码
class string
{
private:
	char* _str = nullptr;
	size_t _size = 0;
	size_t _capacity = 0;


	static const size_t npos = -1;  //static const可以这样干  ->编译器特殊处理,看作定义,double都不可以,int才可以.
	//static const size_t npos;  //静态的不能在类里面给缺省值,静态的值不走初始化列表,走声明定义分离
};

构造函数

构造函数我们实现无参构造和带参字符串构造,这两个构造函数可以合在一起。

cpp 复制代码
//无参和有参数合并写成全缺省
string(const char* str = "") //"" 代表空字符串
{
	_size = strlen(str);
	//capacoty不包含\0
	_capacity = _size;
	_str = new char[_capacity + 1];  //空间要多开一个
	strcpy(_str, str);               //strcpy \0也会拷上 先拷贝再判断
}

析构函数

因为是动态开辟的资源,所以析构函数需要我们自己写,手动释放动态开辟的资源。

cpp 复制代码
~string()
{
	delete[] _str;
	_str = nullptr;
	_size = _capacity = 0;
}

拷贝构造函数

对于成员变量含有指针 的,编译器自动生成的拷贝构造是浅拷贝(值的拷贝) ,也就是说两个string的_str的值是一样的,都指向同一块空间 ,那当我们析构这两个对象时就会发生报错,因为对同一块空间析构了两次。

string里的swap函数

所以我们要手动写拷贝构造函数来实现深拷贝,但是在此之前,我们先实现一个交换函数,用于交换两个string。

cpp 复制代码
void swap(string& str)
{
	std::swap(_str, str._str);
	std::swap(_size, str._size);
	std::swap(_capacity, str._capacity);
}

那为什么不能用标准库里面的交换函数,而要自己写?

我们看库里交换函数的具体代码:

标准库里的交换函数涉及拷贝构造和赋值重载,损耗大,不建议使用。

有了这个交换函数,我们的拷贝构造就有了两种写法。

传统写法

cpp 复制代码
​
//拷贝构造
string(const string& str)
{
	//传统写法
    _str = new char[str._capacity + 1];   
	strcpy(_str, str._str);
	_size = str._size;
	_capacity = str._capacity;

}

​

先开辟和str一样大的空间,然后将str拷贝到_str,最后处理_size和_capacity。

新颖写法

cpp 复制代码
//拷贝构造
string(const string& str)
{
    //新颖写法
	string tmp(str._str);
	swap(tmp);
}

先用str对象的_str指针构造一个临时对象tmp (调用构造函数),然后调用交换函数 交换待初始化的对象this和tmp对象,这样就完成了拷贝构造,tmp对象也不用我们多做处理,函数结束后会自动调用析构函数将其清理。

最后析构tmp的时候,由于交换后tmp._str指针可能是随机值从而导致程序崩溃 ,所以我们在成员变量声明时,要给上缺省值,让它们走初始化列表 ,确保程序不会崩溃**。**

赋值运算符重载

赋值重载也涉及深浅拷贝问题,编译器自动生成的赋值重载不能满足需求 ,所以我们要手动实现赋值重载

赋值重载也有两种写法。

传统写法

cpp 复制代码
​
//赋值重载 注意自己给自己赋值的情况
string& operator=(string& str)
{
	//传统写法
    if (this != &str)                     
	{
		delete[] _str;
		_str = new char[str._capacity + 1];
		strcpy(_str, str._str);
		_size = str._size;
		_capacity = str._capacity;
	}

	return *this;
}

​

先把delete掉原来的资源,然后开辟跟str一样大的空间将str拷贝到_str处理_size和_capacity,最后返回*this。

注意:一定要释放原来的资源先,不然会造成内存泄漏。

新颖写法

cpp 复制代码
​
//赋值重载 注意自己给自己赋值的情况
string& operator=(string str)
{
	//新颖写法
	swap(str);
	return *this;
}

​

相比较于传统写法,我们传入的参数是string对象,不是对象的引用,所以我们传参的时候是传值调用,传值调用会调用拷贝构造 ,所以函数里的str是一个临时string对象 ,然后我们交换this对象和str对象完成了赋值重载

函数结束后str对象会调用析构函数完成清理工作。

迭代器

迭代器(Iterator)是一种设计模式,它提供了一种访问容器中元素的方法,而不需要暴露容器的内部结构。

string迭代器的使用

cpp 复制代码
string s1("hello world");
string::iterator it = s1.begin();
while (it != s1.end())
{
    cout << *it << " ";
    it++;
}
cout << endl;

begin()返回首字符的迭代器,end()返回字符数组最后一个有效字符的下一位置的迭代器,类比指针即可)

迭代器也是一种在string的类型,使用迭代器的方式类似于指针,所以我们实现的string类只需要对指针进行封装即可。

标准库里有正向迭代器和反向迭代器,我们这里只模拟实现正向迭代器。

我们模拟实现的迭代器也有两个版本,普通版本和const版本 ,类比于普通指针和const 指针,普通迭代器指向的元素既 允许读也允许写,而const迭代器指向的元素只允许读不允许写

两个版本的迭代器最好根据对象性质匹配使用,不然有可能触发权限放大导致编译不通过

权限可以缩小,但不能放大。也就是const迭代器既可以接收const对象可以接收普通对象 ,但是普通迭代器只允许接收普通对象接收const对象就是权限放大

迭代器具体代码如下:

cpp 复制代码
typedef char* iterator;
typedef const char* const_iterator;

iterator begin()
{
	return _str;
}

iterator end()
{
	return _str + _size; 
}

const_iterator begin() const
{
	return _str;
}

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

注意对于const迭代器的begin()和end()必须在函数后面加const,否则不构成函数重载。而且普通this指针接收const对象触发权限放大。

数组容量

size和capacity

获取当前有效字符的个数最大容纳有效字符的个数。

cpp 复制代码
size_t size() const
{
	return _size;
}

size_t capacity() const
{
	return _capacity;
}

empty

判断字符数组是否为空(就是判断是否是空字符)。

cpp 复制代码
        bool empty() const//不仅要被我们的普通对象调用,也要被我们的const对象调用,所以加const
        {
            return _size == 0;
        }

reserve

用于空间不足时的扩容函数。

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

开辟一块大小为n+1的空间,将字符串拷贝到新空间,释放原来的资源,处理_str和_capacity。

resize

控制有效数据个数

  1. 若n<_size,直接删除数据,将有效位置的下一位置赋值成'\0',改变_size。
  2. 若_size<n<capacity,从原来的_size依次填写直至达到n个,最后一位置为'\0',改变_size。
  3. 若n>capacity,我们只需要扩容+初始化即可。

情况2 3可以放在reserve函数中。

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

	}
}

增删查改

push_back

在字符串后面尾插一个字符 ,插入之前检查容量是否已满满了的话就调用reserve函数扩容 ,最后记得在数组末尾补上一个'\0'

cpp 复制代码
void string::push_back(char ch)
{
	if (_size == _capacity)
	{
		reserve(_capacity == 0 ? 4 : _capacity * 2);
	}

	_str[_size++] = ch;
	_str[_size] = '\0';
}

append

在字符串后面添加一段新字符串添加之前要判满,满了就扩容 ,记得在数组末尾补**'\0'。**

cpp 复制代码
void string::append(const char* str)
{
	size_t len = strlen(str);
	if (_size + len > _capacity)
	{
		reserve(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);
	}
	strcpy(_str + _size, str);
	_size += len;
}

先计算出新字符串的长度len,若_size + len大于2倍_capacity,扩成_size + len大小,若小于则扩成2倍_capacity大小。

这种方式的可以在一定程度上减少扩容的次数。

+=运算符重载

对于string类,我们可以**+=一个字符或者一段字符串**,所以这个函数会构成函数重载。

+=可以复用push_back函数和append函数。

cpp 复制代码
string& string::operator+=(char ch) 
{
	push_back(ch);
	return *this; //注意我们的+=需要返回+=后的值
}

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

clear

请空字符串,将首元素位置赋值为'\0',将_size置为0即可。

cpp 复制代码
void clear()
{
	_str[0] = '\0';
	_size = 0;
}

insert

insert分为两种,一种是在pos位置插入字符ch,一种是在pos插入一段新字符串

插入字符

先来个错误示范

当pos为0时,程序就会挂掉,因为end是int类型pos是size_t类型在C/C++中,两个类型不一致的数发生比较会发生隐式类型转换,有符号的会被转换成无符号的 ,我们希望end到-1时结束循环 ,但是end被转换成无符号 的,-1就是INT_MAX循环永远结束不了

有两种解决方法,一是把pos强转成int,二是在实参那里修改pos的类型为int。

也可以改成下面的写法:

cpp 复制代码
void string::insert(size_t pos, char ch)
{
	assert(pos <= _size);    //判断pos是否越界
	if (_size == _capacity)  //插入前先判断容量大小,满了就扩容
	{
		reserve(_capacity == 0 ? 4 : _capacity * 2);
	}


    size_t end = _size + 1;                   //从'\0'开始挪动,这里的end是'\0'的下一位置
	while (end > pos)            //pos必须强转,防止end类型转换成size_t,循环条件就永远成立了
	{
		_str[end] = _str[end - 1];
		--end;
	}

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

插入完毕后记得让_size++;

插入字符串

计算出新插入字符串的长度len判断_size + _len是否大于_capacity大于则扩容

挪动数据,插入新字符串,最后_size += len。

cpp 复制代码
void string::insert(size_t pos, const char* str)
{
	assert(pos <= _size);
	size_t len = strlen(str);
	if (len == 0) return;
	if (_size + len > _capacity)
	{
		reserve(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);
	}

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

	for (int i = 0; i < len; ++i)
	{
		_str[pos + i] = str[i];
	}

	_size += len;
}

erase

删除pos置开始的len长个字符

删除需要分情况讨论:

  1. 当删除的长度len >= 剩下元素_size - pos时删除包括pos和之后的所有元素直接将pos位置的元素置为'\0'将_size更新为pos 。当传入len时,函数就会调用缺省值npos,npos为INT_MAX,也是删除包括pos和之后的所有元素,npos就是在这里发挥作用
  2. 当len < _size - pos时,挪动数据删除即可。
cpp 复制代码
​
void string::erase(size_t pos, size_t len = npos)
{
	assert(pos < _size);
	if (len >= _size - pos)
	{
		_str[pos] = '\0';
		_size = pos;
	}
	else
	{
		for (size_t i = pos + len; i <= _size; ++i)
		{
			_str[i - len] = _str[i];
		}
	}

	_size -= len;
}

​

删除完成更新_size。

substr

截取从pos位置开始的len长度的字符串,返回一个string对象。

如果len >= _size - pos ,也就是说从pos位置截取的长度大于剩余元素的长度 ,要将len更新为剩余元素的长度_size - pos,因为你不能没有元素了还截取。

cpp 复制代码
string string::substr(size_t pos = 0, size_t len = npos)
{
	assert(pos < _size);
	if (len > _size - pos)
	{
		len = _size - pos;
	}

	string sub;  
	sub.reserve(len);
	for (int i = 0; i < len; ++i)
	{
		sub += _str[pos + i];
	}
	return sub;        
}

[]运算符重载

string本质上是对字符数组的封装,所以应该对[]进行重载从而支持随机访问。

我们也应该实现普通版本const版本

cpp 复制代码
char& operator[](size_t pos)    //&为了支持修改 
{
	assert(pos >= 0 && pos < _size);
	return _str[pos];
}

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

find

find也实现两个版本,一是从pos位置查找单个字符,二是从pos位置查找字符串(用C语言的strstr函数解决即可)。

cpp 复制代码
size_t string::find(char ch, size_t pos)
{
	assert(pos < _size);
	for (size_t i = pos; i < _size; ++i)
	{
		if (_str[i] == ch) 
			return i;
	}
	return npos;
}

size_t string::find(const char* str, size_t pos)
{
	assert(pos < _size); 
	const char* ptr = strstr(_str + pos, str);
	if (ptr == nullptr)
		return npos;	
	return ptr - _str;       //返回下标
}

c_str

返回_str这个字符指针

cpp 复制代码
​
        const char* c_str() const
        {
            return _str;
        }

​

关系运算符

重载> < ==这些关系运算符。

这些函数写在类外面,配合刚刚的c_str使用

cpp 复制代码
bool operator<(const string& s1, const string& s2)
{
	return strcmp(s1.c_str(), s2.c_str()) < 0;
}
bool operator<=(const string& s1, const string& s2)
{
	return s1 < s2 || s1 == s2;
}
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)
{
	return strcmp(s1.c_str(), s2.c_str()) == 0;
}
bool operator!=(const string& s1, const string& s2)
{
	return !(s1 == s2);
}

重载流插入、流提取

这两个函数也是要写在类外面的。

流插入

实现类似cout << string对象的效果。

cpp 复制代码
ostream& operator<<(ostream& out, const string& str)
{
	for (auto ch : str)
	{
		out << ch;
	}
	return out;
}

流提取

实现类似于cin >> string对象的效果

cpp 复制代码
istream& operator>>(istream& in, string& str)  //cin scanf提取任何类型的值,默认空格或者换行都是分隔符
{                                            //空格换行读到了,被忽略了
	str.clear();
	char ch;
	//in >> ch;		
	ch = in.get();                           //get一个字符一个字符的读,跟getc一样的道理

	const int N = 256;
	char buff[N];
	int index = 0;

	while (ch != ' '&& ch != '\n')
	{
		//str += ch;
		buff[index++] = ch;
		if (index == N - 1)
		{
			buff[index] = '\0';
			str += buff;	
			index = 0;
		}
		ch = in.get();
	}

	if (index > 0)
	{
		buff[index] = '\0';
		str += buff;
	}

	return in;
}

为了扩容不那么频繁,我们使用一个buff数组来缓解这个问题。

注意:cin 和 scanf是读不到空格和换行符的,必须用get函数才能一个字符一个字符的读。


拜拜,下期再见😏

摸鱼ing😴✨🎞

相关推荐
Source.Liu几秒前
【用Rust写CAD】第二章 第四节 函数
开发语言·rust
monkey_meng几秒前
【Rust中的迭代器】
开发语言·后端·rust
余衫马4 分钟前
Rust-Trait 特征编程
开发语言·后端·rust
monkey_meng7 分钟前
【Rust中多线程同步机制】
开发语言·redis·后端·rust
Jacob程序员9 分钟前
java导出word文件(手绘)
java·开发语言·word
小白学大数据16 分钟前
正则表达式在Kotlin中的应用:提取图片链接
开发语言·python·selenium·正则表达式·kotlin
VBA633718 分钟前
VBA之Word应用第三章第三节:打开文档,并将文档分配给变量
开发语言
半盏茶香18 分钟前
【C语言】分支和循环详解(下)猜数字游戏
c语言·开发语言·c++·算法·游戏
小堇不是码农24 分钟前
在VScode中配置C_C++环境
c语言·c++·vscode
Jack黄从零学c++27 分钟前
C++ 的异常处理详解
c++·经验分享