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

一、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类的模拟实现希望可以帮助大家更好的理解

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Flink 问题之 No Watermark (Watermarks are only available if EventTime is used)

Flink 问题之 No Watermark (Watermarks are only available if EventTime is used)

问题背景 Flink-1.17.0在集群下&#xff0c;获取Kafka集群数据&#xff0c;进行流模式实时计算&#xff0c;Watermarks提示&#xff1a;No Watermark (Watermarks are only available if EventTime is used)&#xff1b; source数据源是从kafka中读取topic数据&#xff0c;经…
阅读更多...
【最新鸿蒙应用开发】——ArkUI两种开发范式

【最新鸿蒙应用开发】——ArkUI两种开发范式

在进行鸿蒙应用开发&#xff0c;openHarmony提供了一种页面开发框架叫做ArkUI方舟框架来进行页面布局的开发。 ArkUI方舟UI框架 针对不同的应用场景及技术背景&#xff0c;方舟UI框架提供了两种开发范式&#xff0c;分别是基于ArkTS的声明式开发范式&#xff08;简称“声明式…
阅读更多...
分享美好，高清无阻 - 直播极简联网解决方案

分享美好，高清无阻 - 直播极简联网解决方案

1、需求背景 随着移动互联网、UGC模式和直播平台的发展&#xff0c;网络直播的门槛日益降低&#xff0c;越来越多的人希望成为直播的主角。基于物联网的户外直播无线联网解决方案应运而生&#xff0c;满足直播者的需求。 户外直播无线联网解决方案提供了无处不在的直播体验&a…
阅读更多...
UniAnimate：华科提出人类跳舞视频生成新框架，支持合成一分钟高清视频

UniAnimate：华科提出人类跳舞视频生成新框架，支持合成一分钟高清视频

节前&#xff0c;我们星球组织了一场算法岗技术&面试讨论会&#xff0c;邀请了一些互联网大厂朋友、参加社招和校招面试的同学。 针对算法岗技术趋势、大模型落地项目经验分享、新手如何入门算法岗、该如何准备、面试常考点分享等热门话题进行了深入的讨论。 合集&#x…
阅读更多...
Java 环境配置 -- Java 语言的安装、配置、编译与运行

Java 环境配置 -- Java 语言的安装、配置、编译与运行

大家好&#xff0c;我是栗筝i&#xff0c;这篇文章是我的 “栗筝i 的 Java 技术栈” 专栏的第 002 篇文章&#xff0c;在 “栗筝i 的 Java 技术栈” 这个专栏中我会持续为大家更新 Java 技术相关全套技术栈内容。专栏的主要目标是已经有一定 Java 开发经验&#xff0c;并希望进…
阅读更多...
未来AI大模型的发展趋势

未来AI大模型的发展趋势

大家好&#xff0c;我是小悟 未来AI大模型的发展趋势无疑将是多元化、高效化、普及化以及人性化。随着技术的飞速进步&#xff0c;AI大模型将在各个领域中展现出更加广泛和深入的应用&#xff0c;成为推动社会进步的重要力量。 多元化是AI大模型发展的重要方向。随着数据量的…
阅读更多...
vue26:vue的环境搭建

vue26:vue的环境搭建

vue环境安装配置 在点击上方链接前&#xff0c;注意&#xff01;&#xff01;&#xff01;&#xff01;&#xff01;&#xff01;&#xff01;&#xff01; 下方的红字&#xff01;&#xff01;&#xff01;&#xff01;&#xff01;&#xff01;&#xff01;&#xff01;&am…
阅读更多...
在 Qt Creator 上创建 ROS 项目并新建/导入 ROS 包

在 Qt Creator 上创建 ROS 项目并新建/导入 ROS 包

0、引言 ⚠️ 在开始之前&#xff0c;您需要确保您已经为 Qt 配置好了 ROS 开发环境了。如果您还没有配置好&#xff0c;可以参考这篇文章 本文将着手探讨如何在 Qt Creator 上编辑 ROS 项目&#xff08;工作空间&#xff09;。 1、本教程使用到的相关软件或产品 Ubuntu 20.0…
阅读更多...
【AI基础】第四步：保姆喂饭级-langchain+chatglm2-6b+m3e-base

【AI基础】第四步：保姆喂饭级-langchain+chatglm2-6b+m3e-base

在第三步手动安装chatglm2-6b时&#xff0c;已经可以通过web进行交互。langchain重新封装了一下AI框架&#xff0c;提供更加友好的开发功能&#xff0c;类似于AI届的spring框架。langchain的安装过程也类似于上一步说的&#xff1a;【AI基础】第三步&#xff1a;纯天然手动安装…
阅读更多...
github异常问题总结

github异常问题总结

