【C++STL详解 —— string类的模拟实现】

已于 2024-03-09 15:14:04 修改
阅读量426 收藏 7
点赞数 13
分类专栏： C++ 文章标签： c++ java 前端
于 2024-03-09 12:11:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jokr_/article/details/136580344
版权

文章目录

string类各函数接口总览

namespace String
{
	//模拟实现string类
	class string
	{
	public:
		typedef char* iterator;
		typedef const char* const_iterator;

		//默认成员函数
		string(const char* str = "");         //构造函数
		string(const string& s);              //拷贝构造函数
		string& operator=(const string& s);   //赋值运算符重载函数
		~string();                            //析构函数

		//迭代器相关函数
		iterator begin();
		iterator end();
		const_iterator begin()const;
		const_iterator end()const;

		//容量和大小相关函数
		size_t size() const
		size_t capacity()const 
		void reserve(size_t n);
		void resize(size_t n, char ch = '\0');
		bool empty()const;

		//修改字符串相关函数
		void push_back(char ch);
		void append(const char* str);
		string& operator+=(char ch);
		string& operator+=(const char* str);
		string& insert(size_t pos, char ch);
		string& insert(size_t pos, const char* str);
		string& erase(size_t pos, size_t len);
		void clear();
		string substr(size_t pos = 0, size_t len = npos);
		void swap(string& s);
		const char* c_str()const;

		//访问字符串相关函数
		char& operator[](size_t i);
		const char& operator[](size_t i)const;
		size_t find(char ch, size_t pos = 0)const;
		size_t find(const char* str, size_t pos = 0)const;
		size_t rfind(char ch, size_t pos = npos)const;
		size_t rfind(const char* str, size_t pos = 0)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;
		bool operator!=(const string& s)const;

	private:
		char* _str;       //存储字符串
		size_t _size;     //记录字符串当前的有效长度
		size_t _capacity; //记录字符串当前的容量
		static const size_t npos; //静态成员变量（整型最大值）
	};
	const size_t string::npos = -1;

	//<<和>>运算符重载函数
	istream& operator>>(istream& in, string& s);
	ostream& operator<<(ostream& out, const string& s);
	istream& getline(istream& in, string& s);
}

默认成员函数

构造函数

//默认成员函数
		string(const char* str = "")			//构造函数
			:_size(strlen(str))
		{
			_capacity = _size;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}

		/*
		//不建议版本
		string()			//构造函数
			:_str(new char[1])
			,_size(0)
			,_capacity(0)
		{
			_str[0] = '\0';
		}
		string(const char* str)
			:_size(strlen(str))
		{
			_capacity = _size;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}*/

拷贝构造函数

	string(const string& s)				//拷贝构造
		{
			_size = s._size;
			_capacity = s._capacity;
			_str = new char[s._capacity + 1];
			strcpy(_str, s._str);
		}

		//string(const string& s)				//拷贝构造
		//{
		//	string tmp(s);
		//	swap(tmp);
		//}

赋值运算符重载函数

		string& operator = (const string& 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& operator = (string tmp)	//赋值运算符重载
		//{
		//	//现代写法
		//	swap(tmp);
		//}

析构函数

	~string()							//析构函数	
		{
			delete[]_str;
			_str = nullptr;
			_capacity = _size = 0;
		}

迭代器相关函数

begin和end

//迭代器相关
		iterator begin()
		{
			return _str;
		}
		iterator end()
		{
			return _str + _size;
		}
		const_iterator begin()const
		{
			return _str;

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

容量和大小相关函数

size和capacity

//容量大小相关函数
		size_t size() const
		{
			return _size;
		}
		size_t capacity()const 
		{
			return _capacity;
		}

reserve和resize

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

				_capacity = n;
			}
		}
		void rsize(size_t n,char ch = '\0')
		{
			if (n < _size)
			{
				_str[n] = '\0';
			}
			else
			{
				reserve(n);
				for (size_t i = _size; i < n; i++)
				{
					_str[i] = ch;
				}
				_str[n] = '\0';
				_size = n;
			}
		}

empty

		bool empty()const
		{
			return _str[0] == ' ';
		}

修改字符串相关函数

push_back

//修改字符串相关函数
		void push_back(char ch)
		{
			if (_size == _capacity)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}
			_str[_size] = ch;
			_size++;
			_str[_size] = '\0';
		}

