【C++】STL | 模拟实现简易string

news2025/2/2 15:47:21

目录

1. 框架搭建

 2. 迭代器的实现

3. string的拷贝构造和赋值（深拷贝）

拷贝构造

赋值构造

4. string的增删查改

reserve 接口

resize 接口

push_back 接口

append 接口

operator+=() 实现

 insert 接口

 erase 接口

find 接口

substr 接口

clear 接口

流插入和流提取 

5. 用于比较的操作符重载函数

operator<

operator==

 其它复用

6. 源码分享

写在最后：

1. 框架搭建

首先啊，我们需要搭建好一个框架，

然后在往里面填充内容。

那搭建框架主要包括这几个点：

1. 基本的默认成员函数

2. 必须的成员变量

3. 常用的简单接口（先让代码跑起来）

来看代码：

#pragma once

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

#include <string.h>

using namespace std;

namespace xl {
	class string {
	private:
		char* _str;
		size_t _size;
		size_t _capacity;

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

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

	public:
		char& operator[](size_t pos) {
			assert(pos < _size);
			return _str[pos];
		}

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

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

		size_t size() const {
			return _size;
		}
	};
}

实现功能包括：

1. 构造和析构函数

2. 基本的 [ ] 访问

3. 可供转换类型的 c_str

4. 以及容量相关的 size 

我们就能先跑起来一段遍历：

#include "string.h"

int main()
{
	xl::string s1("hello");
	cout << s1.c_str() << endl;

	for (int i = 0; i < s1.size(); i++) {
		cout << s1[i] << " ";
	}
	cout << endl;

	return 0;
}

输出：

 2. 迭代器的实现

迭代器可能是指针，也可能不是，

不过在string里面，迭代器就是指针。

我们把迭代器实现到类里面，因为标准库中的迭代器，就存在类内，

我们直接通过类域就能访问到。

来看代码：

public:
	typedef char* iterator;

	iterator begin() {
		return _str;
	}

	iterator end() {
		return _str + _size;
	}

这样我们就能直接跑起来：

#include "string.h"

int main()
{
	xl::string s1("hello");
	cout << s1.c_str() << endl;

	for (int i = 0; i < s1.size(); i++) {
		cout << s1[i] << " ";
	}
	cout << endl;

	xl::string::iterator it = s1.begin();
	while (it != s1.end()) {
		cout << *it << " ";
		it++;
	}
	cout << endl;
 
	return 0;
}

输出：

 但是啊，这样只支持了普通对象的迭代器，

还有const对象，所以我们要再实现一份：

public:
	typedef char* iterator;
	typedef const char* const_iterator;

	iterator begin() {
		return _str;
	}

	iterator end() {
		return _str + _size;
	}

	const_iterator begin() const {
		return _str;
	}

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

我们可以观察一下，

使用 const 迭代器确实是禁止访问了：

 而使用普通迭代器是可以修改指向的值的：

void test2() {
	xl::string s1("hello");

	xl::string::const_iterator cit = s1.begin();
	while (cit != s1.end()) {
		//*cit += 1;
		cout << *cit << " ";
		cit++;
	}
	cout << endl;

	xl::string::iterator it = s1.begin();
	while (it != s1.end()) {
		*it += 1;
		cout << *it << " ";
		it++;
	}
	cout << endl;
}

输出：

3. string的拷贝构造和赋值（深拷贝）

拷贝构造

需要新开一块空间：

string(const string& s) {
	_str = new char[s._capacity + 1];
	memcpy(_str, s._str, s.size() + 1);
	_size = s._size;
	_capacity = s._capacity;
}

赋值构造

我们就直接采取删除旧空间，开辟新空间，拷贝数据的策略：

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

 上面的这种中规中矩的方法，我们称之为传统写法，

那么有传统写法，当然还有现代写法，来看这种写法：

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

// 现代写法
string& operator=(string tmp) {
	swap(tmp);
	return *this;
}

我们实现了一个string类内的一个swap，通过拷贝构造形成的 tmp 帮我们打工，

然后我们再通过 swap 白嫖 tmp 的内容即可。

