C++：模拟实现string类

news2024/11/28 6:28:37

文章目录

  • Iterator类
  • capacity类
  • Element access 类
  • Modifiers类
  • String operations类
  • 类外成员函数
  • 头文件总括

本篇主要介绍模拟实现string类，string中有相当多的内容，这里实现一些相对用途广泛的场景

先看要实现的内容有哪些：

在这里插入图片描述

上图源于cplusplus网站，从中截取了部分内容准备进行模拟实现

首先既然string是一个类，那么首先要把类的这个框架搭建起来，我们把string类这个对象放到命名空间中，这样就不会和std中的类所冲突，一个类起码要有构造函数析构函数成员变量：

namespace My_string
{
	class string
	{
	public:
// Constructor/Destructor
		string(const char* str = "")
			: _size(strlen(str))
			, _capacity(_size)
		{
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}
		~string()
		{
			delete[] _str;
		}
		string& operator=(const char* str)
		{
			_size = strlen(str);
			_capacity = _size;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
			return *this;
		}
		string& operator=(const string& str)
		{
			_capacity = str._capacity;
			_size = str._size;
			_str = new char[_capacity + 1];
			strcpy(_str, str._str);
			return *this;
		}
		string& operator=(char c)
		{
			_capacity = 1;
			_size = 1;
			_str = new char[_capacity + 1];
			_str[0] = c;
			return *this;
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity;
		const static size_t npos;
	};
	const size_t string::npos = -1;
}

至此，string类的大体框架已经搭建完毕了，下面进行string类内部成员函数的完善

Iterator类

begin和end迭代器实现：

在这里插入图片描述
从上面库函数中可以看出，这里返回的是迭代器，而我们又知道，实际上迭代器就是指针的作用，因此我们这里就用指针来模拟实现迭代器的作用

// Iterator
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;
}

capacity类

实现的函数主要有：
在这里插入图片描述

