【C++数据结构】STL标准库学习_string模拟实现

深藏阁楼爱情的钟 2024-03-22 10:49 103阅读 0赞

**目录**

【1】string类结构

【2】string类成员变量

【3】string类无参构造函数

【4】string类带参构造函数

【5】string类拷贝构造

【6】string类析构函数

【7】string类迭代器

【8】string类返回C形式指针

【9】string类返回字符串大小

【10】string类返回容量大小

【11】string类清除空间

【12】string类调整数据大小

【13】string类扩容

【14】string类尾插字符

【15】string类尾插字符串

【16】string类插入字符

【17】string类插入字符串

【16】string类删除指定位置字符/字符串

【17】string类查找字符位置

【18】string类查找字符串位置

【20】string类交换

【21】string类运算符重载赋值拷贝

【22】string类运算符重载\[\]

【24】string类运算符重载+=字符

【24】string类运算符重载+=字符串

【25】string类运算符重载<<流输入

【26】string类运算符重载>>流输出

【27】string类完整版

--------------------

### 【1】string类结构 ###

#include <iostream>
    using namespace std;
    
    /** 独立明明空间 **/ 
    namespace ShaXiang {
        /** string类域 **/
        class string {
        /** 私有的限制 **/ 
        private:
        /** 公开的限制 **/ 
        public:
        };
        
        void StringTest1() {
            ShaXiang::string str;
        }
    };

### 【2】string类成员变量 ###

#include <iostream>
    using namespace std;
    
    /** 独立明明空间 **/ 
    namespace ShaXiang {
        /** string类域 **/
        class string {
        /** 私有的限制 **/ 
        private:
            char* _buffer;      // 存储空间
            size_t _size;       // 存储大小
            size_t _capacity;   // 存储熔炼
    
        /** 公开的限制 **/ 
        public:
    
    
        };
    
        void StringTest1() {
            ShaXiang::string str;
        }
    };

### 【3】string类无参构造函数 ###

// 构造函数：无参构造函数
    string(size_t size = 1) {
        _buffer = new char[size];       // 初始化开辟空间
        _buffer[0] = '\0';              // 初始化空间的标识符
        _size = 0;                      // 初始化空间大小
        _capacity = 0;                  // 初始化空间容量
    }
    // 使用下面的带参构造函数，此无参构造函数不需要！

### 【4】string类带参构造函数 ###

// 构造函数：带一个参数构造函数
    string(const char* str = "") {
        _buffer = new char[strlen(str) + 1];    // 开启需要的空间
        strcpy(_buffer, str);                   // 进行深拷贝
    
        _size = strlen(str);                    // 初始化空间大小
        _capacity = _size;                      // 初始化空间容量
    }

### 【5】string类拷贝构造 ###

// 拷贝构造函数 -> 传统写法：
    //string(const string& str) {
    //  _buffer = new char[str._capacity + 1];
    //  _size = str._size;
    //  _capacity = str._capacity;
    
    //  strcpy(_buffer, str._buffer);
    //}
    
    // 拷贝构造函数 -> 现代写法：
    string(const string& str)
        : _buffer(nullptr)
        , _size(0)
        , _capacity(0) {
        string temp(str._buffer);
        swap(temp);
    }

### 【6】string类析构函数 ###

// 析构函数：内存销毁
    ~string() {
        delete[] _buffer; _buffer = nullptr;
        _size = 0;
        _capacity = 0;
    }

### 【7】string类迭代器 ###

// 构建迭代器
    typedef char* iterator;
    iterator begin() { return _buffer; }
    iterator end() { return _buffer + _size; }

### 【8】string类返回C形式指针 ###

// 成员函数：返回C形式指针
    char* c_str() const {
        return _buffer;
    }

### 【9】string类返回字符串大小 ###

// 成员函数：返回C形式指针
    char* c_str() const {
        return _buffer;
    }

### 【10】string类返回容量大小 ###

// 成员函数：返回容量
    size_t capacity() const {
    	return _capacity;
    }

### 【11】string类清除空间 ###

