【C++游记】string的使用和模拟实现

 

枫の个人主页

你不能改变过去，但你可以改变未来

算法/C++/数据结构/C

Hello，这里是小枫。C语言与数据结构和算法初阶两个板块都更新完毕，我们继续来学习C++的内容呀。C++是接近底层有比较经典的语言，因此学习起来注定枯燥无味，西游记大家都看过吧~，我希望能带着大家一起跨过九九八十一难，降伏各类难题，学会C++，我会尽我所能，以通俗易懂、幽默风趣的方式带给大家形象生动的知识，也希望大家遇到困难不退缩，遇到难题不放弃，学习师徒四人的精神！！！故此得名【C++游记】

 话不多说，让我们一起进入今天的学习吧~~~ 

目录

1>>标准库的String

1.1>>auto和范围for小知识

1.2>>string常用接口（组件）这里都可以查找到

容量接口

访问和遍历

 string类对象的修改操作

非成员函数但会用到 

2>>string的模拟实现

 3>>Boos战——string重要接口的模拟实现

1.String.h

2.String.cpp 

3.wctest.cpp

4>>结语

1>>标准库的String

1.1>>auto和范围for小知识

师傅别怕，赠与“武器”一把 i

auto基本知识：

它声明引用类型时，必须在auto后加上&。

声明多个变量时，这些变量必须是相同的类型。

auto不能作为函数参数，可以作为返回值。

不能用于声明数组。

#include<iostream>
using namespace std;
int main() {
	auto a = 10;
	auto b = 'b';
	auto c = "asdofih";
	auto d = 11.11;
	auto& e = a;
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
	cout << d << endl;
	cout << e << endl;
	printf("%p %p", &a, &e);
	return 0;
}

范围for：

        对比C语言的for循环，C++使用更好用的范围for代替， 格式为：“for（auto  范围内用于迭代的变量 : 被迭代的范围）”，自动迭代、取数据、结束，这就是自动范围for。

#include<iostream>
using namespace std;
int main() {
	int arr[] = { 1,2,3,4,5 };
	for (auto& e : arr) {//若要更改里面的数值，那么就要用引用才能修改到数组本身
		e += 2;
	}
	for (auto e : arr) {
		cout << e << " ";
	}
	cout << endl;
	string str("hello world");
	for (auto ch : str) {
		cout << ch << " ";
	}
	cout << endl;
	return 0;
}

1.2>>string常用接口（组件）这里都可以查找到

师傅后面都会介绍，不必担心

String函数名称功能说明
string（）构造空的string类对象，即空字符串
string（const char* s）用C-string（常量字符串）来构造string类对象
string（size_t n,char c）

string类对象中包含n个字符c

string（const string&s)

拷贝构造函数
void Test1() {
	string s1;//构造空的string类对象
	string s2("hello feng");//用常量字符串构造string类对象
	string s3(s2);//用s2拷贝构造s3
}

容量接口

若定义为string s，以下表size为例，就是s.size();

size返回字符串有效字符长度，使用范围比length广
length返回字符串有效字符长度
capacity返回总空间大小
empty检测字符串释放为空串，空返回true，非空返回false
clear清空有效字符
reserve为字符串预留空间
resize将有效字符个数设置为n个，多余用c填充

补充说明：size和length的区别只有在引入迭代器才能体现出来，一般都用size，length有使用限制。

clear只清空，不改大小

resize（size_t n,char c）用变量c的字符填充多余空间，resize（size_t）则是用0来填充。

reserve预留空间，小于string的空间大小时不作改动。

访问和遍历

函数名称功能说明
operator[]返回pos位置的字符，const string类对象调用
begin+endbegin获取一个字符的迭代器+end获取最后一个字符下一个位置的迭代器
rbegin+rendrbegin获取最后一个字符的迭代器+rend获取一个字符的迭代器
范围forC++11的遍历方式

 string类对象的修改操作

函数名称

功能说明

