[C++初阶]string类的详解

news2024/11/27 5:41:24

一、string类的模拟实现

        上面已经对string类进行了简单的介绍，大家只要能够正常使用即可。在面试中，面试官总喜欢让我们来模拟实现string类，最主要是实现string类的构造、拷贝构造、赋值运算符重载以及析构函数。大家看下以下string类的实现是否有问题？
头文件:string.h 
#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include<iostream>
#include<assert.h>
using namespace std;

namespace STring
{
	class string
	{
	public:
		typedef char* iterator;
		typedef const char* const_iterator;

		iterator begin();
		iterator end();

		const_iterator begin() const;
		const_iterator end() const;

		string(const char* str = "");
		string(const string& s);
		string& operator=(const string& s);
		~string();
		const char* c_str() const;

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

		void reserve(size_t n);

		void push_back(char ch);
		void append(const char* str);

		string& operator+=(char ch);
		string& operator+=(const char* str);

		void insert(size_t pos, char ch);
		void insert(size_t pos, const char* str);
		void erase(size_t pos = 0, size_t len = npos);

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

		void swap(string& s);
		string substr(size_t pos = 0, size_t len = npos);

		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;
		void clear();
	private:
		char* _str;
		size_t _size;
		size_t _capacity;
		const static size_t npos;
	};
}

//string.cpp

#include"string.h"
namespace STring
{
	const size_t string::npos = -1;

	 string::iterator string::begin()
	{
		return _str;
	}
	string::const_iterator string::begin() const
	{
		return _str;
	}
	string::iterator string::end()
	{
		return _str + _size;
	}
	string::const_iterator string::end() const
	{
		return _str+_size;
	}
	string:: string(const char* str)
		:_size(strlen(str))
	{
		_str = new char[_size+1];
		_capacity = _size+1;
		strcpy(_str, str);
	}
	string::string(const string& s)
	{
		_str = new char[s._capacity];
		strcpy(_str, s._str);
		_size = s._size;
		_capacity = s._capacity;
	}
	string::~string()
	{
		delete[] _str;
		_str = nullptr;
		_size = _capacity = 0;
	}
	const char* string::c_str() const
	{
		return _str;
	}
	size_t string :: size() const
	{
		return _size;
	}
	void string::reserve(size_t n)
	{
		if (n > _capacity)
		{
			char* tmp = new char[n + 1];
			strcpy(tmp, _str);
			delete[] _str;
			_str = tmp;
			_capacity = n;
		}
	}
	void string::push_back(char ch)
	{
		if (_size == _capacity)
		{
			size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
			reserve(newcapacity);
		}
		_str[_size] = ch;
		_str[_size + 1] = '\0';
		++_size;
	}
	void string::append(const char* str)
	{
		size_t len = strlen(str);
		if (_size + len > _capacity)
		{
			reserve(_size + len);
		}
		strcpy(_str + _size, _str);
		_size += len;
		insert(_size, _str);
	}
	void string::insert(size_t pos, char ch)
	{
		assert(pos <= _size);
		if (_size = _capacity)
		{
			size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
			reserve(newcapacity);
		}
		size_t end = _size + 1;
		while (end > pos)
		{
			_str[end] = _str[end - 1] + 1;
			--end;
		}
		_str[pos] = ch;
		++_size;
	}
	void string::insert(size_t pos, const char* str)
	{
		assert(pos <= _size);
		int len = strlen(str);
		if (_size + len > _capacity)
		{
			reserve(_capacity+len);
		}
		size_t end = _size + len;
		while (end > pos+len+1)
		{
			_str[end] = _str[end - len];
			--end;
		}
		memcpy(_str+pos,str,len);
		_size += len;
	}
	void string::erase(size_t pos, size_t len)
	{
		assert(pos < _size);
		if (len >= _size - pos)
		{
			_str[pos] = '\0';
			_size = len;
		}
		else
		{
			strcpy(_str + pos, _str + pos + len);
			_size = len;
		}
	}
	size_t string::find(char ch, size_t pos)
	{
		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)
	{
		char* p = strstr(_str + pos, str);
		return p - _str;
	}
	void string::swap(string& s)
	{
		std::swap(_str, s._str);
		std::swap(_size, s._size);
		std::swap(_capacity, s._capacity);
	}
	string string::substr(size_t pos, size_t len)
	{
		if (len > _size - pos)
		{
			string sub(_str + pos);
			return sub;
		}
		else
		{
			string sub;
			sub.reserve(len);
			for (size_t i = 0; i < len; i++)
			{
				sub += _str[i + pos];
			}
			return sub;
		}
	}
	string& string:: operator=(const string& s)
	{
		if (this != &s)
		{
			char* tmp = new char[s._capacity];
			strcpy(tmp, s._str);
			delete[] _str;
			_str = tmp;
			_size = s._size;
			_capacity = s._capacity;
		}
		return *this;
	}