// Capacity
size_t size()
{
	return _size;
}
size_t size() const
{
	return _size;
}
size_t lenth()
{
	return _size;
}
void resize(size_t n, char c = '\0')
{
	;
}
size_t capacity()
{
	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 clear()
{
	memset(_str, '\0', _size);
	_size = 0;
}
bool empty() const
{
	if (_size == 0)
	{
		return true;
	}
	return false;
}

Element access 类

实现的函数主要有

在这里插入图片描述

// Element access
char& operator[](size_t pos)
{
	assert(pos < _size);
	return _str[pos];
}
const char& operator[](size_t pos) const
{
	assert(pos < _size);
	return _str[pos];
}
char& at(size_t pos)
{
	assert(pos < _size);
	return _str[pos];
}
const char& at(size_t pos) const
{
	assert(pos < _size);
	return _str[pos];
}
char& back()
{
	return _str[_size - 1];
}
const char& back() const
{
	assert(_size - 1 >= 0);
	return _str[_size - 1];
}
char& front()
{
	assert(_size - 1 >= 0);
	return _str[0];
}
const char& front() const
{
	return _str[0];
}

Modifiers类

实现的函数主要有

在这里插入图片描述

//Modifiers
string operator+(const char* str)
{
	size_t len = strlen(str);
	reserve(len + _size);
	strcpy(_str + _size, str);
	string s1;
	s1 = *this;
	return s1;
}
string operator + (const string& str)
{
	size_t len = strlen(str._str);
	reserve(len + _size);
	strcpy(_str + _size, str._str);
	string s1;
	s1 = *this;
	return s1;
}
string operator + (char str)
{
	if (_size == _capacity)
	{
		reserve(_size + 1);
	}
	_str[_size++] = str;
	string s1;
	s1 = *this;
	return s1;
}
string& operator+=(const char* str)
{
	append(str);
	return *this;
}
string& operator += (const string& str)
{
	append(str);
	return *this;
}
string& operator += (char str)
{
	push_back(str);
	return *this;
}
void append(const string& str)
{
	size_t len = strlen(str._str);
	if (_size + len > _capacity)
	{
		reserve(_size + len);
	}
	strcpy(_str + _size, str._str);
	_size += len;
}
void append(const char* str)
{
	size_t len = strlen(str);
	if (_size + len > _capacity)
	{
		reserve(_size + len);
	}
	strcpy(_str + _size, str);
	_size += len;
}
void push_back(char c)
{
	if (_size == _capacity)
	{
		reserve(_capacity == 0 ? 4 : _capacity * 2);
	}
	_str[_size++] = c;
	_str[_size] = '\0';
}
string& insert(size_t pos, char ch)
{
	assert(pos <= _size);
	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++;
	return *this;
}
string& insert(size_t pos, const char* str)
{
	assert(pos <= _size);
	size_t len = strlen(str);
	if (_size + len == _capacity)
	{
		reserve(_capacity == 0 ? 4 : _capacity * 2);
	}
	size_t end = _size + len;
	while (end > pos + len - 1)
	{
		_str[end] = _str[end - len];
		--end;
	}
	memmove(_str + pos, str, len);
	_size += len;
}
string& insert(size_t pos, const string& str)
{
	assert(pos <= _size);
	size_t len = strlen(str._str);
	if (_size + len == _capacity)
	{
		reserve(_capacity == 0 ? 4 : _capacity * 2);
	}
	size_t end = _size + len;
	while (end > pos + len - 1)
	{
		_str[end] = _str[end - len];
		--end;
	}
	memmove(_str + pos, str._str, len);
	_size += len;
}
string& erase(size_t pos, size_t  len = npos)
{
	if (len == -1)
	{
		size_t n = pos;
		while (n < _size)
		{
			_str[n] = '\0';
			n++;
		}
		_size = pos - 1;
	}
	else
	{
		assert(pos + len < _size);
		size_t left = pos + len - 1;
		size_t end = _size + 1;
		while (left < end)
		{
			_str[pos] = _str[left];
			pos++;
			left++;
		}
		_size = _size - len;
	}
	return *this;
}
void swap(string& s)
{
	string tmp = s;
	s = *this;
	*this = tmp;
}
void pop_back()
{
	_str[_size - 1] = '\0';
	_size--;
}

String operations类

实现的函数主要有：

在这里插入图片描述

char* c_str()
{
	return _str;
}
size_t find(const string& str, size_t pos = 0) const
{
	int begin = 0;
	int end = (int)_size;
	while (begin < end)
	{
		size_t len = strlen(str._str);
		if (_str[begin] == str._str[0])
		{
			int left = begin;
			int res = 1;
			for (int i = 0; i < len; i++)
			{
				if (_str[left] != _str[i])
				{
					break;
				}
				res++;
				left++;
			}
			if (res == len)
			{
				return begin;
			}
		}
		else
		{
			begin++;
		}
	}
	return npos;
}
string substr(size_t pos = 0, size_t len = npos) const
{
	string s1;
	if (len == npos)
	{
		while (_str[pos] != '\0')
		{
			s1 += _str[pos];
			pos++;
		}
	}
	else
	{
		for (int i = 0; i < len; i++)
		{
			s1 += _str[pos];
			pos++;
		}
	}
	return s1;
}

string operator+ (const string& str) const
{
	return *this + str;
}

bool operator== (const string& str) const
{
	return strcmp(_str, str._str) == 0;
}
bool operator!= (const string& str) const
{
	return !(*this == str);
}
bool operator< (const string& str) const
{
	return strcmp(_str, str._str) < 0;
}
bool operator> (const string& str) const
{
	return strcmp(_str, str._str) > 0;
}
bool operator<= (const string& str) const
{
	return (*this < str) || (*this == str);
}
bool operator>= (const string& str) const
{
	return (*this > str) || (*this == str);
}

类外成员函数

实现的函数主要有：

在这里插入图片描述

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

	return out;
}

std::istream& operator>>(std::istream& in, string& s)
{
	s.clear();

	char ch;
	ch = in.get();
	s.reserve(128);

	while (ch != ' ' && ch != '\n')
	{
		s += ch;
		ch = in.get();
	}

	return in;
}

