【C++】：STL中的string类的增删查改的底层模拟实现

在这里插入图片描述
本篇博客仅仅实现存储字符(串)的string
同时由于C++string库设计的不合理，我仅实现一些最常见的增删查改接口
接下来给出的接口都是基于以下框架：

private:
		char* _str;//思考如何不用const
		size_t _size;
		size_t _capacity;
		//这样写可以
		const static size_t string::npos = -1;
		//下面这种写法也可以->和上述写法产生矛盾
		const static size_t string::npos;
	};
	//静态变量只能在类外面定义 上述两种定义容易产生矛盾

📚1.string默认构造 | 析构函数 | 拷贝构造 | 赋值重载

//无参默认构造
string()
	:_str(new char[1])
	, _size(0)
	, _capacity(0)
{
	_str[0] = '\0';
}
//有参默认构造
string(const char* str="\0")//不能写'\0'
	//->类型不匹配
	:_size(strlen(str))
{
	_capacity = _size;
	_str = new char[_capacity + 1];
	strcpy(_str, str);
}

C++string标准库中，无参构造并不是空间为0，直接置为空指针 而是开一个字节，并存放‘\0’
C++中支持无参构造一个对象后，直接在后面插入数据，也从侧面说明了这点
由于C++构造函数不管写不写都会走初始化列表的特性，所以这里也走初始化列表
string中，_capacity和_size都不包含空指针，所以带参构造要多开一个空间，用来存储’\0’

📚2.string类析构函数

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

📚3.拷贝构造

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

📚4.赋值重载

传统写法：

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

现代写法：

//法二
void swap(string& s)
{
	std::swap(_str, s._str);
	std::swap(_size, s._size);
	std::swap(_capacity, s._capacity);
}
string& operator=(string tmp)
{
	swap(tmp);
	return *this;
}

📚5.iterator迭代器和基于范围的for循环

在C++中，范围for在底层是通过迭代器来实现的 所以只要实现了迭代器，就支持范围for
而迭代器类似于指针，迭代器可以被看作是指针的一种泛化，它提供了类似指针的功能，可以进行解引用操作、指针运算等
以下提供了const迭代器和非const迭代器：

typedef char* iterator;
const typedef 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;
}

📚6.运算符重载operator[ ]

这里我们和库中一样，提供以下两个版本

//可读可写
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& operator[](size_t pos) const
{
	assert(pos < _size);
	return _str[pos];
}

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

这里我用了this指针指向的是private里面的数据 然后和s对象所对应的值作比较 能和strcpy函数联合起来用 能达到同样的效果 这是一个很不错的想法

📚7.容量相关：size | resize | capacity | reserve

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

在C++中，我们一般不缩容
所以实现reserve时容量调整到n首先判断目标容量n是否大于当前容量。如果小于就不做处理，否则先开辟n+1个内存空间（多出来的一个用于存储‘\0’），然后将原有数据拷贝到新空间strcpy会将’\0’一并拷贝过去然后释放就空间，并让_str指向新空间，同时更新_capacity

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

当n<_size时，只需将下标为n的地址处的数据改为’\0’
其他情况，我们直接统一处理。直接复用reserve()函数将_capacity扩到n 然后用将[_size, n)中的数据全部初始化为ch 这里博主给ch一个初始值’\0’，但ch不一定为’\0’，所以要将下标为n处的地址初始化为’\0’

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

📚8.数据相关：push_back | append | operator+= | insert | erase

尾插：push_back
尾插首先检查扩容，在插入数据

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

}

append尾部插入字符串

void append(const char* str)
{
	size_t len = strlen(str);
	if (_size + len > _capacity)
	{
		reserve(_size + len);
	}
	strcpy(_str + _size, str);
	//strcat(_str, str);
	_size += len;
}

operator+=()字符/字符串
operator+=()字符、字符串可以直接复用push_back和append

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

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

insert插入字符/字符串
下面给出各位初学者容易犯的错误：

void insert(size_t pos, char ch)
{
	assert(pos <= _size);
	//扩容
	if (_size == _capacity)
	{
		reserve(_capacity == 0 ? 4 : _capacity * 2);
	}
	//挪动数据
	size_t end = _size;
	while (end >= pos)
	{
		_str[end+1] = _str[end];
		end--;
	}
	_str[pos] = ch;
	_size++
}