push_back在字符串后尾插字符c（单个）
append在字符串后追加一个字符串（多个）
operator+=在字符串后追加一个字符串（多个）
c_str返回C格式字符串
find+npos从字符串pos位置往后查找字符c，返回它的位置
rfind从字符串pos位置往前查找字符c，返回它的位置
substr在str中从pos位置开始，截取n个字符，将其返回

非成员函数但会用到 

函数       功能说明       
operator+深拷贝，效率低
operator>>输入运算符重载
operator<<输出运算符重载
getline获取一行字符串
relational operators大小比较

2>>string的模拟实现

错误示范：

#include<iostream>
#include<assert.h>
using namespace std;
class MyString {
public:
	MyString(const char* str = "") {
		if (str == nullptr) {
			perror("flase");
			return;
		}
		_str = new char[strlen(str) + 1];//加1放\0
		strcpy(_str, str);
	}
	~MyString() {
		if (_str) {
			delete[] _str;
			_str = nullptr;
		}
	}
private:
	char* _str;
};
void Test2() {
	string s1("hello feng");
	string s2(s1);
}

int main() {
	/*Test1();*/
	Test2();
	return 0;
}

上述过程会报错，因为没有写拷贝构造，s2会调用s1的默认构造，而在类和对象章节中我们知道默认构造都是浅拷贝，这里是一个字符数组，因此要调用深拷贝。

#include<iostream>
#include<assert.h>
using namespace std;
class MyString {
public:
	MyString(const char* str = "") {//构造
		if (str == nullptr) {
			perror("flase");
			return;
		}
		_str = new char[strlen(str) + 1];//加1放\0
		strcpy(_str, str);
	}
	MyString(const MyString& s)//拷贝构造
		:_str(nullptr)
	{
		MyString tmp(s._str);
		swap(tmp._str, _str);
	}
	~MyString() {//析构
		if (_str) {
			delete[] _str;
			_str = nullptr;
		}
	}
private:
	char* _str;
};
void Test2() {
	string s1("hello feng");
	string s2(s1);
}

int main() {
	/*Test1();*/
	Test2();
	return 0;
}

 3>>Boos战——string重要接口的模拟实现

这里直接附上上个文件源码，大部分已经注释完毕，请大家伙享用，感兴趣可以复制过去测试，不过还是自己敲一遍比较好。

1.String.h

#pragma once

#include<iostream>
#include<assert.h>
#include<string.h>
using namespace std;

namespace wc
{
	class string
	{
	public:
		typedef char* iterator;//手动自造迭代器，名字与库中相同，但在wc的命名空间里
		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;
		}

		void swap(string& s);//交换，直接套用标准库里的swap

		string(size_t n, char ch);//设置相同字符多少个为一个字符串
		
		string(const char* str = "");//构造函数

		string(const string& s);//拷贝构造函数
		
		~string();//析构函数
		void clear()//清除
		{
			_str[0] = '\0';
			_size = 0;
		}

		string& operator=(string s);//string& operator=(const string& s);

		const char* c_str() const//常数直接返回自己地址，比较快因此调用内联
		{
			return _str;
		}

		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, size_t n, char ch);//在pos位置插入n个ch字符
		void insert(size_t pos, const char* str);//在pos位置插入一个字符串
		void erase(size_t pos = 0, size_t len = npos);//在pos位置删除len个字符

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

		size_t size() const
		{
			return _size;
		}

		size_t capacity() const
		{
			return _size;
		}

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

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

		string substr(size_t pos, size_t len = npos);//从pos位置开始取len个作为子串返回

		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;
	private:
		char* _str = nullptr;//定义字符串数组_str
		size_t _size = 0;//有效个数
		size_t _capacity = 0;//总容量
		const static size_t npos;//设置默认结束值
	};

	// cout<<s1
	ostream& operator<<(ostream& out, const string& s);
	// cin>>s1
	istream& operator>>(istream& in, string& s);

	istream& getline(istream& is, string& s, char delim = '\n');

	void test_string1();
	void test_string2();
	void test_string3();
	void test_string4();
	void test_string5();
	void test_string6();
	void test_string7();
}