	char& string::operator[](size_t pos)
	{
		if (pos < _size)
			return _str[pos];
	}
	const char& string::operator[](size_t pos) const
	{
		if (pos < _size)
			return _str[pos];
	}
	string& string::operator+=(char ch)
	{
		push_back(ch);
		return *this;
	}
	string& string::operator+=(const char* str)
	{
		append(str);
		return *this;
	}
	bool string::operator<(const string& s) const
	{
		return strcmp(_str, s._str) < 0;
	}
	bool string::operator>(const string& s) const
	{
		return !(*this <= s);
	}
	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 strcmp(_str, s._str) == 0;
	}
	bool string::operator!=(const string& s) const
	{
		return !(*this == s);
	}
	void string::clear()
	{
		_str[0] = '\0';
		_size = 0;
	}
	istream& operator>> (istream& is, string& str)
	{
		str.clear();
		char ch = is.get();
		while (ch != ' ' && ch != '\n')
		{
			str += ch;
			ch = is.get();
		}
		return is;
	}

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

现在我们看到的是,我这边写的,接下来我将会对于这些内容进行解析,首先我这边的模拟实现都是基于理解和string。   

1.对于命名空间的定义

namespace STring
{
}

2.string类的定义和迭代器

class string
{
public:
private:
}

1）私有成员

这里的内容比较少。

    	char* _str;
		size_t _size;
		size_t _capacity;
		const static size_t npos;

2）公有成员

	    typedef char* iterator;
		typedef const char* const_iterator;

		iterator begin();
		iterator end();

		const_iterator begin() const;
		const_iterator end() const;

		//string();
		string(const char* str = "");
		string(const string& s);
		string& operator=(const string& s);
		~string();

		const char* c_str() const;

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

		void reserve(size_t n);

		void push_back(char ch);
		void append(const char* str);

		string& operator+=(char ch);
		string& operator+=(const char *str);
		 

		void insert(size_t pos, char ch);
		void insert(size_t pos, const char* str);
		void erase(size_t pos = 0, size_t len = npos);

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

		void swap(string& s);
		string substr(size_t pos = 0, size_t len = npos);

		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;
		void clear();

3）迭代器

我们都知道在string中我们常常使用迭代器来完成不少操作，我们知道迭代器其实就是一种指针，所以这里我们选择这样实现

typedef char* iterator;
typedef const char* const_iterator;

iterator begin();
iterator end();

const_iterator begin() const;
const_iterator end() const;

3.构造函数

声明：

string(const char* str = "");

这里我们选择用缺省函数保证字符串内容

下面是搞函数的内部实现:

string:: string(const char* str)
		:_size(strlen(str))
	{
		_str = new char[_size+1];
		_capacity = _size+1;
		strcpy(_str, str);
	}

首先我们用列表初始化得出存储的字符串大小,然后给字符串开辟空间,然后把求出空间(注意:字符串最后有'\0')然后通过拷贝函数把str字符串把内容拷贝给_str存储。

4.拷贝构造函数

声明：

string(const string& s);

函数内部实现：

	string::string(const string& s)
	{
		_str = new char[s._capacity];
		strcpy(_str, s._str);
		_size = s._size;
		_capacity = s._capacity;
	}