append

		void append(const char* str)
		{
			size_t len = strlen(str);
			if (len + _size > _capacity)
			{
				reserve(len + _size);
			}
			strcpy(_str + _size, str);
			_size += len;

		}

operator+=

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

		}

insert

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

			//扩容2倍
			if (_size == _capacity)
				reserve(_capacity == 0 ? 4 : _capacity * 2);

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

		}
		void insert(size_t pos, const char* str)
		{
			assert(pos <= _size);
			size_t len = strlen(str);

			if (_size + len > _capacity)
			{
				//扩容
				reserve(_size + len);
			}
			
			size_t end = _size + len;
			while (end > pos + len - 1)
			{
				_str[end] = _str[end - len];
				end--;
			}
			strncpy(_str + pos, str, len);
			_size += len;
		}

erase

		void erase(size_t pos, size_t len)
		{
			assert(pos < _size);

			if (len == npos || len >= _size - pos)
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				strcpy(_str + pos, _str + pos + len);
				_size = len;
			}
		}

clear

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

swap

		void swap(string& s)
		{
			std::swap(_str, s._str);
			std::swap(_size, s._size);
			std::swap(_capacity, s._capacity);
		}
substr
		string substr(size_t pos = 0, size_t len = npos)
		{
			string sub;
			//if (len == npos || len >= _size-pos)
			if (len >= _size - pos)
			{
				for (size_t i = pos; i < _size; i++)
				{
					sub += _str[i];
				}
			}
			else
			{
				for (size_t i = pos; i < pos + len; i++)
				{
					sub += _str[i];
				}
			}

			return sub;
		}

c_str

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

访问字符串相关函数

operator[ ]

//访问字符串的相关函数
		char& operator[](size_t i)
		{
			assert(i < _size);

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

			return _str[i];
		}

find和rfind

	size_t find(char ch, size_t pos = 0)const
		{
			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)const
		{
			assert(pos < _size);

			const auto * p = strstr(_str + pos, str);
			
			if (p)
			{
				return p - _str;
			}
			else
			{
				return npos;
			}
		}
		size_t rfind(char ch, size_t pos = npos)const
		{
			string tmp(*this);						//拷贝构造对象tmp
			std::reverse(tmp.begin(), tmp.end());	// 用reverse逆置对象tmp的c字符
			if (pos >= _size);						//给pos大于字符串有效长度
			{
				pos = _size - 1;					//设置pos为字符串最后一个字符的下标
			}
			pos = _size - 1 - pos;					//s改为镜像对称后的位置
			size_t ret = tmp.find(ch, pos);			// 复用find函数

			if (ret != npos)
			{
				return _size - 1 - ret;				//return到了，返回ret镜像对称后的位置
			}
			else
			{
				return npos;
			}
		}
		size_t rfind(const char* str, size_t pos = 0)const
		{
			string tmp(*this); //拷贝构造对象tmp
			std::reverse(tmp.begin(), tmp.end()); //调用reverse逆置对象tmp的C字符串
			size_t len = strlen(str); //待查找的字符串的长度
			char* arr = new char[len + 1]; //开辟arr字符串（用于拷贝str字符串）
			strcpy(arr, str); //拷贝str给arr
			size_t left = 0, right = len - 1; //设置左右指针
			//逆置字符串arr
			while (left < right)
			{
				std::swap(arr[left], arr[right]);
				left++;
				right--;
			}
			if (pos >= _size) //所给pos大于字符串有效长度
			{
				pos = _size - 1; //重新设置pos为字符串最后一个字符的下标
			}
			pos = _size - 1 - pos; //将pos改为镜像对称后的位置
			size_t ret = tmp.find(arr, pos); //复用find函数
			delete[] arr; //销毁arr指向的空间，避免内存泄漏
			if (ret != npos)
				return _size - ret - len; //找到了，返回ret镜像对称后再调整的位置
			else
				return npos; //没找到，返回npos
		}

关系运算符重载函数

	//关系运算符重载
		bool operator > (const string& s)const
		{
			return strcmp(_str, s._str) > 0;
		}
		bool operator >= (const string& s)const
		{
			return (*this > s) || (*this == s);
		}
		bool operator < (const string& s) const
		{
			return !(*this >= s);
		}
		bool operator <= (const string& s)const
		{
			return !(*this > s);
		}
		bool operator == (const string& s)const
		{
			return strcmp(_str, s._str) == 0;
		}
		bool operator != (const string& s)const
		{
			return !(*this == s);
		}