2.String.cpp 

//#include<iostream>
//using namespace std;
//int main() {
//	auto a = 10;
//	auto b = 'b';
//	auto c = "asdofih";
//	auto d = 11.11;
//	auto& e = a;
//	cout << a << endl;
//	cout << b << endl;
//	cout << c << endl;
//	cout << d << endl;
//	cout << e << endl;
//	printf("%p %p", &a, &e);
//	return 0;
//}
//#include<iostream>
//using namespace std;
//int main() {
//	int arr[] = { 1,2,3,4,5 };
//	for (auto& e : arr) {//若要更改里面的数值，那么就要用引用才能修改到数组本身
//		e += 2;
//	}
//	for (auto e : arr) {
//		cout << e << " ";
//	}
//	cout << endl;
//	string str("hello world");
//	for (auto ch : str) {
//		cout << ch << " ";
//	}
//	cout << endl;
//	return 0;
//}

//void Test1() {
//	string s1;//构造空的string类对象
//	string s2("hello feng");//用常量字符串构造string类对象
//	string s3(s2);//用s2拷贝构造s3
//}
//#include<iostream>
//#include<assert.h>
//using namespace std;
//class MyString {
//public:
//	MyString(const char* str = "") {//构造
//		if (str == nullptr) {
//			perror("flase");
//			return;
//		}
//		_str = new char[strlen(str) + 1];//加1放\0
//		strcpy(_str, str);
//	}
//	MyString(const MyString& s)//拷贝构造
//		:_str(nullptr)
//	{
//		MyString tmp(s._str);
//		swap(tmp._str, _str);
//	}
//	~MyString() {//析构
//		if (_str) {
//			delete[] _str;
//			_str = nullptr;
//		}
//	}
//private:
//	char* _str;
//};
//void Test2() {
//	string s1("hello feng");
//	string s2(s1);
//}
//
//int main() {
//	/*Test1();*/
//	Test2();
//	return 0;
//}

#define _CRT_SECURE_NO_WARNINGS 1
#include"string.h"

namespace wc
{
	const size_t string::npos = -1;

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

	string::string(size_t n, char ch)
		:_str(new char[n + 1])
		, _size(n)
		,_capacity(n)
	{
		for (size_t i = 0; i < n; i++) {
			_str[i] = ch;
		}
		_str[_size] = '\0';
	}

	string::string(const char* str)//声明中写过默认值，这里就不能再写了 
		:_size(strlen(str))
	{
		_capacity = _size;
		_str = new char[_size + 1];
		strcpy(_str, str);//复制还没复制\0
		_str[_size] = '\0';
	}

	string::string(const string& s)
	{
		string tmp(s._str);
		swap(tmp);
	}