假设是在头插字符，end理论上和pos(即0)比较完后就减到-1，在下一次循环条件比较时失败，退出循环 但遗憾的是end是size_t类型，始终>=0, 会导致死循环
解决办法如下
从end从最后数据的后一位开始，每次将前一个数据移到当前位置。最后条件判断就转化为end>pos，不会出现死循环这种情况

void 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--;
	}
	//插入数据，更新_size
	_str[pos] = ch;
	_size++;
}

insert插入字符串

void insert(size_t pos, const char* str)
{
	int len = strlen(str);
	if (_size + len > _capacity)
	{
		reserve(_size + len);
	}
	
	size_t end = _size+1;
	while (end > pos)
	{
		_str[end + len-1] = _str[end-1];
		end--;
	}
	strncpy(_str + pos, str, len);
	_size += len;
}

erase
erase分两种情况：
从pos开始，要删的数据个数超过的字符串，即将pos后序所有数据全部情况 直接将pos处数据置为’\0’即可
从pos开始，要删的数据个数没有超出的字符串。所以只需要从pos+len位置后的所有数据向前移动从pos位置覆盖原数据即可

void erase(size_t pos, size_t len = npos)
{
	//len==nppos意思是字串全部删除
	if (len==npos || pos + len >= _size)
	{
		//有多少，删多少
		_str[pos] = '\0';
		_size = pos;
	}
	else
	{
		size_t begin = pos + len;
		while (begin <= _size)
		{
			_str[begin - len] = _str[begin];
			begin++;
		}
		_size -= len;
	}
}

📚9.关系操作符重载：< | == | <= | > | >= | !=

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

📚10.find查找字符 | 字符串 | substr

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* sub, size_t pos = 0)
{
	const char* p = strstr(_str + pos, sub);
	if (p)
	{
		return p - _str;
	}
	else
	{
		return npos;
	}
}

strsub()模拟实现
strsub目标长度可能越界string，也可能还有没有。但不管是那种情况，最后都需要拷贝数据。所以这里我们可以先将len真实长度计算出来，在拷贝数据

string substr(size_t pos, size_t len = npos)const
{
	string s;
	size_t end = pos + len;
	//目标字符越界string,更新len
	if (len == npos || end >= _size)
	{
		len = _size - pos;
		end = _size;
	}
	//拷贝数据
	s.reserve(len);
	for (size_t i = pos; i < end; i++)
	{
		s += _str[i];
	}
	return s;
}

📚11.流插入和流提取<< | >>

由于前面我们实现了迭代器，所以最简单的方式就是范围for

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

流提取>>
流提取比较特殊。在流提取前需要将原有数据全部清空。同时由于>>无法获取空字符和换行符()(都是作为多个值之间的间隔)，直接流提取到ostream对象中，没法结束类似于C语言中scanf, 换行符和空字符仅仅只是起到判断结束的作用，但scanf无法获取到它们
所以这里博主直接调用istream对象中的get()函数类似于C语言中的getchar()函数

class string
{
	void clear()
	{
		_str[0] = '\0';
		_size = 0;
	}
private:
	char* _str;
	size_t _capacity;
	size_t _size;
};