>>和<<运算符的重载以及getline函数

>>运算符的重载

//运算符重载
	std::istream& operator>>(std::istream& in, string& s)
	{
		s.clear();						//清空字符串
		char ch = in.get();				//读取第一个字符
		while (ch != ' ' && ch != '\n') //取到的字符不是空格或'\n＇的时候继续读取
		{
			s += ch;					//读取到的字符尾插到字符串后面
			ch = in.get();				//读取字符
		}
		return in;						//持连续输入
	}

<<运算符的重载

	std::ostream& operator<<(std::ostream& out, string& s)
	{
		//使用范围for遍历字符串并输出
		for (auto e : s)
		{
			out << e;
		}
		return out;				//持连续输入
	}

getline

	std::istream& getline(std::istream& in, string& s)
	{
		s.clear();				//清空字符串
		char ch = in.get();		//取一个字符
		while (ch != '\n')		//取到的字符不是'\n＇的时候继续读取
		{	
			s += ch;			//取到的字符尾插到字符串后面
			ch = in.get();		//续读取字符
		}
		return in;
	}

总览：

#pragma once
#include<assert.h>
#include<iostream>
// using namespace std;
namespace String
{
	class string
	{
	public:
		typedef char* iterator;
		typedef const char* const_iterator;

		//默认成员函数
		string(const char* str = "")			//构造函数
			:_size(strlen(str))
		{
			_capacity = _size;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}

		/*
		//不建议版本
		string()			//构造函数
			:_str(new char[1])
			,_size(0)
			,_capacity(0)
		{
			_str[0] = '\0';
		}
		string(const char* str)
			:_size(strlen(str))
		{
			_capacity = _size;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}*/


		string(const string& s)				//拷贝构造
		{
			_size = s._size;
			_capacity = s._capacity;
			_str = new char[s._capacity + 1];
			strcpy(_str, s._str);
		}

		//string(const string& s)				//拷贝构造
		//{
		//	string tmp(s);
		//	swap(tmp);
		//}

		string& operator = (const string& 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& operator = (string tmp)	//赋值运算符重载
		//{
		//	//现代写法
		//	swap(tmp);
		//}



		~string()							//析构函数	
		{
			delete[]_str;
			_str = nullptr;
			_capacity = _size = 0;
		}

		//迭代器相关
		iterator begin()
		{
			return _str;
		}
		iterator end()
		{
			return _str + _size;
		}
		const_iterator begin()const
		{
			return _str;

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

		//容量大小相关函数
		size_t size() const
		{
			return _size;
		}
		size_t capacity()const 
		{
			return _capacity;
		}
		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete _str;
				_str = tmp;

				_capacity = n;
			}
		}
		void rsize(size_t n,char ch = '\0')
		{
			if (n < _size)
			{
				_str[n] = '\0';
			}
			else
			{
				reserve(n);
				for (size_t i = _size; i < n; i++)
				{
					_str[i] = ch;
				}
				_str[n] = '\0';
				_size = n;
			}
		}
		bool empty()const
		{
			return _str[0] == ' ';
		}