// 成员函数：清除空间
    void clear() {
    	_size = 0;
    	_buffer[0] = '\0';
    }

### 【12】string类调整数据大小 ###

// 成员函数：调整数据大小，用指定字符进行填充
    void resize(size_t n, const char ch = '\0') {
    	// 要调整的数据大小比原本的要大，这时候就需要扩容后在填充数据
    	if (n > _size) {
    		reserve(n);
    		for (size_t i = _size; i < n; i++) {
    			_buffer[i] = ch;
    		}
    		_size = n;
    		_buffer[_size] = '\0';
    	}
    
    	// 要填充的数据比原本要小，不缩小空间按
    	_buffer[n] = '\0';
    	_size = n;
    }

### 【13】string类扩容 ###

// 成员函数：扩容
    void reserve(size_t n) {
    	if (n > _capacity) {
    		// 开辟一块新的空间，元数据赋值到新的空间上。
    		char* temp = new char[n + 1];
    		strcpy(temp, _buffer);
    		delete[] _buffer;
    
    		_buffer = temp;
    		_capacity = n;
    	}
    }

### 【14】string类尾插字符 ###

### 【15】string类尾插字符串 ###

// 成员函数：尾插一个字符串
    void append(const char* str) {
    	// 检查扩容
    	size_t len = strlen(str);
    	if (_size + len > _capacity) {
    		reserve((_size + len) * 2);
    	}
    
    	// 将数据拷贝到_buffer中.
    	strcpy(_buffer + _size, str);
    	_size += len;
    }

### 【16】string类插入字符 ###

// 成员函数：插入一个字符
    string& insert(size_t pos, const char ch) {
    	// 检查扩容
    	if (_size == _capacity) {
    		size_t newCapacity = _capacity == 0 ? 4 : _capacity * 2;
    		reserve(newCapacity);
    	}
    
    	// 扩容完成->挪动数据.
    	size_t end = _size + 1;
    	while (end > pos) {
    		_buffer[end] = _buffer[end - 1];
    		--end;
    	}
    	_buffer[pos] = ch;
    	++_size;
    
    	return *this;
    }

### 【17】string类插入字符串 ###

// 成员函数：插入一个字符串
    string& insert(size_t pos, const char* str) {
    	assert(pos < _size);
    	// 检查扩容
    	size_t len = strlen(str);
    	if (_size + len > _capacity) {
    		reserve((_size + len) * 2);
    	}
    	
    	// 挪动数据
    	size_t end = _size + len;
    	while (end > pos + len - 1) {
    		_buffer[end] = _buffer[end - len];
    		--end;
    	}
    
    	// 拷贝数据
    	for (size_t i = 0; i < len; i++) {
    		_buffer[i + pos] = str[i];
    	}
    
    	return *this;
    }

### 【16】string类删除指定位置字符/字符串 ###

// 成员函数：删除指定位置一个或者单个字符/字符串
    string& erase(size_t pos, size_t len = npos) {
    	assert(pos < _size);
    	// 检查要删除的字符len，大于删除剩下的字符，这时候直接插入'\0'
    	if (len == npos || pos + len > _size) {
    		_buffer[pos] = '\0';
    		_size = pos;
    	}
    	// 下面是数据删除的数据实在中间的
    	else {
    		strcpy(_buffer + pos, _buffer + pos + len);
    		_size -= len;
    	}
    
    	return *this;
    }

### 【17】string类查找字符位置 ###

// 成员函数：查找字符串中的字符位置
    size_t find(const char ch, size_t pos = 0) {
    	assert(pos < _size);
    	// 暴力查找
    	while (pos < _size) {
    		if (_buffer[pos] == ch) {
    			return pos;
    		}
    		pos++;
    	}
    
    	return npos;
    }

### 【18】string类查找字符串位置 ###

// 成员函数：查找字符串中字串位置
    size_t find(const char* str, size_t pos = 0) {
    	assert(pos < _size);
    	// 暴力查找
    	const char* ptr = strstr(_buffer + pos, str);
    	if (ptr == nullptr) {
    		return npos;
    	}
    	
    	return ptr - _buffer;
    }