思路具体和上面差不多，开辟新空间，然后把字符串拷入，把大小和空间也拷贝。

5.析构函数

声明：

~string();

这里比较简单，就是把开辟的空间释放然后大小空间归零

string::~string()
	{
		delete[] _str;
		_str = nullptr;
		_size = _capacity = 0;
	}

6.获取字符串和存储的字符串大小

声明:

const char* c_str() const;
size_t size() const;

这个直接返回相应的值

const char* string::c_str() const
{
	return _str;
}
size_t string :: size() const
{
	return _size;
}

7.reserve

声明：

void reserve(size_t n);

函数内部：

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

这个函数（这里我们是大致模拟VS的）我们之前讲过如果n>_capacity就会扩容，否则无反应。

8.insert

声明：

		void insert(size_t pos, char ch);
		void insert(size_t pos, const char* str);

因为我们会用inset插入字符和字符串，所以这里我们定义两种

函数内部：

void string::insert(size_t pos, char ch)
	{
		assert(pos <= _size);
		if (_size = _capacity)
		{
			size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
			reserve(newcapacity);
		}
		size_t end = _size + 1;
		while (end > pos)
		{
			_str[end] = _str[end - 1] + 1;
			--end;
		}
		_str[pos] = ch;
		++_size;
	}
	void string::insert(size_t pos, const char* str)
	{
		assert(pos <= _size);
		int len = strlen(str);
		if (_size + len > _capacity)
		{
			reserve(_capacity+len);
		}
		size_t end = _size + len;
		while (end > pos+len+1)
		{
			_str[end] = _str[end - len];
			--end;
		}
		memcpy(_str+pos,str,len);
		_size += len;
	}

这里的实现和我们以前写顺序表的插入差不多，把目标位置以及之后的字符串后移动，知道空出需要的空间大小，然后插入。

9.push_back和append

声明：

        void push_back(char ch);
		void append(const char* str);

着两个一个是尾插入，一个是插入字符串

void string::push_back(char ch)
	{
		if (_size == _capacity)
		{
			size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
			reserve(newcapacity);
		}
		_str[_size] = ch;
		_str[_size + 1] = '\0';
		++_size;
	}
	void string::append(const char* str)
	{
		size_t len = strlen(str);
		if (_size + len > _capacity)
		{
			reserve(_size + len);
		}
		strcpy(_str + _size, _str);
		_size += len;
		insert(_size, _str);
	}

这个就是正常尾插的实现，但是append是字符串，为了方便我们可以直接调用insert

10.erase

声明：

void erase(size_t pos = 0, size_t len = npos);

这是声明我直接仿照的cplusplus的定义

注意我们需要

const size_t string::npos = -1;

函数内部：

void string::erase(size_t pos, size_t len)
{
	assert(pos < _size);
	if (len >= _size - pos)
	{
		_str[pos] = '\0';
		_size = len;
	}
	else
	{
		strcpy(_str + pos, _str + pos + len);
		_size = len;
	}
}

这里很简单就是把pos后删除，我们考虑两种情况，一种是直接删除，一种是删除部分

11.find

声明：

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

这个函数真正的底层实现很难，这里因为我们只是模拟实现，我们可以这样子解决

函数内部：

	size_t string::find(char ch, size_t pos)
	{
		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)
	{
		char* p = strstr(_str + pos, str);
		return p - _str;
	}

12.swap

声明：

	void swap(string& s);

函数内部：

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

很简单的内容，没什么好说的

13.substr

这个就是很简单的一个函数

声明：

string substr(size_t pos = 0, size_t len = npos);

函数内部:

string string::substr(size_t pos, size_t len)
	{
		if (len > _size - pos)
		{
			string sub(_str + pos);
			return sub;
		}
		else
		{
			string sub;
			sub.reserve(len);
			for (size_t i = 0; i < len; i++)
			{
				sub += _str[i + pos];
			}
			return sub;
		}
	}

ps:上面我用了一些运算符重载，建议结合后面的运算符重载观看

14.运算符重载