		//修改字符串相关函数
		void push_back(char ch)
		{
			if (_size == _capacity)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}
			_str[_size] = ch;
			_size++;
			_str[_size] = '\0';
		}
		void append(const char* str)
		{
			size_t len = strlen(str);
			if (len + _size > _capacity)
			{
				reserve(len + _size);
			}
			strcpy(_str + _size, str);
			_size += len;

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

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

			//扩容2倍
			if (_size == _capacity)
				reserve(_capacity == 0 ? 4 : _capacity * 2);

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

		}
		void insert(size_t pos, const char* str)
		{
			assert(pos <= _size);
			size_t len = strlen(str);

			if (_size + len > _capacity)
			{
				//扩容
				reserve(_size + len);
			}
			
			size_t end = _size + len;
			while (end > pos + len - 1)
			{
				_str[end] = _str[end - len];
				end--;
			}
			strncpy(_str + pos, str, len);
			_size += len;
		}
		void erase(size_t pos, size_t len)
		{
			assert(pos < _size);

			if (len == npos || len >= _size - pos)
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				strcpy(_str + pos, _str + pos + len);
				_size = len;
			}
		}
		void clear()
		{
			_size = 0;
			_str[_size] = '\0';
		}
		string substr(size_t pos = 0, size_t len = npos)
		{
			string sub;
			//if (len == npos || len >= _size-pos)
			if (len >= _size - pos)
			{
				for (size_t i = pos; i < _size; i++)
				{
					sub += _str[i];
				}
			}
			else
			{
				for (size_t i = pos; i < pos + len; i++)
				{
					sub += _str[i];
				}
			}

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

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

		//访问字符串的相关函数
		char& operator[](size_t i)
		{
			assert(i < _size);

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

			return _str[i];
		}
		size_t find(char ch, size_t pos = 0)const
		{
			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)const
		{
			assert(pos < _size);

			const auto * p = strstr(_str + pos, str);
			
			if (p)
			{
				return p - _str;
			}
			else
			{
				return npos;
			}
		}
		size_t rfind(char ch, size_t pos = npos)const
		{
			string tmp(*this);						//拷贝构造对象tmp
			std::reverse(tmp.begin(), tmp.end());	// 用reverse逆置对象tmp的c字符
			if (pos >= _size);						//给pos大于字符串有效长度
			{
				pos = _size - 1;					//设置pos为字符串最后一个字符的下标
			}
			pos = _size - 1 - pos;					//s改为镜像对称后的位置
			size_t ret = tmp.find(ch, pos);			// 复用find函数

			if (ret != npos)
			{
				return _size - 1 - ret;				//return到了，返回ret镜像对称后的位置
			}
			else
			{
				return npos;
			}
		}
		size_t rfind(const char* str, size_t pos = 0)const
		{
			string tmp(*this); //拷贝构造对象tmp
			std::reverse(tmp.begin(), tmp.end()); //调用reverse逆置对象tmp的C字符串
			size_t len = strlen(str); //待查找的字符串的长度
			char* arr = new char[len + 1]; //开辟arr字符串（用于拷贝str字符串）
			strcpy(arr, str); //拷贝str给arr
			size_t left = 0, right = len - 1; //设置左右指针
			//逆置字符串arr
			while (left < right)
			{
				std::swap(arr[left], arr[right]);
				left++;
				right--;
			}
			if (pos >= _size) //所给pos大于字符串有效长度
			{
				pos = _size - 1; //重新设置pos为字符串最后一个字符的下标
			}
			pos = _size - 1 - pos; //将pos改为镜像对称后的位置
			size_t ret = tmp.find(arr, pos); //复用find函数
			delete[] arr; //销毁arr指向的空间，避免内存泄漏
			if (ret != npos)
				return _size - ret - len; //找到了，返回ret镜像对称后再调整的位置
			else
				return npos; //没找到，返回npos
		}



		//关系运算符重载
		bool operator > (const string& s)const
		{
			return strcmp(_str, s._str) > 0;
		}
		bool operator >= (const string& s)const
		{
			return (*this > s) || (*this == s);
		}
		bool operator < (const string& s) const
		{
			return !(*this >= s);
		}
		bool operator <= (const string& s)const
		{
			return !(*this > s);
		}
		bool operator == (const string& s)const
		{
			return strcmp(_str, s._str) == 0;
		}
		bool operator != (const string& s)const
		{
			return !(*this == s);
		}


		static const size_t npos;	//静态成员变量(整形最大值)

	private:
		char* _str;					//用于存储字符串
		size_t _size;				//用于记录字符串的有效长度
		size_t _capacity;			//用于记录字符串的当前容量大小
	};
	const size_t string::npos = -1;

	//运算符重载
	std::istream& operator>>(std::istream& in, string& s)
	{
		s.clear();						//清空字符串
		char ch = in.get();				//读取第一个字符
		while (ch != ' ' && ch != '\n') //取到的字符不是空格或'\n＇的时候继续读取
		{
			s += ch;					//读取到的字符尾插到字符串后面
			ch = in.get();				//读取字符
		}
		return in;						//持连续输入
	}
	std::ostream& operator<<(std::ostream& out, string& s)
	{
		//使用范围for遍历字符串并输出
		for (auto e : s)
		{
			out << e;
		}
		return out;				//持连续输入
	}
	std::istream& getline(std::istream& in, string& s)
	{
		s.clear();				//清空字符串
		char ch = in.get();		//取一个字符
		while (ch != '\n')		//取到的字符不是'\n＇的时候继续读取
		{	
			s += ch;			//取到的字符尾插到字符串后面
			ch = in.get();		//续读取字符
		}
		return in;
	}
	
}