我个人认为这种方法其实本质上就是对拷贝构造的复用。

实际上，拷贝构造也可以用现代写法：

string(const string& s)
	: _str(nullptr)
	, _size(0)
	, _capacity(0)
{
	string tmp(s._str);
	swap(tmp);
}

发现没有，拷贝构造的现代写法本质也是一个复用，

他复用的就是我们实现的构造函数。 

4. string的增删查改

在实现那些花里胡哨的接口之前啊，

先把扩容的问题搞定再说：

reserve 接口

根据给的 n 的大小直接扩容即可：

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

resize 接口

还有一种扩容方法就是resize，不过string一般很少用resize，

来看实现：

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

push_back 接口

 string的 push_back 就是尾插一个元素，

采取的是二倍扩容的机制（这个看个人喜好，也有1.5倍扩容的）

void push_back(char ch) {
	if (_size == _capacity) {
		// 2倍扩容
		reserve(_capacity == 0 ? 4 : _capacity * 2);
	}
	_str[_size] = ch;
	_size++;
	_str[_size] = '\0';
}

append 接口

append 是尾插一段字符串，

扩容机制我使用的是按需扩容。

void append(const char* str) {
	size_t len = strlen(str);
	if (_size + len > _capacity) {
		// 至少扩容到 _size + len
		reserve(_size + len);
	}
	memcpy(_str + _size, str, len + 1);
	_size += len;
}

当然，我们其实更喜欢使用 +=：

operator+=() 实现

当然，这个函数我们就直接复用前面实现的push_back和append就行：

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

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

这用起来当然是爽多了：

void test4() {
	xl::string s1("hello");
	cout << s1.c_str() << endl;

	s1 += " ";
	s1 += "a";
	s1 += "a";
	s1 += "a";
	s1 += "a";
	s1 += "a";
	s1 += "a";
	s1 += " ";
	s1 += "string";
	cout << s1.c_str() << endl;
}

输出：

 insert 接口

实际上STL的string 实现了很多比较冗余的重载，

作为学习，我们就只实现最核心的调用方法。

insert我们实现两种重载：

void insert(size_t pos, size_t n, char ch) {

}

void insert(size_t pos, const char* str) {

}

先来实现第一种，插入一种字符：

void insert(size_t pos, size_t n, char ch) {
	assert(pos <= _size);
	if (_size + n > _capacity) {
		// 至少扩容到_size + n
		reserve(_size + n);
	}
	// 挪动数据
	size_t end = _size;
	while (end >= pos && end != npos) {
		_str[end + n] = _str[end];
		end--;
	}
	// 填值
	for (size_t i = 0; i < n; i++) _str[pos + i] = ch;

	_size += n;
}

第二种，插入一个字符串：

实现方法都是相似的：

void insert(size_t pos, const char* str) {
	assert(pos <= _size);
	size_t len = strlen(str);
	if (_size + len > _capacity) {
		// 至少扩容到_size + len
		reserve(_size + len);
	}
	// 挪动数据
	size_t end = _size;
	while (end >= pos && end != npos) {
		_str[end + len] = _str[end];
		end--;
	}
	// 填值
	for (size_t i = 0; i < len; i++) _str[pos + i] = str[i];

	_size += len;
}

我们来测试一下：

void test5() {
	xl::string s1("hello");
	cout << s1.c_str() << endl;

	s1.insert(5, 3, 'x');
	s1.insert(0, "string ");
	cout << s1.c_str() << endl;
}

输出：

 erase 接口

如果删除的字符超过了有的字符，或者是没有说明删除的字符数，就全部删完：

void erase(size_t pos, size_t len = npos) {
	assert(pos <= _size);
	if (len == npos || pos + len >= _size) {
		_size = pos;
		_str[pos] = '\0';
	}
	else {
		size_t end = pos + len;
		while (end <= _size) {
			_str[pos++] = _str[end++];
		}
		_size -= len;
	}
}

我们可以测试一下：