	string::~string()
	{
		delete[] _str;
		_str = nullptr;
		_size = 0;
		_capacity = 0;
	}
	string& string::operator=(string s) 
	{
		swap(s);
		return *this;
	}

	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 + 1 > _capacity) {//大于就扩容
			reserve(_capacity == 0 ? 4 : _capacity * 2);//预留空间刚写就能用
		}
		_str[_size] = ch;
		_size++;
		_str[_size] = '\0';
	}
	void string::append(const char* str) {
		size_t len = strlen(str);
		if (_size + len > _capacity) {
			reserve(_size + len);
		}
		strcpy(_str + _size, str);
		_size += len;
	}

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

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

	void string::insert(size_t pos, size_t n, char ch)
	{
		assert(pos <= _size);
		assert(n > 0);

		if (_size + n > _capacity)
		{
			// 扩容
			size_t newCapacity = 2 * _capacity;
			if (_size + n > 2 * _capacity)
			{
				newCapacity = _size + n;
			}

			reserve(newCapacity);
		}

		size_t end = _size + n;
		while (end > pos + n - 1) {
			_str[end] = _str[end - n];
			end--;
		}
		for (size_t i = 0; i < n; i++) {
			_str[pos + i] = ch;
		}
		_size += n;
	}

	void string::insert(size_t pos, const char* str)
	{
		size_t n = strlen(str);
		insert(pos, n, 'x');//覆盖一下
		for (size_t i = 0; i < n; i++)
		{
			_str[pos + i] = str[i];
		}
	}

	void string::erase(size_t pos, size_t len) {
		if (len > _size - pos) {//多删了
			_str[pos] = '\0';
			_size = pos;
		}
		else {
			size_t end = pos + len;
			while (end <= _size) {//\0也拷贝
				_str[end - len] = _str[end];
				end++;
			}
			_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)
	{
		const char* p = strstr(_str + pos, str);
		if (p == nullptr)
		{
			return npos;
		}
		else
		{
			return p - _str;
		}
	}

	string string::substr(size_t pos, size_t len)
	{
		if (len > _size - pos)//若超出，就等于剩下长度
			len = _size - pos;
		
		string tmp;
		tmp.reserve(len);
		for (size_t i = 0; i < len; i++) {
			tmp += _str[pos + i];//直接加等，简单易懂
		}
		return tmp;
	}

	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 strcmp(_str, s._str) < 0;
	}

	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 !(*this < s);
	}


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

		return out;
	}

	istream& operator>>(istream& in, string& s)
	{
		s.clear();

		// 输入短串，不会浪费空间
		// 输入长串，避免不断扩容
		const size_t N = 1024;
		char buff[N];
		int i = 0;
		char ch = in.get();
		while (ch != ' ' && ch != '\n')//遇到空格和\n停止
		{
			buff[i++] = ch;
			if (i == N - 1)
			{
				buff[i] = '\0';//最后一个复制为0然后加上
				s += buff;
				i = 0;
			}
			//也可以直接写s+=ch，不过占用内存高
			ch = in.get();
		}

		if (i > 0)
		{
			buff[i] = '\0';
			s += buff;
		}

		return in;
	}

	istream& getline(istream& in, string& s, char delim)
	{
		s.clear();

		const size_t N = 1024;
		char buff[N];
		int i = 0;
		char ch = in.get();
		while (ch != delim)
		{
			buff[i++] = ch;
			if (i == N - 1)
			{
				buff[i] = '\0';
				s += buff;
				i = 0;
			}

			ch = in.get();
		}

		if (i > 0)
		{
			buff[i] = '\0';
			s += buff;
		}

		return in;
	}

	void test_string1()
	{
		string s1("hello world");
		cout << s1.c_str() << endl;

		string s2;
		cout << s2.c_str() << endl;

		s1 += ' ';
		s1 += '+';
		s1 += "hello ";
		s1 += "hello feng1111111111111111111111111";
		cout << s1.c_str() << endl;
	}

	void test_string2()
	{
		string s1("hello world");
		cout << s1.c_str() << endl;

		s1.insert(11, 3, 'x');
		cout << s1.c_str() << endl;

		s1.insert(6, 3, 'x');
		cout << s1.c_str() << endl;

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

		string s2("hello world");
		cout << s2.c_str() << endl;

		s2.insert(11, "yyy");
		cout << s2.c_str() << endl;

		s2.insert(6, "yyy");
		cout << s2.c_str() << endl;

		s2.insert(0, "yyy");
		cout << s2.c_str() << endl;
	}

	void test_string3()
	{
		string s1("hello world");
		cout << s1.c_str() << endl;

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

		s1.erase(6, 20);
		cout << s1.c_str() << endl;

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

		string s2("hello helleoo");
		cout << s2.find('e') << endl;
		cout << s2.find("helle") << endl;
	}

	void test_string4()
	{
		string s1("hello world");
		for (size_t i = 0; i < s1.size(); i++)
		{
			s1[i]++;
			cout << s1[i] << " ";
		}
		cout << endl;

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

		for (auto e : s1)
		{
			cout << e << " ";
		}
		cout << endl;

		const string s2("hello world");
		for (auto e : s2)
		{
			cout << e << " ";
		}
		cout << endl;
	}

	void test_string5()
	{
		string s1("hello world");

		string sub1 = s1.substr(6, 3);
		cout << sub1.c_str() << endl;

		string sub2 = s1.substr(6, 300);
		cout << sub2.c_str() << endl;

		string sub3 = s1.substr(6);
		cout << sub3.c_str() << endl;

		string s2("hello fengxxxxxxxxxxxxxxxxxx");
		s1 = s2;
		cout << s1.c_str() << endl;
		cout << s2.c_str() << endl;

		s1 = s1;
		cout << s1.c_str() << endl;
	}

	void test_string6()
	{
		/*string s1("hello world");
		string s2("hello bit");

		cout << s1 << endl;
		cout << s2 << endl;

		string s3;
		cin >> s3;
		cout << s3 << endl;*/

		string s1, s2;
		cin >> s1 >> s2;
		cout << s1 << endl;
		cout << s2 << endl;

		string s3;
		//getline(cin, s3);
		getline(cin, s3, '!');
		cout << s3 << endl;
	}

	void test_string7()
	{
		string s1("1111111111111");
		string s2(s1);
		cout << s1 << endl;
		cout << s2 << endl;

		string s3("222222222222222222222222222");
		s1 = s3;
		cout << s1 << endl;
		cout << s3 << endl;

		//s1.swap(s2);
		//swap(s1, s2);
		cout << s1 << endl;
		cout << s2 << endl;
	}
}