头文件总括

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

namespace My_string
{
	typedef char* iterator;
	typedef const char* const_iterator;
	class string
	{
	public:
		// Constructor/Destructor
		string(const char* str = "")
			: _size(strlen(str))
			, _capacity(_size)
		{
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}
		~string()
		{
			delete[] _str;
		}
		string& operator=(const char* str)
		{
			_size = strlen(str);
			_capacity = _size;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
			return *this;
		}
		string& operator=(const string& str)
		{
			_capacity = str._capacity;
			_size = str._size;
			_str = new char[_capacity + 1];
			strcpy(_str, str._str);
			return *this;
		}
		string& operator=(char c)
		{
			_capacity = 1;
			_size = 1;
			_str = new char[_capacity + 1];
			_str[0] = c;
			return *this;
		}

		// Iterator
		iterator begin()
		{
			return _str;
		}
		const_iterator begin() const
		{
			return _str;
		}
		iterator end()
		{
			return _str + _size;
		}
		const_iterator end() const
		{
			return _str + _size;
		}

		// Capacity
		size_t size()
		{
			return _size;
		}
		size_t size() const
		{
			return _size;
		}
		size_t lenth()
		{
			return _size;
		}
		void resize(size_t n, char c = '\0')
		{
			;
		}
		size_t capacity()
		{
			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 clear()
		{
			memset(_str, '\0', _size);
			_size = 0;
		}
		bool empty() const
		{
			if (_size == 0)
			{
				return true;
			}
			return false;
		}

		// Element access
		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}
		const char& operator[](size_t pos) const
		{
			assert(pos < _size);
			return _str[pos];
		}
		char& at(size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}
		const char& at(size_t pos) const
		{
			assert(pos < _size);
			return _str[pos];
		}
		char& back()
		{
			return _str[_size - 1];
		}
		const char& back() const
		{
			assert(_size - 1 >= 0);
			return _str[_size - 1];
		}
		char& front()
		{
			assert(_size - 1 >= 0);
			return _str[0];
		}
		const char& front() const
		{
			return _str[0];
		}