void test5() {
	xl::string s1("hello");
	cout << s1.c_str() << endl;

	s1.insert(5, 3, 'x');
	s1.insert(0, "string ");
	cout << s1.c_str() << endl;

	s1.erase(10, 3);
	cout << s1.c_str() << endl;

	s1.erase(2, 100);
	cout << s1.c_str() << endl;
}

输出：

find 接口

如果是单个字符，直接找就行了：

size_t find(char ch, size_t pos = 0) {
	for (size_t i = pos; i < _size; i++) {
		if (_str[i] == ch) return i;
	}
	return npos;
}

字符串的话我们用strstr暴力匹配就行：

size_t find(const char* str, size_t pos = 0) {
	const char* ptr = strstr(_str + pos, str);
	if (ptr) return ptr - _str;
	else return npos;
}

substr 接口

截取字符串的操作：

string substr(size_t pos = 0, size_t len = npos) {
	assert(pos <= _size);
	size_t n = len + pos;
	if (len == npos || pos + len > _size) {
		n = _size;
	}
	string tmp;
	tmp.reserve(n);
	for (size_t i = pos; i < n; i++) {
		tmp += _str[i];
	}
	return tmp;
}

来测试一下：

void test6() {
	xl::string s1("hello string");
	cout << s1.c_str() << endl;
	
	size_t pos = s1.find('s');
	cout << s1.substr(pos, 3).c_str() << endl;

	pos = s1.find('s');
	cout << s1.substr(pos, 100).c_str() << endl;
}

输出：

clear 接口

顺便实现一下：

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

流插入和流提取 

这个我们需要实现在类外，因为操作符的顺序要求，

先来看流插入：

ostream& operator<<(ostream& out, const string& s) {
	for (auto e : s) cout << e;
	return out;
}

再来看流提取：

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

测试时间~

void test7() {
	string s1;
	cin >> s1;
	cout << s1 << endl;
}

输出：

5. 用于比较的操作符重载函数

我们还是一样的操作，先实现两个，在复用到全部：

operator<

我们用库函数memcmp实现：

bool operator<(const string& s) {
	int ret = memcmp(_str, s._str, _size < s._size ? _size : s._size);
	return ret == 0 ? _size < s._size : ret < 0;
}

operator==

bool operator==(const string& s) {
	return memcmp(_str, s._str, _size < s._size ? _size : s._size) == 0;
}

 其它复用

bool operator<=(const string& s) {
	return *this < s || *this == s;
}

bool operator>(const string& s) {
	return !(*this <= s);
}

bool operator>=(const string& s) {
	return !(*this < s);
}

bool operator!=(const string& s) {
	return !(*this == s);
}

6. 源码分享

#pragma once

#include <iostream>
#include <string>

#include <assert.h>
#include <string.h>

using namespace std;

namespace xl {
	class string {
	private:
		char* _str;
		size_t _size;
		size_t _capacity;

		const static size_t npos = -1; // 可以这样用，但不建议，违背了C++的语法准则（建议声明和定义分离）

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

		 传统写法
		//string(const string& s) {
		//	_str = new char[s._capacity + 1];
		//	memcpy(_str, s._str, s._size + 1);
		//	_size = s._size;
		//	_capacity = s._capacity; 
		//}

		// 现代写法
		string(const string& s) 
			: _str(nullptr)
			, _size(0)
			, _capacity(0)
		{
			string tmp(s._str);
			swap(tmp);
		}

		 传统写法
		//string& operator=(const string& s) {
		//	if (this != &s) {
		//		char* tmp = new char[s._capacity + 1];
		//		memcpy(tmp, s._str, s._size + 1);
		//		delete[] _str;
		//		_str = tmp;
		//	}
		//	return *this;
		//}

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

		// 现代写法
		string& operator=(string tmp) {
			swap(tmp);
			return *this;
		}

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

	public:
		typedef char* iterator;
		typedef const char* const_iterator;

		iterator begin() {
			return _str;
		}

		iterator end() {
			return _str + _size;
		}

		const_iterator begin() const {
			return _str;
		}

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

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

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

		void push_back(char ch) {
			if (_size == _capacity) {
				// 2倍扩容
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}
			_str[_size] = ch;
			_size++;
			_str[_size] = '\0';
		}
		