问题1&#xff1a; gitgitlab.gz.cvte.cn: Permission denied (publickey). fatal: Could not read from remote repository.Please make sure you have the correct access rights and the repository exists.解决方法&#xff1a; 这个错误表示 GitLab 服务器拒绝了你的 SSH…
阅读更多...
【MySQL】（基础篇二） —— MySQL初始用

【MySQL】（基础篇二） —— MySQL初始用

MySQL初始用 目录 MySQL初始用基本语法约定选择数据库查看数据库和表其它的SHOW 在Navicat中&#xff0c;大部分数据库管理相关的操作都可以通过图形界面完成&#xff0c;这个很简单&#xff0c;大家可以自行探索。虽然Navicat等图形化数据库管理工具为操作和管理数据库提供了非…
阅读更多...
【小白专用24.6.8】c#异步方法 async task调用及 await运行机制

【小白专用24.6.8】c#异步方法 async task调用及 await运行机制

await是C#中用于等待异步操作完成的关键字。它通常用于异步方法内部&#xff0c;使得在等待异步操作期间&#xff0c;线程可以继续执行其他操作&#xff0c;从而保持程序的响应性。 在使用await时&#xff0c;需要注意以下几点&#xff1a; 1. async修饰符&#xff1a; 使用…
阅读更多...
PgSQL技术内幕 - psql与服务端连接与交互机制

PgSQL技术内幕 - psql与服务端连接与交互机制

PgSQL技术内幕 - 客户端psql与服务端连接与交互机制 简单来说&#xff0c;PgSQL的psql客户端向服务端发起连接请求&#xff0c;服务端接收到请求后&#xff0c;fork出一个子进程&#xff0c;之后由该子进程和客户端进行交互&#xff0c;处理客户端的SQL等&#xff0c;并将结果返…
阅读更多...
用HAL库改写江科大的stm32入门-输入捕获原理图示

用HAL库改写江科大的stm32入门-输入捕获原理图示

原理与接线&#xff1a; &#xff08;输入捕获的结构&#xff09; cubeMx: PA11&#xff1a;
阅读更多...
【复现】含能量路由器的交直流混合配电网潮流计算

【复现】含能量路由器的交直流混合配电网潮流计算

目录 1 主要内容 2 理论及模型 3 程序结果 4 下载链接 1 主要内容 程序复现《含能量路由器的交直流混合配电网潮流计算》&#xff0c;主要是对算例4.1进行建模分析&#xff0c;理论和方法按照文献所述。能量路由器&#xff08;ER&#xff09;作为新兴的电力元器件&#xff…
阅读更多...
应用matplotlib.animation.FuncAnimation绘制摆线

应用matplotlib.animation.FuncAnimation绘制摆线

上次尝试了用matplotlib.animation.ArtistAnimation绘制摆线&#xff0c;实际上也可以用matplotlib.animation.FuncAnimation实现同样的功能。 导入相关文件 引用的库包括numpy&#xff0c;matplotlib&#xff0c;代码如下&#xff1a; import numpy as np import matplotli…
阅读更多...
字符串形成树形

字符串形成树形

字符串形成树形 有的时候我们形成树形不是以ID的关系进行匹配的而是以字符串进行形成 数据 CREATE TABLE `contract_main_org_info` (`id` bigint(20) NOT NULL COMMENT 组织单位id,`parent_id` int(11) NULL DEFAULT NULL COMMENT 父组织单位id,`org_name` varchar(255) CHA…
阅读更多...
mysql数据库密码破解

mysql数据库密码破解

一、Mysql数据库密码破解 ①一旦获取了网站一定的权限后&#xff0c;如果能够获取MSQL中保存用户数据&#xff0c;通过解密后&#xff0c;即可通过正常途径来访问数据库;一方面可以直接操作数据库中的数据&#xff0c;另一方面可以用来提升权限。 ②MySQL数据库用户密码跟其它…
阅读更多...
jmeter的infludb+grafana实时监控平台

jmeter的infludb+grafana实时监控平台

目的&#xff1a;可以实时查看到jmeter拷机信息 框架&#xff1a;将 Jmeter 的数据导入 InfluxDB &#xff0c;再用 Grafana 从 InfluxDB 中获取数据并以特定的模板进行展示 性能监控平台部署实践 一、influxDB 官网&#xff1a;https://www.influxdata.com/downloads/ wget h…
阅读更多...
第一篇红队笔记-百靶精讲之W1R3S-john

第一篇红队笔记-百靶精讲之W1R3S-john

https://download.vulnhub.com/w1r3s/w1r3s.v1.0.1.zip 主机发现 nmap端口扫描及思路 扫描某个网段 扫描单个ip所有端口 重复扫描单个ip具体端口 udp协议再来一次 漏洞扫描 FTP渗透 尝试匿名登陆 防止文件损坏 识别加密方式-hash-identifier base64 Web目录爆破…
阅读更多...
最新文章

Copyright @ 2022~2023