程序员经验分享-hwhale

C++：模拟实现string类

2023-11-16

本篇主要介绍模拟实现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;
	}
}
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

c

知识总结

模拟实现

C++：模拟实现string类 的相关文章

  • “参数按值传递，仅复制一次；考虑移动它” - 对于引用类型避免这种情况

    我正在 CLion 2021 3 中编写 C 代码 它使用整洁的支票 https clang llvm org extra clang tidy checks list html 在我的代码中 我有一个轻量级参考类 假设它看起来像这样 st

  • 从多播数据包中获取发送者 ip

    如何获取组播 UDP 数据包发送者的 IP 当前代码以同步 阻塞方式设置 参见下面的注释 这是代码 private void receive string mcastGroup SetMcastGroup s new Socket Addr

  • 用于在 n LSBits 之后清除 m 位的掩码

    我在一次采访中被问到这个问题 要清除 16 位整数的 n 位之后的 m 位 假设数字是 10010010010100101 清除 LSBit 中 5 位后的三位 之前 1001100111011001 之后 1001100100011001

  • Bjarne Stroustrup 的 C++ 编程和实践第 2 版中的使用单参数排序

    我正在阅读 Bjarne Stroustrup new C PP 第二版 他在其中使用了排序方法 sort someVector 使用此方法编译代码时出现以下错误 3 IntelliSense 没有重载函数 sort 的实例与参数列表匹配

  • libc++ 中短字符串优化的机制是什么？

    这个答案 https stackoverflow com a 10319672 1805388给出了短字符串优化 SSO 的高级概述 但是 我想更详细地了解它在实践中是如何工作的 特别是在 libc 实现中 字符串必须有多短才能符合 SSO

  • EF 6：映射复杂类型集合？

    EF 6 代码优先 是否支持复杂类型集合 值对象集合 映射 我知道它支持复杂类型 但还没有找到我们拥有复杂类型集合的示例 例如 假设您有一个名为 Student 的实体 其中包含联系人集合 对于 NH 我可以简单地说 Student 有一个

  • 如何重写 C++ 标准库类函数？

    如何重写 C 标准库类函数 在我的应用程序中 我使用ofstream代码中许多不同位置的对象 现在我想在Linux Ubuntu中以不同的权限模式打开文件 但open的函数ofstream没有参数来指定它创建的文件的权限模式 现在我想覆盖o

  • C++ 将 HashMap 对象返回给 Java

    我有一个 JAVA 调用的 JNI 函数 需要构建并返回一个 HashMap 映射的键是 String 相应的值是 boolean 或 Boolean 任何一个都可以 只要它有效 使用我当前的代码 如下 该字符串已成功添加到返回的映射中 并

  • 编译器之间的重载分辨率不同

    我构建了以下我的问题的最小示例 include

  • 在.NET windows窗体中向TableLayoutPanel添加动态控件

    我想在单击按钮时动态地将控件添加到面板 但我想整理一下位置 例如 我想要两个并排的文本框宽度相等 占用面板的相等空间 见下图 正如您在上图中看到的 单击按钮时 将添加控件 但我在使用 TableLayoutPanel 时遇到问题 请参阅下面

  • 如何使用现代 GCC 抑制“-fpermissive”错误？

    我正在尝试编译一些不合格的代码C 17 https en wikipedia org wiki C 2B 2B17 但我遇到了以下问题 pragma GCC diagnostic push pragma GCC diagnostic ign

  • 如何使用 mongo-cxx-driver 设置 Visual Studio 项目设置？

    我已经在 Windows 10 上成功构建了用于 C 的 MongoDB 驱动程序版本 3 0 3 CMAKE INSTALL PREFIX C mongo cxx driver 但我不知道如何在 Visual Studio 2015 中设

  • 结构体指针运算符猜想（理论）

    结构体指针的使用非常频繁 因此有一个特殊的运算符 gt 下面的表达式是等价的 x y x gt y 将此运算符简单地视为如下定义的预处理器宏是否公平 define x gt x 为什么或者为什么不 或者它从一开始就被编码为运算符 这有何不同

  • 在 C# 中使用 Nsubstitute 模拟具有固定参数的可选参数的函数返回 null

    我一直在尝试模拟一个包含带有固定参数的可选参数的函数 但每次我得到一个空值 这是我在接口中定义的函数 我想模拟它 List GetEntitiesByIDs List

  • 处理后退导航 Windows 10 (UWP)

    在我的 Xaml 页面中 我有一个框架 我正在尝试使用 backButton 事件来在frame 内导航 所以我尝试使用这段代码 public MainPage this InitializeComponent if Windows Fou

  • C++11正则表达式匹配[重复]

    这个问题在这里已经有答案了 我正在尝试在 C 11 中进行相当简单的正则表达式匹配 使用 gcc 4 7 2 但我遇到了很多麻烦 尝试使用构建模式 std regex unquoted R regex s s regex 导致构造函数抛出一

  • 显式移动构造函数

    尝试编译以下代码 struct Foo explicit Foo void explicit Foo Foo rhs Foo bar void return Foo 出现以下错误 调用 Foo 的隐式删除复制构造函数 嗯 很明显复制者被隐式

  • 创建 ip 网络数据包 [关闭]

    很难说出这里问的是什么 这个问题是含糊的 模糊的 不完整的 过于宽泛的或修辞性的 无法以目前的形式得到合理的回答 如需帮助澄清此问题以便重新打开 访问帮助中心 help reopen questions 我必须使用任何协议手动创建自己的网络

  • 使用 lambda 从数组中选择每隔一个元素[重复]

    这个问题在这里已经有答案了 C 4 0 如何使用 lambda 表达式完成以下操作 int a new int 8 0 1 2 3 4 5 6 7 Now fetch every second element so that we get

  • 如何在 MVC 中点击链接的主视图中渲染部分视图？

    我有像下面这样的控制器操作方法将从数据库返回所有详细信息 public ActionResult Index BusDataContext db new BusDataContext List