		void append(const char* str) {
			size_t len = strlen(str);
			if (_size + len > _capacity) {
				// 至少扩容到 _size + len
				reserve(_size + len);
			}
			memcpy(_str + _size, str, len + 1);
			_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, size_t n, char ch) {
			assert(pos <= _size);
			if (_size + n > _capacity) {
				// 至少扩容到_size + n
				reserve(_size + n);
			}
			// 挪动数据
			size_t end = _size;
			while (end >= pos && end != npos) {
				_str[end + n] = _str[end];
				end--; 
			}
			// 填值
			for (size_t i = 0; i < n; i++) _str[pos + i] = ch;

			_size += n;
		}

		void insert(size_t pos, const char* str) {
			assert(pos <= _size);
			size_t len = strlen(str);
			if (_size + len > _capacity) {
				// 至少扩容到_size + len
				reserve(_size + len);
			}
			// 挪动数据
			size_t end = _size;
			while (end >= pos && end != npos) {
				_str[end + len] = _str[end];
				end--;
			}
			// 填值
			for (size_t i = 0; i < len; i++) _str[pos + i] = str[i];

			_size += len;
		}

		void erase(size_t pos, size_t len = npos) {
			assert(pos <= _size);
			if (len == npos || pos + len >= _size) {
				_size = pos;
				_str[pos] = '\0';
			}	
			else {
				size_t end = pos + len;
				while (end <= _size) {
					_str[pos++] = _str[end++];
				}
				_size -= len;
			}
		}

		size_t find(char ch, size_t pos = 0) {
			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 char* ptr = strstr(_str + pos, str);
			if (ptr) return ptr - _str;
			else return npos;
		}

		string substr(size_t pos = 0, size_t len = npos) {
			assert(pos <= _size);
			size_t n = len + pos;
			if (len == npos || pos + len > _size) {
				n = _size;
			}
			string tmp;
			tmp.reserve(n);
			for (size_t i = pos; i < n; i++) {
				tmp += _str[i];
			}
			return tmp;
		}

	public:
		char& operator[](size_t pos) {
			assert(pos < _size);
			return _str[pos];
		}

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

		bool operator<(const string& s) {
			int ret = memcmp(_str, s._str, _size < s._size ? _size : s._size);
			return ret == 0 ? _size < s._size : ret < 0;
		}

		bool operator==(const string& s) {
			return _size == s._size && memcmp(_str, s._str, _size) == 0;
		}

		bool operator<=(const string& s) {
			return *this < s || *this == s;
		}

		bool operator>(const string& s) {
			return !(*this <= s);
		}

		bool operator>=(const string& s) {
			return !(*this < s);
		}

		bool operator!=(const string& s) {
			return !(*this == s);
		}

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

		size_t size() const {
			return _size;
		}

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