3.wctest.cpp

#include"string.h"

int main()
{
	//wc::test_string1();
	//wc::test_string3();
	wc::test_string5();

	return 0;
}

4>>结语

        今日C++到这里就结束啦，如果觉得文章还不错的话，可以三连支持一下。感兴趣的宝子们欢迎持续订阅小枫，小枫在这里谢谢宝子们啦~小枫の主页还有更多生动有趣的文章，欢迎宝子们去点评鸭~C++的学习很陡，时而巨难时而巨简单，希望宝子们和小枫一起坚持下去~你们的三连就是小枫的动力，感谢支持~

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

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

相关文章

Dcoker Redis哨兵模式集群介绍与搭建 故障转移 分布式 Java客户端连接

Dcoker Redis哨兵模式集群介绍与搭建 故障转移 分布式 Java客户端连接

介绍 Redis 哨兵模式&#xff08;Sentinel&#xff09;是 Redis 集群的高可用解决方案&#xff0c;它主要用于监控 Redis 主从复制架构中的主节点和从节点的状态&#xff0c;并提供故障转移和通知功能。通过 Redis 哨兵模式&#xff0c;可以保证 Redis 服务的高可用性和自动故…
阅读更多...
支路、回路、网孔和节点（基尔霍夫电压、电流定律）

支路、回路、网孔和节点（基尔霍夫电压、电流定律）

由基尔霍夫电流定律可以得出I3电流为0.
阅读更多...
golang操作sqlite3加速本地结构化数据查询

golang操作sqlite3加速本地结构化数据查询

目录 摘要Sqlite3SQLite 命令SQLite 语法SQLite 数据类型列亲和类型——优先选择机制 SQLite 创建数据库SQLite 附加数据库SQLite 分离数据库 SQLite 创建表SQLite 删除表 SQLite Insert 语句SQLite Select 语句SQLite 运算符SQLite 算术运算符SQLite 比较运算符SQLite 逻辑运算…
阅读更多...
Android v4和v7冲突

Android v4和v7冲突

android.useAndroidXtrue android.enableJetifiertruev4转成AndroidX
阅读更多...
【MySQL】优雅的使用MySQL实现分布式锁

【MySQL】优雅的使用MySQL实现分布式锁