### 【20】string类交换 ###

// 成员函数：交换
    void swap(string& str) {
    	std::swap(_buffer, str._buffer);c
    	std::swap(_size, str._size);
    	std::swap(_capacity, str._capacity);
    }

### 【21】string类运算符重载赋值拷贝 ###

// 运算符重载：拷贝 -> 传统写法
    //string& operator=(const string& str) {
    //	if (this != &str) {
    //		char* temp = new char[str._capacity + 1];
    //		strcpy(temp, str._buffer);
    
    //		delete[] _buffer;
    //		_buffer = temp;
    //		_size = str._size;
    //		_capacity = str._capacity;
    //	}
    //	return *this;
    //}
    
    // 运算符重载：拷贝 -> 现代写法
    //string& operator=(const string& str) {
    //	if (this != &str) {
    //		string temp(str);
    //		swap(temp);
    //	}
    //	
    //	return *this;
    //}
    
    // 运算符重载：拷贝 -> 现代写法
    string& operator=(string str) {
    	if (this != &str) {
    		swap(str);
    	}
    
    	return *this;
    }

### 【22】string类运算符重载\[\] ###

// 运算符重载：[]
    char& operator[](size_t pos) {
    	assert(pos < _size);	// pos的大小不可以超过字符串本身的大小
    	return _buffer[pos];	// 返回字符的引用
    }
    
    // 运算符重载：[] -> const 版本
    const char& operator[](size_t pos) const {
    	assert(pos < _size);	// pos的大小不可以超过字符串本身的大小
    	return _buffer[pos];	// 返回字符的引用
    }

### 【24】string类运算符重载+=字符 ###

// 运算符重载：+= 字符
    string& operator+=(const char ch) {
    	push_back(ch);
    	return *this;
    }

### 【24】string类运算符重载+=字符串 ###

// 运算符重载：+= 字符串
    string& operator+=(const char* str) {
    	append(str);
    	return *this;
    }

### 【25】string类运算符重载<<流输入 ###

inline istream& operator>>(istream& in, string& str) {
    	str.clear();
    	char buffer[128] = { '\0' };
    	char ch = in.get();
    	
    	// 持续获取字符
    	size_t i = 0;
    	while (ch != ' ' && ch != '\n') {
    		if (i >= 127) {
    			str += buffer;
    			i = 0;
    		}
    
    		buffer[i++] = ch;
    		ch = in.get();
    	}
    
    	// 程序走到这里如果i不是0，说明还有一端需要添加到str中
    	if (i > 0) {
    		buffer[i] = '\0';
    		str += buffer;
    	}
    
    	return in;
    }

### 【26】string类运算符重载>>流输出 ###

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

### 【27】string类完整版 ###