	ostream& operator<<(ostream& out, const string& s) {
		for (auto e : s) cout << e;
		return out;
	}

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

写在最后：

以上就是本篇文章的内容了，感谢你的阅读。

如果感到有所收获的话可以给博主点一个赞哦。

如果文章内容有遗漏或者错误的地方欢迎私信博主或者在评论区指出~

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

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

相关文章

若依前端使用图标

若依前端使用图标

图标 前后端分离的若依前端使用的图标分为两种&#xff1a;分别是svg图标和element的图标 svg图标 1&#xff0c;使用方法 <!-- icon-class 为 icon 的名字; class-name 为 icon 自定义 class--> <svg-icon icon-class"password" class-namecustom-cla…
阅读更多...
C++ for Reverse Words in a String

C++ for Reverse Words in a String

这道题是Leetcode上的151.反转字符串中的单词这道题&#xff0c;这道题给出的题目要求是&#xff1a; 给你一个字符串 s &#xff0c;请你反转字符串中 单词 的顺序。 单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。 返回 单词 顺序颠倒…
阅读更多...
Pycharm--Low Memory

Pycharm--Low Memory

Low Memory The IDE is running low on memory and this might affect performance. Please consider increasing available heap. 卡成翔 -- 已经配置成4096了啊
阅读更多...
【UE4 塔防游戏系列】07-子弹对敌人造成伤害

【UE4 塔防游戏系列】07-子弹对敌人造成伤害

目录 效果 步骤 一、让子弹拥有不同伤害 二、敌人拥有不同血量 三、修改“BP_TowerBase”逻辑 四、发射的子弹对敌人造成伤害 效果 步骤 一、让子弹拥有不同伤害 为了让每一种子弹拥有不同的伤害值&#xff0c;打开“TotalBulletsCategory”&#xff08;所有子弹的父类…
阅读更多...
java线上故障排查套路总结

java线上故障排查套路总结

线上故障主要会包括cpu、磁盘、内存以及网络问题&#xff0c;而大多数故障可能会包含不止一个层面的问题&#xff0c;所以进行排查时候尽量四个方面依次排查一遍。同时例如jstack、jmap等工具也是不囿于一个方面的问题的&#xff0c;基本上出问题就是df、free、top 三连&#x…
阅读更多...
（五）Flask之深入剖析路由源码

（五）Flask之深入剖析路由源码

路由&#xff08;Route&#xff09;这个概念在所有web框架中都非常重要&#xff0c;它是用于定义URL和对应的处理函数&#xff08;视图&#xff09;之间的映射关系。通过定义路由&#xff0c;可以使web框架应用程序能够响应不同的URL请求&#xff0c;并执行相应的逻辑。 源码剖…
阅读更多...
老码农的管理拙见

老码农的管理拙见

【引子】 尽管自己从业了20多年&#xff0c;也曾管理过从几个人到几百人的团队&#xff0c;但个人非常不愿意或者不敢讨论团队管理的问题&#xff0c;因为管理是以结果为导向的&#xff0c; 具有后验的特征&#xff0c;而且管理中面对的最大复杂性是人&#xff0c;每个人都是不…
阅读更多...
安装pycocotools报错“fatal error: Python.h: No such file or directory“ | 已解决

安装pycocotools报错“fatal error: Python.h: No such file or directory“ | 已解决

记录一段报错&#xff1a; pycocotools/_mask.c:6:10: fatal error: Python.h: No such file or directory#include "Python.h"^~~~~~~~~~compilation terminated./tmp/pip-build-env-crtws8v6/overlay/lib/python3.8/site-packages/Cython/Compiler/Main.py:369: F…
阅读更多...
mssql 以xml类型为存储过程传递不确定数量的参数

mssql 以xml类型为存储过程传递不确定数量的参数

mssql 以xml类型传递不确定数量的参数 存储过程xml 处理在存储过程中参数在存储过程中使用 xml 作为参数存储过程 相信各位小伙伴在使用数据库的过程中，或多或少的建立了一些存储过程，并且带有一些参数，用来增加存储过程的适用性。 类似老顾的截图这样的，通常，我们需要将…
阅读更多...
华为云CodeArts Check IDE插件体验之旅

华为云CodeArts Check IDE插件体验之旅

1 开发者的思考 近年来&#xff0c;ChatGPT的来临像一场突然出现的风暴&#xff0c;程序员是否马上被取代的担忧出现在媒体上了&#xff0c;作为软件开发小白&#xff0c;前不久我也陷入了这样的深思之中&#xff0c;但认真的想了下&#xff0c;ChatGPT就如自动驾驶一样&#…
阅读更多...
MySQL的安装与配置

MySQL的安装与配置

今天要和大家唠唠关于数据库的那些事儿&#xff01;按照加哥一贯的调性&#xff0c;咱还是从花边八卦聊起。先来简 单地梳理一下数据库、MySQL发展的时间线&#xff1a; 1970年&#xff0c;在IBM公司工作的数学家 E.F.Codd 发表了数学论文《大型共享数据库的关系数据模型》 &am…
阅读更多...
每日站会如此简单，为什么总是开不好？

每日站会如此简单，为什么总是开不好？

美式足球或橄榄球等运动的球队&#xff0c;会在每场比赛上场前聚在一起开个短会。这种临场短会能让整个球队的成员在比赛过程中互通信息、相互协作。 每日站会是敏捷开发的重要流程之一。对于团队而言&#xff0c;每日站会与这种赛前短会类似&#xff0c;让每个成员都了解到团…
阅读更多...
2023年上海/成都/深圳CSPM-3中级国标项目管理认证招生

2023年上海/成都/深圳CSPM-3中级国标项目管理认证招生

CSPM-3中级项目管理专业人员认证&#xff0c;是中国标准化协会&#xff08;全国项目管理标准化技术委员会秘书处&#xff09;&#xff0c;面向社会开展项目管理专业人员能力的等级证书。旨在构建多层次从业人员培养培训体系&#xff0c;建立健全人才职业能力评价和激励机制的要…
阅读更多...
Matplotlib坐标轴范围

Matplotlib坐标轴范围

Matplotlib 可以根据自变量与因变量的取值范围&#xff0c;自动设置 x 轴与 y 轴的数值大小。当然&#xff0c;您也可以用自定义的方式&#xff0c;通过 set_xlim() 和 set_ylim() 对 x、y 轴的数值范围进行设置。 当对 3D 图像进行设置的时&#xff0c;会增加一个 z 轴&#x…
阅读更多...
日志收集工具

日志收集工具

日志管理的第一步是收集日志数据。日志收集可能是一项具有挑战性的任务&#xff0c;因为某些系统&#xff08;如防火墙、入侵检测系统和入侵防御系统&#xff09;具有生成大量日志数据的 EPS&#xff08;每秒事件数&#xff09;。为了实时收集和处理日志数据&#xff0c;无论日…
阅读更多...
【历史上的今天】6 月 7 日：图灵逝世；Kubernetes 开源版本发布；分组交换网络发明者出生

【历史上的今天】6 月 7 日：图灵逝世；Kubernetes 开源版本发布；分组交换网络发明者出生

整理 | 王启隆 透过「历史上的今天」&#xff0c;从过去看未来&#xff0c;从现在亦可以改变未来。 今天是 2023 年 6 月 7 日&#xff0c;在 1742 年的今天&#xff0c;普鲁士数学家克里斯蒂安哥德巴赫在写给瑞士数学家莱昂哈德欧拉的通信中&#xff0c;提出了以下的猜想&…
阅读更多...
手机APP三维建模不清晰？单反相机接入移动端来袭！

手机APP三维建模不清晰？单反相机接入移动端来袭！

为什么我们需要单反相机接入 当前&#xff0c;手机本身的像素还满足不了考古级的精度要求&#xff0c;考古现场都是用专业相机对文物进行拍照&#xff0c;再把照片导入到电脑进行建模。“考古工作比较细致&#xff0c;有时候一来一回挺费事的。”云端地球的忠实用户&#xff0…
阅读更多...
Linux5.16 Ceph集群

Linux5.16 Ceph集群

文章目录 计算机系统5G云计算第四章 LINUX Ceph集群一、Ceph1.存储基础1&#xff09;单机存储设备2&#xff09;单机存储的问题3&#xff09;商业存储解决方案4&#xff09;分布式存储&#xff08;软件定义的存储 SDS&#xff09;5&#xff09;分布式存储的类型 2.Ceph 简介3.C…
阅读更多...
微信公众号登录

微信公众号登录

整个流程&#xff0c;1.前端调用授权url 接口(创建一个重定向的请求方法&#xff0c;访问自动回调方法wechat.mp.callbackUrl的地址)。2.微信自动回调方法里判断该用户是需要注册还是直接登录(如果直接登录就返回token&#xff09; 是注册还是登录返回到配置文件中的 wechat.mp…
阅读更多...
LIMS系统应用于第三方实验室的意义

LIMS系统应用于第三方实验室的意义

金现代LIMS实验室管理系统是将实验室业务从线下转到线上&#xff0c;按照 CNAS 规范进行合规化管理&#xff0c;并提升实验室工作效率的信息化系统。随着实验室业务的不断发展&#xff0c;实验室的规模逐渐扩大&#xff0c;样品数量和检测项目不断增加&#xff0c;数据管理需求…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023