MySQL实现分布式锁 引言二、基于唯一索引2.1、实现思路2.2、代码实现2.3、 测试代码2.4、小结 三、基于悲观锁3.1 、实现思路3.2、代码实现3.3、测试代码3.4、小结 四、基于乐观锁4.1 、实现思路4.2 、代码实现4.3 、测试代码4.4、小结 总结 引言 在文章《Redis实现分布式锁详…
阅读更多...
生活小妙招之UE CaptureRT改

生活小妙招之UE CaptureRT改

需求&#xff0c;四个不同的相机拍摄结果同屏分屏显示 一般的想法是四个Capture拍四张RT&#xff0c;然后最后在面片/UI上组合。这样的开销是创建4张RT&#xff0c;材质中采样4次RT。 以更省的角度&#xff0c;想要对以上流程做优化&#xff0c;4个相机拍摄是必须的&#xff…
阅读更多...
1 JVM JDK JRE之间的区别以及使用字节码的好处

1 JVM JDK JRE之间的区别以及使用字节码的好处

JDK jdk是编译java源文件成class文件的&#xff0c;我们使用javac命令把java源文件编译成class文件。 我们在java安装的目录下找到bin文件夹&#xff0c;如下图所示: 遵循着编译原理&#xff0c;把java源文件编译成JVM可识别的机器码。 其中还包括jar打包工具等。主要是针对…
阅读更多...
【Unity功能集】TextureShop纹理工坊（二）图层（上）

【Unity功能集】TextureShop纹理工坊（二）图层（上）

项目源码&#xff1a;后期发布 索引 图层TextureLayer可见性激活性可编辑性绘画区域、绘画板绘画区域锚点导入图像 图层 在PS中&#xff0c;图层的概念贯穿始终&#xff08;了解PS图层&#xff09;&#xff0c;他可以称作PS最基础也是最强大的特性之一。 那么&#xff0c;在T…
阅读更多...
贪心算法 part01

贪心算法 part01