测试

#define _CRT_SECURE_NO_WARNINGS 1
#include"string.h"
using namespace String;

void test1()
{
	string s1("a");
	s1.append("bcdefg");
	s1.rsize(13);
	//std::cout << s1.c_str() << std::endl;
}
void test_string7()
{
	string url1("https://legacy.cplusplus.com/reference/string/string/substr/");
	string url2("http://www.baidu.com/s?ie=utf-8&f=8&rsv_bp=1&rsv_idx=1&tn=65081411_1_oem_dg&wd=%E5%90%8E%E7%BC%80%20%E8%8B%B1%E6%96%87&fenlei=256&rsv_pq=0xc17a6c03003ede72&rsv_t=7f6eqaxivkivsW9Zwc41K2mIRleeNXjmiMjOgoAC0UgwLzPyVm%2FtSOeppDv%2F&rqlang=en&rsv_dl=ib&rsv_enter=1&rsv_sug3=4&rsv_sug1=3&rsv_sug7=100&rsv_sug2=0&rsv_btype=i&inputT=1588&rsv_sug4=6786");

	string protocol, domain, uri;
	size_t i1 = url1.find(':');
	if (i1 != -1)
	{
		protocol = url1.substr(0, i1 - 0);
		std::cout << protocol.c_str() << std::endl;
	}

	// strchar
	size_t i2 = url1.find('/', i1 + 3);
	if (i2 != string::npos)
	{
		domain = url1.substr(i1 + 3, i2 - (i1 + 3));
		std::cout << domain.c_str() << std::endl;

		uri = url1.substr(i2 + 1);
		std::cout << uri.c_str() << std::endl;
	}


	size_t i3 = url1.find("baidu");
	std::cout << i3 << std::endl;
}
int main()

