『C++』string类模拟实现

最新推荐文章于 2022-11-16 14:28:21 发布

爱喝可乐的炸鸡

最新推荐文章于 2022-11-16 14:28:21 发布

阅读量377

点赞数 3

分类专栏：『C++』文章标签： C++ 浅拷贝深拷贝 string类的模拟实现

本文链接：https://blog.csdn.net/sss_0916/article/details/83338238

版权

『C++』专栏收录该内容

25 篇文章 1 订阅

订阅专栏

深拷贝与浅拷贝

首先来看一段代码

#include <iostream>
#include <string.h>
#include <assert.h>

class String{
	public:
		String(const char* str = ""){
			assert(str != nullptr);

			_str = new char[strlen(str) + 1];
			strcpy(_str, str);
		}

		~String(){
			if(_str){
				delete[] _str;
				_str = nullptr;
			}
		}

	private:
		char* _str;
};

int main(){
	String s1("hello, world!");
	String s2(s1);

	return 0;
}

这个简单的String类有没有问题呢？我们使用的是默认的拷贝构造函数，我们来运行一下。
在这里插入图片描述

浅拷贝

这是为什么呢？为什么new开辟的空间会被释放两次。
在这里插入图片描述
从上图，我们可以看出，使用s1拷贝构造s2就是将s1中的_str的值拷贝给了s2中的_str。导致s1._str与s2._str指向了同一块空间。因此在程序结束时，s1和s2分别调用各自的析构函数，所以同一块空间就被delete[]两次，这显然是不行的。
动态申请的空间是不能释放两次的，因为第一次释放，该空间就已经还给系统，再第二次释放之前，有可能该空间已经分配给其他用户，所以第二次释放有可能释放的是其他用户申请的空间，这显然是不合理的。
上述这种问题就是由于浅拷贝造成的。从上面的例子中，我们大概可以明白什么是浅拷贝。
浅拷贝就是将对象中的值拷贝过来，如果对象中管理了堆中的资源，最后会导致多个对象共享同一份资源。

深拷贝

在这里插入图片描述
如上图所示就是深拷贝。为每个对象独立分配资源，保证多个对象之间不会因为共享资源而导致资源被多次释放。

写时拷贝

写时拷贝就是一种拖延症，是在浅拷贝的基础上增加了引用计数的方式来实现的。写时拷贝在写的时候（即改变字符串的时候）才会真正开辟空间进行深拷贝，如果只是对数据的读，则只会进行浅拷贝。
引用计数：用来记录资源使用者的个数。在构造时，将资源的计数给成1，每增加一个对象使用该资源，就给计数增加1，当某个对象被销毁时，先给该计数减1，然后再检查是否需要释放资源，如果计数为1，说明该对象是资源的最后一个使用者，将该资源释放；否则就不能释放，因为还有其他对象在使用该资源。

string类的模拟实现

string.h

#pragma once

#include <iostream>
#include <assert.h>
#include <string.h>

class String{
	friend std::ostream& operator<<(std::ostream& _cout, const String& s);
	friend std::istream& operator>>(std::istream& _cin, String& s);

	public:
		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;
		}

	public:
		String(const char* str = "")
			: _str(nullptr)
			, _capacity(0)
		{
			assert(str != nullptr);

			_size = strlen(str);
			reserve(_size);
			strcpy(_str, str);
		}

		~String(){
			if(_str){
				delete[] _str;
				_str = nullptr;
				_size = 0;
				_capacity = 0;
			}
		}

		String(const String& s)
			: _str(nullptr)
			, _size(0)
			, _capacity(0)
		{
			String temp(s.c_str());

			swap(temp);
		}

		String& operator=(String s){
			swap(s);

			return *this;
		}

	public:
		void reserve(size_t capacity);

		void resize(size_t size, char ch = 0);

	public:
		String& operator+=(char ch);

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

		String operator+(char ch) const;

		String operator+(const char* str) const;

		char& operator[](size_t pos);

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

	public:
		String& insert(size_t pos, char ch);

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

		String& push_back(char ch);

		String& append(const char* str);

		String& erase(size_t pos, size_t len = -1);

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

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

	public:
		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;

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

		size_t capacity() const{
			return _capacity;
		}

		char* c_str() const{
			return _str;
		}

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

	private:
		char* _str;
		size_t _size;
		size_t _capacity;
};