class Solution { public:int maxSubArray(vector<int>& nums) {int result INT32_MIN;int count 0;for (int i 0; i < nums.size(); i) {count nums[i];if (count > result) { // 取区间累计的最大值&#xff08;相当于不断确定最大子序终止位置&#xff…
阅读更多...
二、FIFO缓存

二、FIFO缓存

FIFO缓存 1.FIFO缓存介绍2.FIFO缓存实现3.FIFO缓存总结 1.FIFO缓存介绍 FIFO&#xff08;First-In-First-Out&#xff09;缓存 是一种简单的缓存淘汰策略&#xff0c;它基于先进先出的原则来管理数据。当缓存达到容量限制并需要淘汰元素时&#xff0c;最先进入缓存的元素会被移…
阅读更多...
王佩丰24节Excel学习笔记——第十四讲：日期函数

王佩丰24节Excel学习笔记——第十四讲：日期函数

【以 Excel2010 系列学习&#xff0c;用 Office LTSC 专业增强版 2021 实践】 【本章小技巧】 掌握date()日期函数&#xff0c;配合年月日时分秒使用使用datedif()函数计算两个日期之前的差&#xff0c;重点记住参数三&#xff0c;差的值以哪种类型显示。使用weeknum/weekday,…
阅读更多...
python--在服务器上面创建conda环境

python--在服务器上面创建conda环境

今天刚开始使用服务器的时候使用上面的公共环境发现老师缺少模块&#xff0c; [guoyupingcins195 ~]$ conda --version Traceback (most recent call last): File "/home/miniconda3/bin/conda", line 12, in <module> from conda.cli import main Fil…
阅读更多...
Trimble天宝三维激光扫描仪在建筑工程竣工测量中的应用【沪敖3D】

Trimble天宝三维激光扫描仪在建筑工程竣工测量中的应用【沪敖3D】

竣工测量是建筑项目竣工阶段的一个至关重要的环节&#xff0c;它为建筑工程的质量验收和成果核查提供了核心的参考依据。传统的竣工测量方法&#xff0c;如全站仪测量&#xff0c;主要依赖于现场人工操作&#xff0c;存在一些明显的局限性&#xff0c;例如作业时间长、工作量大…
阅读更多...
SEO初学者-搜索引擎如何工作

SEO初学者-搜索引擎如何工作

搜索引擎基础搜索引擎是如何建立索引的搜索引擎如何对网页进行排名搜索引擎是如何个性化搜索结果的 搜索引擎的工作方式是使用网络爬虫抓取数十亿个页面。爬虫也称为蜘蛛或机器人&#xff0c;它们在网络上导航并跟踪链接以查找新页面。然后&#xff0c;这些页面会被添加到搜索引…
阅读更多...
react中实现导出excel文件

react中实现导出excel文件

react中实现导出excel文件 一、安装依赖二、实现导出功能三、自定义列标题四、设置列宽度五、样式优化1、安装扩展库2、设置样式3、扩展样式功能 在 React 项目中实现点击按钮后导出数据为 Excel 文件&#xff0c;可以使用 xlsx 和 file-saver 这两个库。 一、安装依赖 在项目…
阅读更多...
Latex中表格添加底部文本注释并调整对齐

Latex中表格添加底部文本注释并调整对齐

如何实现从第一个表到第三个表的转换&#xff0c; 其中主要涉及到两点&#xff1a; &#xff08;1&#xff09;底部脚注与表格自动对齐并缩进换行 &#xff08;2&#xff09;表格自适应页面宽度 底部脚注的对齐与换行缩进需要用到 \usepackage{threeparttable} \usepackage{…
阅读更多...
MySQL基础 -----MySQL数据类型

MySQL基础 -----MySQL数据类型

目录 INT类型 tinyint类型 类型大小范围 测试tinyint类型数据 float类型 测试&#xff1a; 测试正常数据范围的数据 测试插入范围超过临界值的数据&#xff1a; 测试float类型的四舍五入 ​编辑 decimal类型 同样测试&#xff1a; 字符串类型 char类型 测试&…
阅读更多...
【HarmonyOS NEXT】Web 组件的基础用法以及 H5 侧与原生侧的双向数据通讯

【HarmonyOS NEXT】Web 组件的基础用法以及 H5 侧与原生侧的双向数据通讯

关键词&#xff1a;鸿蒙、ArkTs、Web组件、通讯、数据 官方文档Web组件用法介绍&#xff1a;文档中心 Web 组件加载沙箱中页面可参考我的另一篇文章&#xff1a;【HarmonyOS NEXT】 如何将rawfile中文件复制到沙箱中_鸿蒙rawfile 复制到沙箱-CSDN博客 目录 如何在鸿蒙应用中加…
阅读更多...
ONES 功能上新｜ONES Copilot、ONES Wiki 新功能一览

ONES 功能上新｜ONES Copilot、ONES Wiki 新功能一览

ONES Copilot 可基于工作项的标题、描述、属性信息&#xff0c;对工作项产生的动态和评论生成总结。 针对不同类型的工作项&#xff0c;总结输出的内容有对应的侧重点。 应用场景&#xff1a; 在一些流程步骤复杂、上下游参与成员角色丰富的场景中&#xff0c;工作项动态往往会…
阅读更多...
使用qemu搭建armv7嵌入式开发环境

使用qemu搭建armv7嵌入式开发环境

目录 目录 1 概述 2 环境准备 2.1 vexpress系列开发板介绍 2.2 安装工具 2.2.1 安装交叉工具链 2.2.2 安装qemu 2.2.3 安装其他工具 3 启动uboot 3.1 uboot下载与编译 3.1.1 下载 3.1.2 编译 3.2 使用qemu启动uboot 4 启动kernel 4.1 下载和编译kernel 4.1.1 下…
阅读更多...
最新文章

Copyright @ 2022~2023