istream& operator>>(istream& in, string& s)
	{
		s.clear();
		char ch;
		//in >> ch;
		ch = in.get();

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

📚12.完整代码

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<vector>
#include<list>
#include<string>
#include<assert.h>
using namespace std;
namespace success
{
	class string
	{
	public:
		typedef char* iterator;
		iterator begin()
		{
			return _str;
		}
		iterator end()
		{
			return _str + _size;
		}
		string()
			:_str(new char[1])
			, _size(0)
			, _capacity(0)
		{
			_str[0] = '\0';
		}
		string(const char* str="\0")//不能写'\0'
			//->类型不匹配
			:_size(strlen(str))
		{
			_capacity = _size;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}
		const char* c_str()
		{
			return _str;
		}
		string(const string& str)
			:_size(str._size)
		{
			_capacity = str._capacity;
			_str = new char[str._capacity + 1];
			strcpy(_str, str._str);
		}
		char& operator[](size_t pos) const
		{
			assert(pos < _size);
			return _str[pos];
		}
		size_t size()
		{
			return _size;
		}
		string& operator=(const string& str)
		{
			if (this != &str)
			{
				delete[] _str;
				_str = new char[str._capacity + 1];
				_size = str._size;
				_capacity = str._capacity;
				strcpy(_str, str._str);
			}
			return *this;
		}
		~string()
		{
			delete[] _str;
			_str = nullptr;
			_size = 0;
			_capacity = 0;
		}
		bool operator>(const string& s)
		{
			return strcpy(_str, s._str) == 0;
		}
		bool operator==(const string& s)
		{
			return strcpy(_str, s._str) == 0;
		}
		bool operator>=(const string& s)
		{
			return *this > s || *this == s;
		}
		bool operator<(const string& s)
		{
			return !(*this >= s);
			//return strcpy(_str, s._str) == 0;
		}
		bool operator!=(const string& s)
		{
			return !(*this == s);
		}
		void resize(size_t n, char ch = '\0');
		void reserve(size_t n)
		{
			char* tmp = new char[n + 1];
			strcpy(tmp, _str);
			delete[] _str;
			_str = tmp;
			_capacity = n;
		}
		void push_back(char ch)
		{
			if (_size + 1 > _capacity)
			{			
				reserve(_capacity * 2);
			}
			_str[_size] = ch;
			++_size;
			_str[_size] = '\0';
		}
		void append(const char* str)
		{
			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}
			strcpy(_str + _size, str);
			//strcat(_str, str);
			_size += len;
		}
		void insert(size_t pos, char ch)
		{
			assert(pos <= _size);
			if (_size + 1 > _capacity)
			{
				reserve(2 * _capacity);
			}
			size_t end = _size;
			while (end >= pos)
			{
				_str[end + 1] = _str[end];
				--end;
			}
			_str[pos] = ch;
			++_size;
		}
		void insert(size_t pos, const char* str)
		{
			int len = strlen(str);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}
			
			size_t end = _size+1;
			while (end > pos)
			{
				_str[end + len-1] = _str[end-1];
				end--;
			}
			strncpy(_str + pos, str, len);
			_size += len;
		}
		void erase(size_t pos, size_t len = npos)
		{
			//len==nppos意思是字串全部删除
			if (len==npos || pos + len >= _size)
			{
				//有多少，删多少
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				size_t begin = pos + len;
				while (begin <= _size)
				{
					_str[begin - len] = _str[begin];
					begin++;
				}
				_size -= len;
			}
		}
	private:
		char* _str;//思考如何不用const
		size_t _size;
		size_t _capacity;
		//这样写可以
		const static size_t string::npos = -1;
		//下面这种写法也可以->和上述写法产生矛盾
		const static size_t string::npos;
	};
	//静态变量只能在类外面定义 上述两种定义容易产生矛盾
	void test_string1()
	{
		string s1("hello bit");
		string s2("hello bit.");
		cout << s1.c_str() << endl;
		cout << s2.c_str() << endl;
		s2[0]++;
		cout << s2.c_str() << endl;
	}
	void test_string2()	
	{
		string s3 = ("hello bit");
		string s4("hello bit.");
		cout << s3.c_str() << endl;
		cout << s4.c_str() << endl;
		string s5(s3);
		cout << s5.c_str() << endl;
		s3[0]++;
		s4 = s3;
		cout << s3.c_str() << endl;
		cout << s5.c_str() << endl;
	}

	void test_string3()
	{
		string s1 = "hello bit";
		string::iterator it = s1.begin();
		while (it != s1.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;
	}
}