这里是我所有使用的运算符重载以完成模拟实现

声明：

string& operator=(const string& s);
char& operator[](size_t pos);
const char& operator[](size_t pos) const;
string& operator+=(char ch);
string& operator+=(const char *str);
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;

函数实现

string& string:: operator=(const string& s)
	{
		if (this != &s)
		{
			char* tmp = new char[s._capacity];
			strcpy(tmp, s._str);
			delete[] _str;
			_str = tmp;
			_size = s._size;
			_capacity = s._capacity;
		}
		return *this;
	}

	char& string::operator[](size_t pos)
	{
		if (pos < _size)
			return _str[pos];
	}
	const char& string::operator[](size_t pos) const
	{
		if (pos < _size)
			return _str[pos];
	}
	string& string::operator+=(char ch)
	{
		push_back(ch);
		return *this;
	}
	string& string::operator+=(const char* str)
	{
		append(str);
		return *this;
	}
	bool string::operator<(const string& s) const
	{
		return strcmp(_str, s._str) < 0;
	}
	bool string::operator>(const string& s) const
	{
		return !(*this <= s);
	}
	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 strcmp(_str, s._str) == 0;
	}
	bool string::operator!=(const string& s) const
	{
		return !(*this == s);
	}

=号是重载的拷贝构造

[]号是实现下标访问

+=是重载push_back和append

剩下的都是完成判断的

15.clear

声明：

void clear();

函数内部：

直接把_st[0]='\0',_size=0即可

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

16.输入输出流的重载

这里我们之前写日期类的时候应该写过，我就不多讲了，直接展示

声明：

istream& operator>> (istream& is, string& str);
ostream& operator<< (ostream& os, const string& str);

注意：不要声明在类中

函数内部：

istream& operator>> (istream& is, string& str)
{
		str.clear();
		char ch = is.get();
		while (ch != ' ' && ch != '\n')
		{
			str += ch;
			ch = is.get();
		}
		return is;
}

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

以上就是我们对于string类的模拟实现希望可以帮助大家更好的理解

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

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

相关文章

【IC验证】03 UVM

【IC验证】03 UVM

阅读更多...
深度学习-CPGNet部署

深度学习-CPGNet部署

1、导出onnx提示以下警告 问题&#xff1a; 原因&#xff1a; 模型是torch1.8导出的&#xff0c;对应的onnx版本是11&#xff0c;但是onnx是torch1.12生成的&#xff0c;对应的onnx版本是16。 解决方法&#xff1a; 将onnx.export函数的属性从opset_version16改成opset_version…
阅读更多...
【数据结构】查找（顺序查找、二分查找、索引顺序查找、二叉排序树、平衡排序树、B树、B+树、哈希表）

【数据结构】查找（顺序查找、二分查找、索引顺序查找、二叉排序树、平衡排序树、B树、B+树、哈希表）

目录 数据结构——查找何为查找1. 查找表2. 关键字3. 查找方法效果评价指标——平均查找长度ASL(Average Search Length) 静态查找表1.顺序查找2.二分查找二分查找判定树 3.静态查找表—索引顺序表的查找索引顺序查找表的算法原理&#xff1a; 动态查找树表1. 二叉排序树2. 二叉…
阅读更多...
7种方法教你如何解决msvcp140_1.dll丢失问题，一键修复dll丢失问题

7种方法教你如何解决msvcp140_1.dll丢失问题，一键修复dll丢失问题

msvcp140_1.dll 是 Microsoft Visual C 2015 Redistributable 的一部分&#xff0c;它提供了运行时所需的 C 标准库的实现。这个 DLL 文件对于依赖 Visual C 2015 编译的应用程序至关重要&#xff0c;因为它包含了程序运行时所必需的函数和资源。 作用 运行时支持&#xff1a…
阅读更多...
点击一张图片，到最后渲染到屏幕，都经历了哪些流程？

点击一张图片，到最后渲染到屏幕，都经历了哪些流程？