std::ostream& operator<<(std::ostream& _cout, const String& s);

std::istream& operator>>(std::istream& _cin, String& s);

string.cpp

#include "string.h"

void String::reserve(size_t capacity){
	if(capacity > _capacity || capacity == 0){
		if(capacity % 8 == 0){
			capacity += 8;
		}
		else{
			capacity = (capacity / 8 + 1) * 8;
		}

		char* temp = new char[capacity];

		if(_str){
			strcpy(temp, _str);
		}

		delete[] _str;

		_str = temp;
		_capacity = capacity - 1;
	}
}

void String::resize(size_t size, char ch){
	if(size <= _size){
		_size = size;
	}
	else if(size <= _capacity){
		for(size_t i = _size; i < size; ++i){
			_str[i] = ch;
		}

		_size = size;
	}
	else{
		reserve(size);
		for(size_t i = _size; i < size; ++i){
			_str[i] = ch;
		}

		_size = size;
	}

	_str[_size] = '\0';
}

String& String::insert(size_t pos, char ch){
	assert(pos <= _size);

	++_size;
	if(_size > _capacity){
		reserve(_capacity * 2);
	}

	for(int i = _size; i > (int)pos; --i){
		_str[i] = _str[i - 1];
	}

	_str[pos] = ch;

	return *this;
}

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

	int len = strlen(str);

	_size += len;

	if(_size > _capacity){
		reserve(_size);
	}

	for(int i = _size; i >= (int)pos + len; --i){
		_str[i] = _str[i - len];
	}

	strncpy(_str + pos, str, len);

	return *this;
}

String& String::push_back(char ch){
	insert(_size, ch);

	return *this;
}

String& String::append(const char* str){
	insert(_size, str);

	return *this;
}

String& String::erase(size_t pos, size_t len){
	assert(pos < _size);

	if(len >= _size - pos - 1){
		_size = pos;
		_str[_size] = '\0';
	}
	else{
		for(int i = pos; i < (int)_size; ++i){
			_str[i] = _str[i + len];
		}
	}

	return *this;
}

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

	return -1;
}

size_t String::find(const char* str, size_t pos) const{
	char* temp = strstr(_str + pos, str);

	if(!temp){
		return -1;
	}

	return temp - _str;
}

String& String::operator+=(char ch){
	insert(_size, ch);

	return *this;
}

String& String::operator+=(const char* str){
	insert(_size, str);

	return *this;
}

String String::operator+(char ch) const{
	String temp(*this);

	temp += ch;

	return temp;
}

String String::operator+(const char* str) const{
	String temp(*this);

	temp += str;

	return temp;
}

char& String::operator[](size_t pos){
	return *(_str + pos);
}

const char& String::operator[](size_t pos) const{
	return *(_str + pos);
}

bool String::operator>(const String& s) const{
	int ret = strcmp(_str, s._str);

	if(ret > 0){
		return true;
	}

	return false;
}

bool String::operator==(const String& s) const{
	int ret = strcmp(_str, s._str);

	if(!ret){
		return true;
	}

	return false;
}

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 !(*this > s);
}

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

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

	_cout << std::endl;

	return _cout;
}

std::istream& operator>>(std::istream& _cin, String& s){
	if(s._str){
		delete[] s._str;
		s._str = nullptr;
		s._size = 0;
		s._capacity = 0;
	}

	char* temp = new char[2048];

	_cin >> temp;

	int len = strlen(temp);

	s.reserve(len);

	strcpy(s._str, temp);

	delete[] temp;
	temp = nullptr;

	s._size = len;

	return _cin;
}