#include"string.h"
#include<Windows.h>
#include<iostream>
using namespace std;
int main()
{
	try
	{
		success::test_string2();
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
	success::test_string1();
	success::test_string2();
	success::test_string3();
	//string a = "hello world";
	//string b = a;//在用一个表达式中 构造+拷贝构造
	//->编译器优化成一次构造
	//a.c_str() == b.c_str()比较的是存储字符串位置的地址
	//if (a.c_str() == b.c_str())
	//{
	//	cout << "true" << endl;
	//}
	//else cout << "false" << endl;//案1
	//string c = b;
	//c = "";
	//if (a.c_str() == b.c_str())	
	//{
	//	cout << "true" << endl;
	//}
	//else cout << "false" << endl;
	//a = "";
	//if (a.c_str() == b.c_str())
	//{
	//	cout << "true" << endl;
	//}
	//else cout << "false" << endl;、
	
	
	//string str("Hello Bit.");
	//str.reserve(111);
	//str.resize(5);
	//str.reserve(50);
	//cout << str.size() << ":" << str.capacity() << endl;
	//str.reserve(111); //调整容量为111
	//str.resize(5);   //调整元素个数为5
	//str.reserve(50);  //调整容量为50，由于调整的容量小于已有空间容量，故容量不会减小
	//所以size = 5 capacity = 111


	//string strText = "How are you?";
	//string strSeparator = " ";
	//string strResult;
	//int size_pos = 0;
	//int size_prev_pos = 0;
	//while ((size_pos = strText.find_first_of(strSeparator, size_pos)) != string::npos)
	//{
	//	strResult = strText.substr(size_prev_pos, size_pos - size_prev_pos);
	//	cout << strResult << " ";
	//	size_prev_pos = ++size_pos;
	//}
	//if (size_prev_pos != strText.size())
	//{
	//	strResult = strText.substr(size_prev_pos, size_pos - size_prev_pos);
	//	cout << strResult << " ";
	//}
	//cout << endl;
	system("pause");
	return 0;
}

// 为了和标准库区分，此处使用String
class String
{
public:
/*String()
:_str(new char[1])
{*_str = '\0';}
*/
//String(const char* str = "\0") 错误示范
//String(const char* str = nullptr) 错误示范
String(const char* str = "")
{
// 构造String类对象时，如果传递nullptr指针，可以认为程序非
if (nullptr == str)
{
assert(false);
return;
}
_str = new char[strlen(str) + 1];
strcpy(_str, str);
}
~String()
{
if (_str)
{
delete[] _str;
_str = nullptr;
}
}
private:
char* _str;
};
// 测试
void TestString()
{
String s1("hello bit!!!");
String s2(s1);
}

在这里插入图片描述
说明：上述String类没有显式定义其拷贝构造函数与赋值运算符重载，此时编译器会合成默认的，当用s1构造s2时，编译器会调用默认的拷贝构造。最终导致的问题是，s1、s2共用同一块内存空间，在释放时同一块空间被释放多次而引起程序崩溃，这种拷贝方式，称为浅拷贝
浅拷贝
浅拷贝：也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为还有效，所以当继续对资源进项操作时，就会发生发生了访问违规
深拷贝
如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供
在这里插入图片描述
传统版写法的String类

class String
{
public:
String(const char* str = "")
{
// 构造String类对象时，如果传递nullptr指针，可以认为程序非
if (nullptr == str)
{
assert(false);
return;
}
_str = new char[strlen(str) + 1];
strcpy(_str, str);
}
String(const String& s)
: _str(new char[strlen(s._str) + 1])
{
strcpy(_str, s._str);
}
String& operator=(const String& s)
{
if (this != &s)
{
char* pStr = new char[strlen(s._str) + 1];
strcpy(pStr, s._str);
delete[] _str;
_str = pStr;
}
return *this;
}
~String()
{
if (_str)
{
delete[] _str;
_str = nullptr;
}
}
private:
char* _str;
};

现代版写法的String类

class String
{
public:
String(const char* str = "")
{
if (nullptr == str)
{
assert(false);
return;
}
_str = new char[strlen(str) + 1];
strcpy(_str, str);
}
String(const String& s)
: _str(nullptr)
{
String strTmp(s._str);
swap(_str, strTmp._str);
}
// 对比下和上面的赋值那个实现比较好？
String& operator=(String s)
{
swap(_str, s._str);
return *this;
}
/*
String& operator=(const String& s)
{
if(this != &s)
{
String strTmp(s);
swap(_str, strTmp._str);
}
return *this;
}
*/
~String()
{
if (_str)
{
delete[] _str;
_str = nullptr;
}
}
private:
char* _str;
};

在这里插入图片描述
写时拷贝就是一种拖延症，是在浅拷贝的基础之上增加了引用计数的方式来实现的
引用计数：用来记录资源使用者的个数。在构造时，将资源的计数给成1，每增加一个对象使用该资源，就给计数增加1，当某个对象被销毁时，先给该计数减1，然后再检查是否需要释放资源，如果计数为1，说明该对象时资源的最后一个使用者，将该资源释放；否则就不能释放，因为还有其他对象在使用该资源
在这里插入图片描述

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

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

相关文章

csdn最新最全的Selenium教程：定位frame框架中的元素

csdn最新最全的Selenium教程：定位frame框架中的元素

定位frame框架中的元素 在web应用中经常会出现frame嵌套的应用&#xff0c;假设页面上有A,B两个frame,其中B在A内&#xff0c;那么定位B中的内容则需要先到A&#xff0c;再到B。 switch_to.frame方法可以把当前定位的主题切换到frame里&#xff0c;在frame里实际是嵌套了另外一…
阅读更多...
Android Studio xml文件id爆红但是项目可以运行

Android Studio xml文件id爆红但是项目可以运行

这种原因是你的R文件太大了&#xff08;超过了Android Studio的上限25.6M了&#xff09; 解决办法如下&#xff1a; Help -> Edit Custom Properties -> create custom properties?(yes) ->添加 idea.max.intellisense.filesize5000 最后需要重启Android Studio
阅读更多...
【double check 读写锁】

【double check 读写锁】

使用double check 读写锁 读多写少场景 记录下 //来源 jdbc 中的查询连接信息 //public abstract class ConnectionUrl implements DatabaseUrlContainer public static ConnectionUrl getConnectionUrlInstance(String connString, Properties info) {if (connString null…
阅读更多...
算法刷题-动态规划2（继续）

算法刷题-动态规划2（继续）

算法刷题-动态规划2 珠宝的最高价值下降路径最小和 珠宝的最高价值 题目 大佬思路 多开一行使得代码更加的简洁 移动到右侧和下侧 dp[ i ][ j ]有两种情况&#xff1a; 第一种是从上面来的礼物最大价值&#xff1a;dp[ i ][ j ] dp[ i - 1 ][ j ] g[ i ][ j ] 第二种是从左…
阅读更多...
【MySQL】宝塔面板结合内网穿透实现公网远程访问

【MySQL】宝塔面板结合内网穿透实现公网远程访问

文章目录 前言1.Mysql服务安装2.创建数据库3.安装cpolar3.2 创建HTTP隧道4.远程连接5.固定TCP地址5.1 保留一个固定的公网TCP端口地址5.2 配置固定公网TCP端口地址 前言 宝塔面板的简易操作性,使得运维难度降低,简化了Linux命令行进行繁琐的配置,下面简单几步,通过宝塔面板cpo…
阅读更多...
Course1-Week2-多输入变量的回归问题

Course1-Week2-多输入变量的回归问题

Course1-Week2-多输入变量的回归问题 文章目录 Course1-Week2-多输入变量的回归问题1. 向量化和多元线性回归1.1 多维特征1.2 向量化1.3 用于多元线性回归的梯度下降法 2. 使梯度下降法更快收敛的技巧2.1 特征缩放2.2 判断梯度下降是否收敛2.3 如何设置学习率 3. 特征工程3.1 选…
阅读更多...
react中的state

react中的state

没想到hooks中也有state这一说法 看下面的两个案例 1、无state变化不会执行父子函数 2、有state更改执行父子函数
阅读更多...
竞赛选题 车道线检测(自动驾驶 机器视觉)

竞赛选题 车道线检测(自动驾驶 机器视觉)

0 前言 无人驾驶技术是机器学习为主的一门前沿领域&#xff0c;在无人驾驶领域中机器学习的各种算法随处可见&#xff0c;今天学长给大家介绍无人驾驶技术中的车道线检测。 1 车道线检测 在无人驾驶领域每一个任务都是相当复杂&#xff0c;看上去无从下手。那么面对这样极其…
阅读更多...
数据提取PDF SDK的对比推荐

数据提取PDF SDK的对比推荐

PDF 已迅速成为跨各种平台共享和分发文档的首选格式&#xff0c;它作为一种数据来源&#xff0c;常见于公司的各种报告和报表中。为了能更好地分析、处理这些数据信息&#xff0c;我们需要检测和提取 PDF 中的数据&#xff0c;并将其转换为可用且有意义的格式。而数据提取的 PD…
阅读更多...
【Spring进阶系列丨第四篇】Spring的Bean管理(基于xml的配置)

【Spring进阶系列丨第四篇】Spring的Bean管理(基于xml的配置)

前言 我们知道&#xff0c;容器是一个空间的概念&#xff0c;一般理解为可盛放物体的地方。在Spring容器通常理解为BeanFactory或者ApplicationContext。我们知道spring的IOC容器能够帮我们创建对象&#xff0c;对象交给spring管理之后我们就不用手动去new对象。 那么Spring是如…
阅读更多...
服务号可以迁移到订阅号吗

服务号可以迁移到订阅号吗

服务号和订阅号有什么区别&#xff1f;服务号转为订阅号有哪些作用&#xff1f;首先我们要看一下服务号和订阅号的主要区别。1、服务号推送的消息没有折叠&#xff0c;消息出现在聊天列表中&#xff0c;会像收到消息一样有提醒。而订阅号推送的消息是折叠的&#xff0c;“订阅号…
阅读更多...
2023“亚太杯”大学生数学建模竞赛

2023“亚太杯”大学生数学建模竞赛

2023亚太杯数学建模C题 中国新能源电动汽车的发展趋势 解题思路、数据 该题并没有提供数据集&#xff0c;对所需数据进行收集整理是对题目进行求解的基础。在本题中&#xff0c;主要需要以下数据&#xff1a;新能源汽车历史销售量、新能汽车相关专利的历史数量、充电桩历史数…
阅读更多...
【外贸商机篇】黑色星期五来啦，跨境电商必备手册!

【外贸商机篇】黑色星期五来啦，跨境电商必备手册!

黑色星期五是每年11月的第四个星期五&#xff0c;三天后是网络星期一。这两个购物日是美国一年中最繁忙的购物日之一&#xff0c;仅在2021年的感恩节周末&#xff0c;电子商务收入估计就达到196亿美元。 在一项Statista调查中&#xff0c;美国消费者被问及他们计划购买哪些商品…
阅读更多...
太赫兹涂层测厚：为汽车制造商保驾护航

太赫兹涂层测厚：为汽车制造商保驾护航

太赫兹涂层测厚&#xff1a;为汽车制造商保驾护航 近年来&#xff0c;专用于测量任何表面涂层厚度的IRYS太赫兹系统&#xff0c;成功赢得了包括大众和丰田在内的全球领先整车厂的信任。 为了实现这一目标&#xff0c;IRYS系统经过了许多制造商为甄选值得信赖的技术供应商而设置…
阅读更多...
软件开发及交付中，如何平衡项目进度和团队成员的利益？

软件开发及交付中，如何平衡项目进度和团队成员的利益？

在平衡软件质量与时间、成本、范围的关系时&#xff0c;需要考虑到项目管理的金三角概念&#xff0c;即时间、成本和范围。从项目管理的角度来看&#xff0c;项目进度和团队成员的利益需要平衡。 以下是一些建议&#xff1a; 制定可行的计划&#xff1a;让项目相关各方充分参与…
阅读更多...
我劝烂了，这东西大学生早用早解脱

我劝烂了，这东西大学生早用早解脱

大学生看我&#xff0c;这个东西太太太香了啊&#xff01;&#xff01;&#xff01; 要写论文&#xff0c;写总结的都给我用起来 这东西能自动写文章&#xff0c;想写几篇就写几篇&#xff0c;篇篇不重复&#xff01;只要输入一个标题&#xff0c;马上就能生成一篇。真的贼香…
阅读更多...
目前软件测试行业发展如何?第三方软件检测机构是否是未来趋势?

目前软件测试行业发展如何?第三方软件检测机构是否是未来趋势?

随着软件行业的快速发展&#xff0c;软件质量的重要性日益凸显&#xff0c;软件测试也成为了软件开发过程中不可或缺的环节。那么目前软件测试行业的发展如何?第三方软件检测机构又是否是未来软件测试的趋势呢?接下来我们将从多个角度为您详细解答。 目前软件测试行业呈现快…
阅读更多...
老师检查家庭作业的作用

老师检查家庭作业的作用

在教育体系中&#xff0c;老师检查家庭作业是一种常见的教学方式&#xff0c;旨在帮助学生巩固课堂所学知识&#xff0c;提高自学能力&#xff0c;以及培养良好的学习习惯。家庭作业是学生学习过程中不可或缺的一环&#xff0c;而老师对家庭作业的检查则起到了至关重要的作用。…
阅读更多...
内容营销频频出圈，这些品牌号做对了什么？

内容营销频频出圈，这些品牌号做对了什么？

小红书拥有大量的年轻用户&#xff0c;通过运营品牌号既能降低投放成本&#xff0c;又能更好地连接消费者和品牌&#xff0c;在平台完成一站式闭环营销。 今天就借助几个成功案例&#xff0c;来分析下他们是如何搭建官方账号&#xff0c;通过内容运营吸引更多用户&#xff0c;实…
阅读更多...
航天博物馆3D虚拟交互展厅让大众对科技发展有更深切的理解和感受

航天博物馆3D虚拟交互展厅让大众对科技发展有更深切的理解和感受

博物馆作为人们了解历史、文化和艺术的重要场所&#xff0c;现在可以通过VR全景技术来进行展览&#xff0c;让参观者身临其境地感受历史文化的魅力。本文将介绍博物馆VR全景的特点、优势&#xff0c;以及如何使用VR全景技术来使得博物馆的展览和教育活动更丰富。 VR数字博物馆…
阅读更多...
最新文章

Copyright @ 2022~2023