随机推荐

  • 滤波电容的选择

    滤波电容的选择 理论部分 参考案例 一 参考案例 二 其他案例 理论部分 滤波电容主要看容值和耐压值 电容尺寸 容值x耐压值 电容价格 容值x耐压值 电解和钽电容耐压值要x2倍使用 陶瓷电容至少x1 5倍使用 电容选择的逻辑是频率越高 电容

  • 编译Linux内核的一些报错

    内核版本3 18 6 编译目标架构为x86 64 硬件实际架构为x86 64 1 error code model kernel does not support PIC mode 修改 kernel path arch x86 Makef

  • 微信小程序-获取用户手机号码

    1 在获取手机号码之前 要先进行登陆 使用wx login进行登录 登录成功会返回一个code 将code传给后台 获取登录密钥session key等信息 将这些信息存入data 2 使用type getPhoneNumber 的butt

  • 快速fcm matlab,Matlab中的FCM算法代码及中文详解

    Matlab中的FCM算法代码及中文详解 转自 http xiaozu renren com xiaozu 106512 336681453 function center U obj fcn FCMClust data cluster n

  • 【日积月累】后端刷题日志

    刷题日志 说说对Java的理解 JAVA中抽象类和接口之间的区别 Java中的泛型 和equals 的区别 八种基本数据类型与他们的包装类 在一个静态方法内调用一个非静态成员为什么是非法的 静态方法与实例方法有何不同 重载与重写 深拷贝浅拷

  • Sqli-labs 博客目录

    之前学习了一遍 sqli labs 这是巩固复习一遍 代码全部手敲 加深印象 Sqli labs 博客目录 Sqli labs Less01 04 基于错误的sql注入 GET Sqli labs Less05 06 报错型sql盲注 GE

  • 第12章 K8s进阶篇-细粒度权限控制

    12 1 什么是RBAC 负责k8s整个集群控制的 不同人员权限的管控 开发 测试 管理员等 12 2 RBAC配置解析 12 3 RBAC常用配置示例 参考官方文档 使用 RBAC 鉴权 Kubernetes 正常是通过yaml文件创建

  • 替代空格

    include

  • host文件的工作原理及应用

    host文件的工作原理及应用 Hosts文件是一个用于存储计算机网络中节点信息的文件 它可以将主机名映射到相应的IP地址 实现DNS的功能 它可以由计算机的用户进行控制 一 Hosts文件基本介绍 Hosts文件的存储位置在不同的操作系统中

  • java 16进制与字符串互相转

    字符串转换成为16进制 无需Unicode编码 param str return public static String str2HexStr String str char chars 0123456789ABCDEF toCharAr

  • 各种字符串Hash函数比较

    转自 beyond the void 常用的字符串Hash函数还有ELFHash APHash等等 都是十分简单有效的方法 这些函数使用位运算使得每一个字符都对最后的函数值产生影响 另外还有以MD5和SHA1为代表的杂凑函数 这些函数几乎不

  • get和post详解

    Get和post是表单提交数据的两种基本方式 get请求数据通过域名后缀url传送 用户可见 不安全 post请求数据通过在请求报文正文里传输 相对比较安全 get是通过url传递表单值 post通过url看不到表单域的值 get传递的数据

  • OceanBase 4.1解读：我们想给用户一个开箱即用的OceanBase部署运维工具

    欢迎访问 OceanBase 官网获取更多信息 https www oceanbase com 关于作者 肖磊 OceanBase 产品专家 负责 OceanBase 运维管控体系产品规划与设计 包括安装部署工具 OBD OAT 运维管控平

  • 小程序领取微信卡券

    小程序领取微信卡券 获取 access token api ticket singuare等完整版 转载自 感谢这位作者 https www cnblogs com w53064 p 9771232 html 返回主页 啊傑Plus 博客园

  • Java实现，手写二叉树

    一 基本概念 二叉树 每个节点最多有两个子树的结构 满二叉树 除了最后一层没有任何节点外 每一层的所有节点都有两个子节点的二叉树 完全二叉树 结构与满二叉树类似 不同点在于最后一层可以不满 但最后一层的节点必须连续集中再最左边 二叉搜索树

  • Redis高级的相关问题总结

    1 rdb和aof有什么区别 你们在工作中如何使用redis的持久化策略 1 rdb定时对整个内存做快照 aof记录每一次执行的命令 2 rdb两次备份之间会丢失数据 aof取决于刷盘策略 相对比较完整 3 rdb宕机恢复速度快 aof恢复

  • XSL-FO Blocks（块）

    XSL FO 的输出位于块区域中 XSL FO 页面 流以及块 内容 块 会 流 入 页面 中 然后输出到媒介 XSL FO 输出通常被嵌套在

  • 监控神器-普罗米修斯Prometheus的安装

    最近看了些AIOPS的资料 对于里面提及的一个普罗米修斯Prometheus起了兴趣 首先是联想到异形 哈哈 去看了一下 普罗米修斯还真是厉害 而且还是开源的 真是搬砖党的福音 功能 在业务层用作埋点系统 Prometheus支持多种语言

  • 面向对象和面向过程的区别，Java为什么说它性能低

    面向对象相比于面向过程 面向对象的代码延展性更好 拿上面的例子举例如果现在要把存储的对象不是大象了而是狮子 那么很明显 面向过程要的方法要所有大象为狮子 面向对象的方法只要改一下关于这个改动的方法也就是 存储 内容 不仅仅是修改 添加删除等

  • C++：模拟实现string类

    文章目录 Iterator类 capacity类 Element access 类 Modifiers类 String operations类 类外成员函数 头文件总括 本篇主要介绍模拟实现string类 string中有相当多的内容 这里

热门标签