		//Modifiers
		string operator+(const char* str)
		{
			size_t len = strlen(str);
			reserve(len + _size);
			strcpy(_str + _size, str);
			string s1;
			s1 = *this;
			return s1;
		}
		string operator + (const string& str)
		{
			size_t len = strlen(str._str);
			reserve(len + _size);
			strcpy(_str + _size, str._str);
			string s1;
			s1 = *this;
			return s1;
		}
		string operator + (char str)
		{
			if (_size == _capacity)
			{
				reserve(_size + 1);
			}
			_str[_size++] = str;
			string s1;
			s1 = *this;
			return s1;
		}
		string& operator+=(const char* str)
		{
			append(str);
			return *this;
		}
		string& operator += (const string& str)
		{
			append(str);
			return *this;
		}
		string& operator += (char str)
		{
			push_back(str);
			return *this;
		}
		void append(const string& str)
		{
			size_t len = strlen(str._str);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}
			strcpy(_str + _size, str._str);
			_size += len;
		}
		void append(const char* str)
		{
			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}
			strcpy(_str + _size, str);
			_size += len;
		}
		void push_back(char c)
		{
			if (_size == _capacity)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}
			_str[_size++] = c;
			_str[_size] = '\0';
		}
		string& insert(size_t pos, char ch)
		{
			assert(pos <= _size);
			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++;
			return *this;
		}
		string& insert(size_t pos, const char* str)
		{
			assert(pos <= _size);
			size_t len = strlen(str);
			if (_size + len == _capacity)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}
			size_t end = _size + len;
			while (end > pos + len - 1)
			{
				_str[end] = _str[end - len];
				--end;
			}
			memmove(_str + pos, str, len);
			_size += len;
		}
		string& insert(size_t pos, const string& str)
		{
			assert(pos <= _size);
			size_t len = strlen(str._str);
			if (_size + len == _capacity)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}
			size_t end = _size + len;
			while (end > pos + len - 1)
			{
				_str[end] = _str[end - len];
				--end;
			}
			memmove(_str + pos, str._str, len);
			_size += len;
		}
		string& erase(size_t pos, size_t  len = npos)
		{
			if (len == -1)
			{
				size_t n = pos;
				while (n < _size)
				{
					_str[n] = '\0';
					n++;
				}
				_size = pos - 1;
			}
			else
			{
				assert(pos + len < _size);
				size_t left = pos + len - 1;
				size_t end = _size + 1;
				while (left < end)
				{
					_str[pos] = _str[left];
					pos++;
					left++;
				}
				_size = _size - len;
			}
			return *this;
		}
		void swap(string& s)
		{
			string tmp = s;
			s = *this;
			*this = tmp;
		}
		void pop_back()
		{
			_str[_size - 1] = '\0';
			_size--;
		}

		// String operations
		char* c_str()
		{
			return _str;
		}
		size_t find(const string& str, size_t pos = 0) const
		{
			int begin = 0;
			int end = (int)_size;
			while (begin < end)
			{
				size_t len = strlen(str._str);
				if (_str[begin] == str._str[0])
				{
					int left = begin;
					int res = 1;
					for (int i = 0; i < len; i++)
					{
						if (_str[left] != _str[i])
						{
							break;
						}
						res++;
						left++;
					}
					if (res == len)
					{
						return begin;
					}
				}
				else
				{
					begin++;
				}
			}
			return npos;
		}
		string substr(size_t pos = 0, size_t len = npos) const
		{
			string s1;
			if (len == npos)
			{
				while (_str[pos] != '\0')
				{
					s1 += _str[pos];
					pos++;
				}
			}
			else
			{
				for (int i = 0; i < len; i++)
				{
					s1 += _str[pos];
					pos++;
				}
			}
			return s1;
		}

		string operator+ (const string& str) const
		{
			return *this + str;
		}

		bool operator== (const string& str) const
		{
			return strcmp(_str, str._str) == 0;
		}
		bool operator!= (const string& str) const
		{
			return !(*this == str);
		}
		bool operator< (const string& str) const
		{
			return strcmp(_str, str._str) < 0;
		}
		bool operator> (const string& str) const
		{
			return strcmp(_str, str._str) > 0;
		}
		bool operator<= (const string& str) const
		{
			return (*this < str) || (*this == str);
		}
		bool operator>= (const string& str) const
		{
			return (*this > str) || (*this == str);
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity;
		const static size_t npos;
	};
	const size_t string::npos = -1;

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

		return out;
	}

	std::istream& operator>>(std::istream& in, string& s)
	{
		s.clear();

		char ch;
		ch = in.get();
		s.reserve(128);

		while (ch != ' ' && ch != '\n')
		{
			s += ch;
			ch = in.get();
		}

		return in;
	}
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/843867.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

认识所有权

认识所有权

专栏简介&#xff1a;本专栏作为Rust语言的入门级的文章&#xff0c;目的是为了分享关于Rust语言的编程技巧和知识。对于Rust语言&#xff0c;虽然历史没有C、和python历史悠远&#xff0c;但是它的优点可以说是非常的多&#xff0c;既继承了C运行速度&#xff0c;还拥有了Java…
阅读更多...
从零构建深度学习推理框架-4 框架中的算子注册机制

从零构建深度学习推理框架-4 框架中的算子注册机制

今天要讲的这一注册机制用到了设计模式中的工厂模式和单例模式&#xff0c;所以这节课也是对两大设计模式的一个合理应用和实践。KuiperInfer的注册表是一个map数据结构&#xff0c;维护了一组键值对&#xff0c;key是对应的OpType&#xff0c;用来查找对应的value&#xff0c;…
阅读更多...
断路器分合闸线圈电流试验

断路器分合闸线圈电流试验

试验目的 仅通过断路器低电压值来分析判断断路器的状态, 不能有效地反映断路器内部潜 在缺陷, 同时无法对故障进行定位, 分、 合闸线圈电流蕴含断路器操作回路的极大信 息, 典型的分、 合闸线圈动作电流暂态波形, 通常有两个波峰和一个波谷, 根据波峰、 波谷出现的时间位置, …
阅读更多...
关于外贸跟进客户过程中需要注意的地方