#define _CRT_SECURE_NO_WARNINGS
    #include <iostream>
    #include <cassert>
    using namespace std;
    
    /** 独立明明空间 **/ 
    namespace ShaXiang {
    	/** string类域 **/
    	class string {
    	/** 私有的限制 **/
    	private:
    		char* _buffer;		// 存储空间
    		size_t _size;		// 存储大小
    		size_t _capacity;	// 存储容量
    	
    	/** 公开的限制 **/
    	public:
    		// friend inline ostream& operator<<(ostream& out, const string& str);
    		const static size_t npos = -1;
    
    	/** 公开的限制 **/
    	public:
    		// 构建迭代器
    		typedef char* iterator;
    		iterator begin() { return _buffer; }
    		iterator end() { return _buffer + _size; }
    
    	/** 公开的限制 **/ 
    	public:
    		// 构造函数：带一个参数构造函数
    		string(const char* str = "") {
    			_buffer = new char[strlen(str) + 1];	// 开启需要的空间
    			strcpy(_buffer, str);					// 进行深拷贝
    
    			_size = strlen(str);					// 初始化空间大小
    			_capacity = _size;						// 初始化空间容量
    		}
    
    		// 拷贝构造函数 -> 传统写法：
    		//string(const string& str) {
    		//	_buffer = new char[str._capacity + 1];
    		//	_size = str._size;
    		//	_capacity = str._capacity;
    
    		//	strcpy(_buffer, str._buffer);
    		//}
    
    		// 拷贝构造函数 -> 现代写法：
    		string(const string& str)
    			: _buffer(nullptr)
    			, _size(0)
    			, _capacity(0) {
    			string temp(str._buffer);
    			swap(temp);
    		}
    
    		// 析构函数：内存销毁
    		~string() {
    			delete[] _buffer; _buffer = nullptr;
    			_size = 0;
    			_capacity = 0;
    		}
    	/** 公开的限制 **/
    	public:
    		// 成员函数：返回C形式指针
    		char* c_str() const {
    			return _buffer;
    		}
    
    		// 成员函数：返回字符串大小
    		size_t size() const {
    			return _size;
    		}
    
    		// 成员函数：返回容量
    		size_t capacity() const {
    			return _capacity;
    		}
    
    		// 成员函数：清除空间
    		void clear() {
    			_size = 0;
    			_buffer[0] = '\0';
    		}
    
    		// 成员函数：调整数据大小，用指定字符进行填充
    		void resize(size_t n, const char ch = '\0') {
    			// 要调整的数据大小比原本的要大，这时候就需要扩容后在填充数据
    			if (n > _size) {
    				reserve(n);
    				for (size_t i = _size; i < n; i++) {
    					_buffer[i] = ch;
    				}
    				_size = n;
    				_buffer[_size] = '\0';
    			}
    
    			// 要填充的数据比原本要小，不缩小空间按
    			_buffer[n] = '\0';
    			_size = n;
    		}
    
    		// 成员函数：扩容
    		void reserve(size_t n) {
    			if (n > _capacity) {
    				// 开辟一块新的空间，元数据赋值到新的空间上。
    				char* temp = new char[n + 1];
    				strcpy(temp, _buffer);
    				delete[] _buffer;
    
    				_buffer = temp;
    				_capacity = n;
    			}
    		}
    
    		// 成员函数：尾插一个字符
    		void push_back(const char ch) {
    			// 检查扩容
    			if (_size == _capacity) {
    				size_t newCapacity = _capacity == 0 ? 4 : _capacity * 2;
    				reserve(newCapacity);	// 对于插入字符来说，可以扩2倍
    			}
    
    			// 扩容完成后将字符插入
    			_buffer[_size] = ch;
    			_size++;
    			_buffer[_size] = '\0';	// 原有的\0被新的字符提到，所以要补\0
    		}
    
    		// 成员函数：尾插一个字符串
    		void append(const char* str) {
    			// 检查扩容
    			size_t len = strlen(str);
    			if (_size + len > _capacity) {
    				reserve((_size + len) * 2);
    			}
    
    			// 将数据拷贝到_buffer中.
    			strcpy(_buffer + _size, str);
    			_size += len;
    		}
    
    		// 成员函数：插入一个字符
    		string& insert(size_t pos, const char ch) {
    			// 检查扩容
    			if (_size == _capacity) {
    				size_t newCapacity = _capacity == 0 ? 4 : _capacity * 2;
    				reserve(newCapacity);
    			}
    
    			// 扩容完成->挪动数据.
    			size_t end = _size + 1;
    			while (end > pos) {
    				_buffer[end] = _buffer[end - 1];
    				--end;
    			}
    			_buffer[pos] = ch;
    			++_size;
    
    			return *this;
    		}
    
    		// 成员函数：插入一个字符串
    		string& insert(size_t pos, const char* str) {
    			assert(pos < _size);
    			// 检查扩容
    			size_t len = strlen(str);
    			if (_size + len > _capacity) {
    				reserve((_size + len) * 2);
    			}
    			
    			// 挪动数据
    			size_t end = _size + len;
    			while (end > pos + len - 1) {
    				_buffer[end] = _buffer[end - len];
    				--end;
    			}
    
    			// 拷贝数据
    			for (size_t i = 0; i < len; i++) {
    				_buffer[i + pos] = str[i];
    			}
    
    			return *this;
    		}
    
    		// 成员函数：删除指定位置一个或者单个字符/字符串
    		string& erase(size_t pos, size_t len = npos) {
    			assert(pos < _size);
    			// 检查要删除的字符len，大于删除剩下的字符，这时候直接插入'\0'
    			if (len == npos || pos + len > _size) {
    				_buffer[pos] = '\0';
    				_size = pos;
    			}
    			// 下面是数据删除的数据实在中间的
    			else {
    				strcpy(_buffer + pos, _buffer + pos + len);
    				_size -= len;
    			}
    
    			return *this;
    		}
    
    		// 成员函数：查找字符串中的字符位置
    		size_t find(const char ch, size_t pos = 0) {
    			assert(pos < _size);
    			// 暴力查找
    			while (pos < _size) {
    				if (_buffer[pos] == ch) {
    					return pos;
    				}
    				pos++;
    			}
    
    			return npos;
    		}
    
    		// 成员函数：查找字符串中字串位置
    		size_t find(const char* str, size_t pos = 0) {
    			assert(pos < _size);
    			// 暴力查找
    			const char* ptr = strstr(_buffer + pos, str);
    			if (ptr == nullptr) {
    				return npos;
    			}
    			
    			return ptr - _buffer;
    		}
    
    		// 成员函数：交换
    		void swap(string& str) {
    			std::swap(_buffer, str._buffer);
    			std::swap(_size, str._size);
    			std::swap(_capacity, str._capacity);
    		}
    
    
    
    	/** 公开的限制 **/
    	public:
    		// 运算符重载：拷贝 -> 传统写法
    		//string& operator=(const string& str) {
    		//	if (this != &str) {
    		//		char* temp = new char[str._capacity + 1];
    		//		strcpy(temp, str._buffer);
    
    		//		delete[] _buffer;
    		//		_buffer = temp;
    		//		_size = str._size;
    		//		_capacity = str._capacity;
    		//	}
    		//	return *this;
    		//}
    
    		// 运算符重载：拷贝 -> 现代写法
    		//string& operator=(const string& str) {
    		//	if (this != &str) {
    		//		string temp(str);
    		//		swap(temp);
    		//	}
    		//	
    		//	return *this;
    		//}
    
    		// 运算符重载：拷贝 -> 现代写法
    		string& operator=(string str) {
    			if (this != &str) {
    				swap(str);
    			}
    
    			return *this;
    		}
    
    
    		// 运算符重载：[]
    		char& operator[](size_t pos) {
    			assert(pos < _size);	// pos的大小不可以超过字符串本身的大小
    			return _buffer[pos];	// 返回字符的引用
    		}
    
    		// 运算符重载：[] -> const 版本
    		const char& operator[](size_t pos) const {
    			assert(pos < _size);	// pos的大小不可以超过字符串本身的大小
    			return _buffer[pos];	// 返回字符的引用
    		}
    
    		// 运算符重载：+= 字符
    		string& operator+=(const char ch) {
    			push_back(ch);
    			return *this;
    		}
    	
    		// 运算符重载：+= 字符串
    		string& operator+=(const char* str) {
    			append(str);
    			return *this;
    		}
    	};
    
    	inline ostream& operator<<(ostream& out, const string& str) {
    		for (size_t i = 0; i < str.size(); i++) {
    			out << str[i];
    		}
    		return out;
    	}
    
    	inline istream& operator>>(istream& in, string& str) {
    		str.clear();
    		char buffer[128] = { '\0' };
    		char ch = in.get();
    		
    		// 持续获取字符
    		size_t i = 0;
    		while (ch != ' ' && ch != '\n') {
    			if (i >= 127) {
    				str += buffer;
    				i = 0;
    			}
    
    			buffer[i++] = ch;
    			ch = in.get();
    		}
    
    		// 程序走到这里如果i不是0，说明还有一端需要添加到str中
    		if (i > 0) {
    			buffer[i] = '\0';
    			str += buffer;
    		}
    
    		return in;
    	}
    }