文章目录 图像的表示在iOS设备上 图像的表示 位图&#xff08;bitmap&#xff09;是一种常见的图像表示方式&#xff0c;它通过记录图像中每个像素的颜色信息来表示整张图片。以下是位图表示图片的基本原理&#xff1a; 像素网格&#xff1a; 位图将图像分解成一个网格&…
阅读更多...
【数据结构】十一、图的应用：Prime算法、Dijkstra算法和拓扑排序

【数据结构】十一、图的应用：Prime算法、Dijkstra算法和拓扑排序

目录 一、最小生成树&#xff08;Prime算法&#xff09; 1&#xff09;概念 2&#xff09;最小生成树的应用 3&#xff09;最小生成树的创建 4&#xff09;代码实现 五、最短路径 1&#xff09;Dijkstra算法 Question&#xff1a; 六、拓扑排序 1&#xff09;概念 2&…
阅读更多...
机器学习--线性模型和非线性模型的区别？哪些模型是线性模型，哪些模型是非线性模型？

机器学习--线性模型和非线性模型的区别？哪些模型是线性模型，哪些模型是非线性模型？

文章目录 引言线性模型和非线性模型的区别线性模型非线性模型 总结线性模型非线性模型 引言 在机器学习和统计学领域&#xff0c;模型的选择直接影响到预测的准确性和计算的效率。根据输入特征与输出变量之间关系的复杂程度&#xff0c;模型可以分为线性模型和非线性模型。线性…
阅读更多...
【SpringBoot + Vue 尚庭公寓实战】根据类型查询标签列表接口实现（五）

【SpringBoot + Vue 尚庭公寓实战】根据类型查询标签列表接口实现（五）

【SpringBoot Vue 尚庭公寓实战】根据类型查询标签列表接口实现&#xff08;五&#xff09; 文章目录 【SpringBoot Vue 尚庭公寓实战】根据类型查询标签列表接口实现&#xff08;五&#xff09;1、查看接口2、进行开发 1、查看接口 启动项目 访问&#xff1a;http://localho…
阅读更多...
《软件定义安全》之一：SDN和NFV：下一代网络的变革

《软件定义安全》之一：SDN和NFV：下一代网络的变革

第1章 SDN和NFV&#xff1a;下一代网络的变革 1.什么是SDN和NFV 1.1 SDN/NFV的体系结构 SDN SDN的体系结构可以分为3层&#xff1a; 基础设施层由经过资源抽象的网络设备组成&#xff0c;仅实现网络转发等数据平面的功能&#xff0c;不包含或仅包含有限的控制平面的功能。…
阅读更多...
【Redis学习笔记05】Jedis客户端（中）

【Redis学习笔记05】Jedis客户端（中）

Jedis客户端 1. 命令 1.1 String类型 1.1.1 常见命令 SET命令 语法&#xff1a;SET key value [EX seconds | PX milliseconds] [NX|XX] 说明&#xff1a;将string类型的value值设置到指定key中&#xff0c;如果之前该key存在&#xff0c;则会覆盖原先的值&#xff0c;原先…
阅读更多...
有什么借助伦敦金行情软件才能做的技术分析方法吗？

有什么借助伦敦金行情软件才能做的技术分析方法吗？

现在伦敦金交易都可以在网上去完成&#xff0c;这样我们就必须借助伦敦金行情软件。由于科学技术的发展&#xff0c;现在的伦敦金行情软件不光提供交易买卖的功能&#xff0c;它还有图表分析、时间周期选择等等各种各样的功能&#xff0c;这样丰富了我们的分析手段。那么下面我…
阅读更多...
qt4-qt5 升级（2)-GUI-UTF-8-GBK-QTextCode-字符集乱码

qt4-qt5 升级（2)-GUI-UTF-8-GBK-QTextCode-字符集乱码

MFC与QT的消息机制的区别_qt信号槽机制与mfc的消息映射机制的区别-CSDN博客 1.QT4-QT5差别 kits构建 控件&#xff0c;信号与槽 ui修改好后点击编译会自动生成 ui_XXX.h 聚合的关系&#xff0c;不是拥有的关系。 QWidget 和QWindow有什么差别&#xff1f; 2.VS2019-QT5 构建…
阅读更多...
Xsens动作捕捉系统：角色动画制作与运动分析领域的先进工具