关于外贸跟进客户过程中需要注意的地方

如果你感觉业务进展困难&#xff0c;多去看一些书&#xff0c;多去链接一些人&#xff0c;特别是优秀的人&#xff0c;多交流会让你思维更加开阔&#xff0c;笔记做好实践起来&#xff0c;就会有收获&#xff01; 我记得汪老师说过&#xff1a;跟进客户&#xff0c;当你准备好…
阅读更多...
【Maven】依赖范围、依赖传递、依赖排除、依赖原则、依赖继承

【Maven】依赖范围、依赖传递、依赖排除、依赖原则、依赖继承

【Maven】依赖范围、依赖传递、依赖排除、依赖原则、依赖继承 依赖范围 依赖传递 依赖排除 依赖原则 依赖继承 依赖范围 在Maven中&#xff0c;依赖范围&#xff08;Dependency Scope&#xff09;用于控制依赖项在编译、测试和运行时的可见性和可用性。通过指定适当的依赖…
阅读更多...
AWK实战案例——筛选给定时间范围内的日志

AWK实战案例——筛选给定时间范围内的日志

时间戳与当地时间 概念&#xff1a; 1.时间戳&#xff1a; 时间戳是指格林威治时间自1970年1月1日&#xff08;00:00:00 GMT&#xff09;至当前时间的总秒数。它也被称为Unix时间戳&#xff08;Unix Timestamp&#xff09;。通俗的讲&#xff0c;时间戳是一份能够表示一份数据…
阅读更多...
关于Python 的 Web 自动化测试的实践

关于Python 的 Web 自动化测试的实践

Web 测试是软件测试中比较重要的一个分支&#xff0c;而要实现 Web 自动化测试则要求测试人员能熟练掌握自动化测试工具和编程语言。介绍免费开源的 Web 测试工具 Selenium&#xff0c;以及流行的编程语言 Python。根据自动化测试的原理&#xff0c;对网页元素的常用定位方式&a…
阅读更多...
教育行业的文件管理方法和实践

教育行业的文件管理方法和实践

信息化浪潮的冲击下&#xff0c;教育行业也正在向建设数据化平台发展。在文件管理方面&#xff0c;教育行业依旧存在文件交互与协作方式传统陈旧的问题。Zoho Workdrive为教育行业提供安全的文件集中存储管理空间&#xff0c;用户可以快速使用、共享文件&#xff0c;帮助教育行…
阅读更多...
内容动态展示抽屉组件

内容动态展示抽屉组件

知识点 mousemove与mouseenter的区别在于mousemove会触发事件冒泡&#xff0c;mouseenter不会&#xff0c;mouseleave同理。 mousemove会触发事件冒泡&#xff0c;因此鼠标在范围区域内移动时会一直触发。 mouseenter只触发一次&#xff0c;鼠标移入后触发&#xff0c;鼠标移…
阅读更多...
绘制曲线python

绘制曲线python

文章目录 import matplotlib.pyplot as plt# 提供的数据 x= [1,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8,1.9,2,2.1,2.2,2.3,2.4,2.5,2.6,2.7,2.8,2.9,3,3.1,3.2,3.3,3.4,3.5,3.6,3.7,3.8,3.9,4,4.1,4.2,4.3,4.4,4.5,4.6,4.7,4.8,4.9,5,5.1,5.2,5.3,5.4,5.5,5.6,5.7,5.8,5.9,6,6.1,6.2…
阅读更多...
AI时代,这些绘画软件让你简单上手绘画

AI时代,这些绘画软件让你简单上手绘画

即时灵感 即时设计是一款基于云端的矢量编辑工具&#xff0c;可以帮助用户创建网页和移动应用程序原型、界面和可视化设计等。除此之外&#xff0c;即时设计还具备协同。实时预览、团队管理等多种功能&#xff0c;可以实现多个用户同时设计一个项目。 AI 绘画工具和即时设计虽…
阅读更多...
日撸java三百行day81-83