{
	test_string7();
	
	return 0;
}
jokr_
关注
  • 13
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
STL 容器详解——string 类
qq_61500888的博客
06-06 3028
带你一命通关C++的STL容器 十分钟手撕 string 类
c++ stl之string常用函数
05-23
### C++ STL String 常用函数详解 在C++标准模板库(STL)中，`std::string` 类提供了一系列强大的字符串处理功能。本文将详细介绍`std::string`类的一些核心成员函数及其应用场景。 #### 构造与赋值 1. **构造函数*...
【C++STL详解 —— string类】
jokr_的博客
03-06 1480
string s();//构造一个空字符串//复制s所指向的字符序列//复制s所指向的字符序列的前n个字符//生成n个c字符的字符串//生成str的复制//复制str中字符位置pos开始并且跨越len个字符的部分。
C++STL——string类详解及其模拟实现
Forward♞的博客
11-27 1241
STL全称，译为下面展示STL的六大组件：本章，我们将对string部分常用的功能进行说明和使用，最后对string进行简单的模拟实现本章思维导图：注：本章思维导图已经同步导入至。
【C++STL详解 —— vector的模拟实现】
jokr_的博客
04-04 807
start_finish和。这些成员变量共同管理着vector的存储空间和元素。_start：指向数组开始的指针，也就是vector中第一个元素的位置。_finish：指向数组中最后一个有效元素之后的位置，这个位置是新元素插入的地方。：指向分配的内存空间结束的位置之后的那个位置。这个位置标记了vector可以在不重新分配内存的情况下扩展到的最远位置。：从start到end_of_storage的区域是vector当前分配的整个内存空间，它决定了vector能够容纳的最大元素数量（容量）。
C++STL容器——string类(2)——成员函数详解
weixin_69283129的博客
07-22 674
C++——String类的简单函数介绍
C++STL详解（一）—— string类
2021dragon的博客
06-14 6232
文章目录C++STL详解（一） —— sring类一、string的定义方式二、string的插入三、string的拼接四、string的删除五、string的查找六、string的比较七、string的替换八、string的交换九、string的大小和容量十、string中元素的访问十一、string中运算符的使用十二、string中与迭代器相关的函数 C++STL详解（一） —— sring类 本次内容大纲： 一、string的定义方式 string类实现了多个构造函数的重载，常用的构造函数如下： st
C++ STL容器 —— string 用法详解
Ember_Sky
04-23 7928
STL容器——string函数用法详解 写在前面：近期正在重新学习C++的STL容器，因此准备用一些大白话将STL函数的用法详细记录一下，主要介绍一些基本函数是怎么用的，并不涉及原理。写的不好或者理解的有问题, 请见谅. 下面说的 “运行之后” 表示: 运行上个语句之后的结果. 一行如果说的太长的话, 就得拖动下面的进度条才能看到后面的内容 因此将一段话分成了多行,就像现在这种形式 需要头文件...
C++STL详解（二）——string类的模拟实现
duanku111的博客
07-19 769
首先，我们为了防止命名冲突，我们需要在自己的命名空间内实现string类。
c＋＋初阶知识——string类详解
最新发布
qq_58761784的博客
07-25 1509
C语言中，字符串是以'\0'结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。
【C++ STL详解】——string类
m0_73470633的博客
03-08 894
好了，老铁们，前面我们对C++的一些基础语法以及一些注意事项都有了一定的了解！那么接下来我们将要进入一个崭新的世界，就是对STL库的学习！对于STL的学习核心有三点：熟用、明理（底层实现）、扩展！下面先来看看string类通过文档可以看出string是表示字符串的字符串类底层实际是：basic_string模板类的别名，typedef basic_string<char, char_traits, allocator>stirng;
C++ STL std::string详细讲解
01-19
总结，理解和掌握`std::string`类的这些基本操作，意味着你已经具备了处理C++中大部分字符串问题的能力。在实际编程中，结合其他STL容器和算法，可以构建出复杂而高效的字符串处理逻辑。记得在使用`std::string`时，...
c++-string类详解.pdf
09-13
C++ String 类详解 C++ 中的字符串处理一直是一个难题，标准库中设计了 string 类，以解决 C 语言中字符串处理的难题。string 类的出现，使得编程中涉及到字符串的处理变得更加方便。 字符串声明 在 C++ 中，声明...
C++ string详解
08-29
### C++标准程序库中的`string`类详解 在C++编程中，处理字符串是非常常见的需求之一。相较于传统的`char*`方式，C++标准库中的`string`类提供了更加强大且方便的功能集合，使得字符串操作变得更加简洁高效。本文将...
C字符串函数对应的C++ string操作详解
08-25
C字符串函数和C++ string操作是两种不同的字符串处理方法，在C语言中，我们通常使用字符串函数来操作字符串，而在C++中，我们使用STL中的string类来处理字符串。然而，在C++中，我们也可以使用C字符串函数来操作字符...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1131
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
C++二叉搜索树
Jk_Mr的博客
07-20 1129
树结构是一种重要的数据结构。树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
C++笔试强训7
m0_74189279的博客
07-21 972
这意味着编译器会尝试将函数的代码直接插入到每个调用该函数的地方，而不是像通常那样进行函数调用（即，生成调用指令，跳转到函数代码，执行函数体，然后返回）。友元函数是在类外部定义的普通函数，它只能通过传入的参数（如果有的话）来访问类的成员，或者通过类的对象显式地访问（如果该函数设计为接受类的对象作为参数）。函数参数默认值又叫缺省参数，缺省参数必须从右向左开始缺省，必须连续给定缺省值，也就是说，从左到右，一旦遇到一个参数是缺省的，那么之后的参数也必须都是缺省的。指针是类成员函数特有的，用于指向调用该函数的对象。
商品信息管理系统(C语言)
zeyeqianli的博客
07-22 325
该案例使用了C语言中最具特色的结构体，将每个商品的所有信息存在结构体中，并且定义一个结构体类型的数组保存所有商品的信息，并且按照模块化的编程思想，将要实现的每个功能编写成独立的函数，这样即方便阅读同时也方便差错修改。该系统的主要功能如下：(1) 登录系统。(2) 创建商品信息。(3) 打印商品信息。(4) 查询商品信息。(5) 修改商品信息。(6) 删除商品信息。(7) 商品价格排名显示。(8) 退出系统。
C++ STL详解：从vector到map
这篇文档详细总结了C++ STL中的常用容器，包括vector、stack、queue、priority_queue、deque、list、bitset、set、multiset、map和multimap，以及string的基本操作。 1. vector向量容器：vector是最常见的动态数组...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值