Xsens动作捕捉系统：角色动画制作与运动分析领域的先进工具

随着传感器技术的不断进步&#xff0c;动作捕捉技术现在更加趋向于民用化&#xff0c;拥有价格优势的惯性动作捕捉系统现在更多的出现在独立动画工作室与国内外多所高校的实际项目应用中。 凭借无场地限制、价格优惠、校准使用方便、数据采集精确等多项优势&#xff0c;Xsens惯…
阅读更多...
KEIL5如何打开KEIL4的GD工程

KEIL5如何打开KEIL4的GD工程

GD官方提供的很多KEIL例程为KIEL4的版本&#xff0c;读者使用的时候可能会碰到使用KEIL5打开KEIL4的工程会报错以及无法找到芯片选型的问题&#xff0c;具体表现如下图所示。 我们该怎么办呢&#xff1f; 下面为大家介绍两种方法&#xff1a; 第一种方法是在keil4的工程后缀u…
阅读更多...
数据结构---树与二叉树

数据结构---树与二叉树

个人介绍 hello hello~ &#xff0c;这里是 code袁~&#x1f496;&#x1f496; &#xff0c;欢迎大家点赞&#x1f973;&#x1f973;关注&#x1f4a5;&#x1f4a5;收藏&#x1f339;&#x1f339;&#x1f339; &#x1f981;作者简介&#xff1a;一名喜欢分享和记录学习的…
阅读更多...
数据结构笔记 3 串 数组 广义表

数据结构笔记 3 串 数组 广义表

以下了解即可&#xff0c;暂时没发现有什么考点 参考&#xff1a; 【数据结构】——多维数组和广义表_数据结构loc-CSDN博客 相对应的题目&#xff1a; 他这个数组不是从0开始的&#xff0c;是从1开始的&#xff0c;所以为了配合公式要减1 下面这道题又不一样&#xff0c;它是…
阅读更多...
小白教程--- kali（po解）WIFI密码 （图文教程）

小白教程--- kali（po解）WIFI密码 （图文教程）

kali学得好&#xff0c;牢饭少不了&#xff01;&#xff01;&#xff01; 原理&#xff1a; 模拟WiFi的已连接设备&#xff0c;强制让其下线重连&#xff0c;获取其握手包&#xff0c;使用密码字典&#xff08;宝丽&#xff09;婆洁。 环境&#xff08;准备工作&#xff09;&a…
阅读更多...
STM32 uc/OS-III多任务程序

STM32 uc/OS-III多任务程序

目录 一、项目创建 二、代码移植 1、uC/OS-III源码处理 2、KEIL文件配置 ​编辑3、文件修改 启动文件 ​编辑app_cfg.h includes.h bsp.c和bsp.h main.c lib_ cfg.h app.c和app.h 三、总结 学习目标&#xff1a; 学习嵌入式实时操作系统&#xff08;RTOS&#xf…
阅读更多...
【Tool】Matlab 数据分析可视化

【Tool】Matlab 数据分析可视化

一、问题描述 近期围绕imu总是出现问题&#xff0c;自己整理了一下将数据可视化的工具 二、imu 类 1. 待处理数据格式 # yaw roll pitch time -2.08131 -0.0741765 0.0200713 121.281000000 -2.08724 -0.0745256 0.0197222 121.301000000 -2.093 -0.075747…
阅读更多...
引入Springcloud--Sleuth-链路追踪中MDC是如何获取到traceid和何时放入traceid的

引入Springcloud--Sleuth-链路追踪中MDC是如何获取到traceid和何时放入traceid的

在分布式项目中需要引入 spring-cloud-starter-sleuth框架来记录跟踪请求在不同服务之前流转的路径。在整个流转路径通过traceid将所有的路径给串联起来。 项目中需要保存traceid来实现日志快速搜索和定位&#xff0c;可以通过MDC.get("traceId")获取到traceId。 …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023