日撸java三百行day81-83

文章目录 说明CNN卷积神经网络1. 什么是CNN&#xff08;CNN基础知识&#xff09;1. 基本概念2.输入层3.卷积层3.1 图像3.2 卷积核3.3 偏置数3.4 滑动窗口步长3.5 特征图个数&#xff08;特征图通道数或深度&#xff09;3.6 边缘填充3.7 卷积过程例子 4. 激活函数5. 池化层6.全连…
阅读更多...
打破界限，图文档与物料清单完美互联

打破界限，图文档与物料清单完美互联

在现代企业的产品开发过程中&#xff0c;图文档和物料清单是不可或缺的重要信息。然而&#xff0c;由于数据来源多样、格式繁杂&#xff0c;图文档与物料清单之间的信息传递往往存在障碍。而PDM系统&#xff08;Product Data Management&#xff0c;产品数据管理&#xff09;的…
阅读更多...
MySQL插入数据的方法

MySQL插入数据的方法

插入数据方法&#xff1a; 1.insert into 表 values(value1, value2, value3....) 2.insert into 表 (字段1&#xff0c; 字段3&#xff0c; 字段5) values(value1, value2, value3) 3.insert into 表 [(字段1&#xff0c; 字段2&#xff0c; 字段3....)] values(value1, val…
阅读更多...
41.利用matlab 平衡方程用于图像（matlab程序）

41.利用matlab 平衡方程用于图像（matlab程序）

1.简述 白平衡 白平衡的英文为White Balance&#xff0c;其基本概念是“不管在任何光源下&#xff0c;都能将白色物体还原为白色”&#xff0c;对在特定光源下拍摄时出现的偏色现象&#xff0c;通过加强对应的补色来进行补偿。 所谓的白平衡是通过对白色被摄物的颜色还原&…
阅读更多...
C++经典排序算法详解

C++经典排序算法详解

目录 一、选择排序 二、冒泡排序 三、插入排序 一、选择排序 选择排序 选择排序&#xff08;Selection sort&#xff09;是一种简单直观的排序算法。它的工作原理是&#xff1a;第一次从待排序的数据元素中选出最小&#xff08;或最大&#xff09;的一个元素&#xff0c;存…
阅读更多...
Linux命令200例：join将两个文件按照指定的键连接起来分析

Linux命令200例：join将两个文件按照指定的键连接起来分析

&#x1f3c6;作者简介&#xff0c;黑夜开发者&#xff0c;全栈领域新星创作者✌。CSDN专家博主&#xff0c;阿里云社区专家博主&#xff0c;2023年6月csdn上海赛道top4。 &#x1f3c6;数年电商行业从业经验&#xff0c;历任核心研发工程师&#xff0c;项目技术负责人。 &…
阅读更多...
十二、ESP32控制步进电机

十二、ESP32控制步进电机

1. 运行效果 2. 步进电机 最大特点：能够控制旋转一定的角度 3. 步进电机原理
阅读更多...
P1433 吃奶酪（状态压缩dp）（内附封面）

P1433 吃奶酪（状态压缩dp）（内附封面）

吃奶酪 题目描述 房间里放着 n n n 块奶酪。一只小老鼠要把它们都吃掉&#xff0c;问至少要跑多少距离&#xff1f;老鼠一开始在 ( 0 , 0 ) (0,0) (0,0) 点处。 输入格式 第一行有一个整数&#xff0c;表示奶酪的数量 n n n。 第 2 2 2 到第 ( n 1 ) (n 1) (n1) 行…
阅读更多...
研发工程师玩转Kubernetes——emptyDir

研发工程师玩转Kubernetes——emptyDir

kubernets可以通过emptyDir实现在同一Pod的不同容器间共享文件系统。 正如它的名字&#xff0c;当Pod被创建时&#xff0c;emptyDir卷会被创建&#xff0c;这个时候它是一个空的文件夹&#xff1b;当Pod被删除时&#xff0c;emptyDir卷也会被永久删除。 同一Pod上不同容器之间…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023