初识C++: string类【标准库里的string】【string类的模拟实现】

news2024/9/20 1:06:55

关于string类，可以先看一下这个文档string文档。

一.标准库里的string

1.1auto关键字

（1） 在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，后来这个 不重要了。C++11中，标准委员会变废为宝赋予了auto全新的含义即：auto不再是一个存储类型 指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期 推导而得。

（2）用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&

（3）当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际 只对第一个类型进行推导，然后用推导出来的类型定义其他变量。

	// 编译报错：error C3538: 在声明符列表中，“auto”必须始终推导为同一类型
	auto cc = 3, dd = 4.0;

（4）auto不能作为函数的参数，可以做返回值，但是建议谨慎使用

不能做函数的参数

auto可以自动的识别类型，做返回值是一种牺牲可读性的方式： 

auto func2()
{
	return 3;
}

（5）auto不能直接用来声明数组

1.2范围for

（1）对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围 内用于迭代的变量，第二部分则表示被迭代的范围，自动迭代，自动取数据，自动判断结束。

（2）范围for可以作用到数组和容器对象上进行遍历

int main()
{
	int array[] = { 1, 2, 3, 4, 5 };

	for (auto& e : array)//自动识别类型
		e *= 2;
	for (auto e : array)
		cout << e << ' ';
	cout << endl;
	string str("hello world");
	for (auto ch : str)
	{
		cout << ch << ' ';
	}
	cout << endl;
	return 0;
}

（3）范围for的底层很简单，容器遍历实际就是替换为迭代器。

这三个等价：

string str("hello world");
for (auto ch : str)
{
	cout << ch << ' ';
}
cout << endl;
//这个for循环就是上面范围for的底层
for (auto ch = str.begin(); ch < str.end(); ch++)
{
	cout << *ch << ' ';
}
cout << endl;
//这里的auto就是string::iterator
for (string::iterator ch = str.begin(); ch < str.end(); ch++)
{
	cout << *ch << ' ';
}

1.3string类的常见接口

1.3.1string类对象的常见构造

string()构造空的string类对象，即空字符串

string(const char* s) 

用C-string来构造string类对象
string(size_t n, char c)string类对象中包含n个字符c
string(const string&s)

拷贝构造函数 

	string s1;
	string s2("abcdefg");
	string s3(5, 'c');
	string s4(s2);

这里只是几个常用的，C++11中更新了9个：

1.3.2string对象的容量操作

size返回字符串有效字符长度
length返回字符串有效字符长度
capacity返回空间总大小
empty检测字符串是否为空串，是返回true，否则返回false
clear清空有效字符
reserve为字符串预留空间
resize将有效字符的个数该成n个，多出的空间用字符'\0'填充
string s("hello world");
cout << s.size() << endl;//有效字符长度
cout << s.length() << endl;//有效字符长度
cout << s.capacity() << endl;//空间总大小
cout << s << endl;

// 将s中的字符串清空，注意清空时只是将size清0，不改变底层空间的大小
s.clear();
cout << s.size() << endl;
cout << s.capacity() << endl;

// 将s中有效字符个数增加到10个，多出位置用'a'进行填充
// “aaaaaaaaaa”
s.resize(10, 'a');
cout << s.size() << endl;
cout << s.capacity() << endl;

// 将s中有效字符个数增加到15个，多出位置用缺省值'\0'进行填充
// "aaaaaaaaaa\0\0\0\0\0"
// 注意此时s中有效字符个数已经增加到15个
s.resize(15);
cout << s.size() << endl;
cout << s.capacity() << endl;
cout << s << endl;

// 将s中有效字符个数缩小到5个
s.resize(5);
cout << s.size() << endl;
cout << s.capacity() << endl;
cout << s << endl;

注意：

（1）size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接 口保持一致，一般情况下基本都是用size()。

（2）clear()只是将string中有效字符清空，不改变底层空间大小。

（3）resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不 同的是当字符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的元素空间。注意：resize在改变元素个数时，如果是将元素个数 增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。

（4）reserve(size_t res_arg=0)：为string预留空间，不改变有效元素个数，当reserve的参 数小于string的底层空间总大小时，reserver不会改变容量大小。

1.3.3类对象的访问及遍历操作

operator[]返回pos位置的字符，const string类对象调用
begin+endbegin获取一个字符的迭代器 + end获取最后一个字符下一个位 置的迭代器
rbegin+rend与begin+end刚好相反
范围forC++11支持更简洁的范围for的新遍历方式

operator[]当成数组就行，比如在遍历的时候：

int main()
{
	string s1("hello world");
	for (int i = 0; i < s1.size(); i++)
	{
		cout << s1[i] << ' ';
	}
	return 0;
}

之后是begin+end和rbegin+rend：

int main()
{
	string s1("hello world");
	string::iterator it = s1.begin();
	while (it != s1.end())
	{
		cout << *it;
		++it;
	}
	cout << endl;
	// string::reverse_iterator rit = s.rbegin();
	// C++11之后，直接使用auto定义迭代器，让编译器推到迭代器的类型
	auto rit = s1.rbegin();
	while (rit != s1.rend())
	{
		cout << *rit;
		rit++;
	}
	return 0;
}

打印出： 

范围for就跟上面的一样。

1.3.4string类对象的修改操作

push_back

在字符串后插入字符
append在字符串后追加字符串
operator+=在字符串后追加字符串
c_str返回字符串
find+npos从字符串pos位置开始往后找字符c，返回该字符在字符串中的 位置
rfind从字符串pos位置开始往前找字符c，返回该字符在字符串中的 位置
substr在str中从pos位置开始，截取n个字符，然后将其返回

对于前四个： 

	string str;
	str.push_back(' ');   // 在str后插入空格
	str.append("hello");  // 在str后追加一个字符"hello"
	str += "world";          // 在str后追加一个字符串"it"
	cout << str << endl;
	cout << str.c_str() << endl;

rfind：

	// 获取file的后缀
	string file("string.cpp");//rfind从后面开始查找
	size_t pos = file.rfind('.');//返回.的位置
	string suffix(file.substr(pos, file.size() - pos));
	cout << suffix << endl;

find是从前面开始查找，查找失败返回npos。 npos是string里面的一个静态成员变量：static const size_t npos = -1。

substr：

string str = "We think in generalities, but we live in details.";

string str2 = str.substr(3, 5);     // "think"

size_t pos = str.find("live");      // 返回live的位置

string str3 = str.substr(pos);     // 从pos位置到最后

cout << str2 << '\n' << str3 << '\n';

1.3.5string类非成员函数

operator+尽量少用，传值返回，调用拷贝效率低
operator>>输入运算符重载
operator<<输入运算符重载
getline获取一行字符串
relational operators

大小比较

这几个就比较简单了，关于我提到的这些函数的定义，还是没有提到的都可以在上面的那个文档里查看string文档 。

1.3.6vs和g++下string结构的说明

在不同的编译环境下，对于string定义的结构也有所不同：

vs下string的结构：

string总共占28个字节，内部结构稍微复杂一点。

首先是有一个联合体，联合体用来定义string中字符串的存储空间：

当字符串长度小于16时，使用内部固定的字符数组来存放 当字符串长度大于等于16时，从堆上开辟空间

union _Bxty

{ // storage for small buffer or pointer to larger one

 value_type _Buf[_BUF_SIZE];
 pointer _Ptr;
 char _Alias[_BUF_SIZE]; // to permit aliasing

} _Bx;

其次：还有一个size_t字段保存字符串长度，一个size_t字段保存从堆上开辟空间总的 容量

最后：还有一个指针做一些其他事情。

故总共占16+4+4+4=28个字节。

g++下string的结构：

g++下，string是通过写时拷贝实现的，string对象总共占4个字节，内部只包含了一个指针，该指针将来指向一块堆空间，内部包含了如下字段： 空间总大小 字符串有效长度 引用计数 指向堆空间的指针，用来存储字符串。

struct _Rep_base

{
 size_type               _M_length;
 size_type               _M_capacity;
 _Atomic_word            _M_refcount;
};

二.string类的模拟实现

2.1构造函数，赋值运算符重载，析构函数的模拟实现

class String
{
public:
	//默认构造函数
	//不能写成String(const char* str = nullptr)
	//如果写成这样我们初始化一个无参的s1会用这个缺省值，打印会出现错误，库里的不会
	String(const char* str="")//注意这里缺省值，""里本身就有\0.
	{
		_size = strlen(str);
		_capacity = _size;
		_str = new char[_size + 1];//多开一个给\0
		strcpy(_str, str);
	}
	//拷贝构造函数的传统写法
	//深拷贝
	String(const String& s)
	{
		_str = new char[s._capacity + 1];
		_size = s._size;
		_capacity = s._capacity;
		strcpy(_str, s._str);
	}
	//拷贝构造函数的现代写法
	void swap(String& s)
	{
		std::swap(_str, s._str);
		std::swap(_size, s._size);
		std::swap(_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)//s1==s1
		{
			delete[] _str;//先把原来的空间释放
			_str = new char[s._capacity + 1];//重新开一个可以放下s的空间，+1是为了放'\0'
			_size = s._size;
			_capacity = s._capacity;
			strcpy(_str, s._str);//依次赋值
		}
		return *this;
	}

	//赋值运算符重载的现代写法
	String& operator=(const String& s)
	{
		String tmp = s;
		swap(tmp);
		return *this;
	}

	//析构函数
	~String()
	{
		delete[] _str;
		_str = nullptr;
		_size = 0;
		_capacity = 0;
	}
private:
	char* _str;
	size_t _size;
	size_t _capacity;
};

2.1.1深拷贝与浅拷贝

深拷贝：

如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给 出。一般情况都是按照深拷贝方式提供。

浅拷贝：

也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致 多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该 资源已经被释放，以为还有效，所以当继续对资源进项操作时，就会发生发生了访问违规。  

2.1.2传统写法与现代写法

上面我在写拷贝构造函数和赋值运算符重载的时候用了两种方式。一种是我们普通就可以想到的直接赋值就行（传统写法）。一种就是利用库里的swap函数来进行创建，例如拷贝构造函数，我先利用默认构造函数来初始化一个对象tmp，然后再交换tmp与this指针指向的地址的值，相当于是找了一个中转站。

2.2 iterator 迭代器

	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;
	}

2.3 capacity

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

	bool empty()const
	{
		return 0 == _size;
	}

	void reserve(size_t NewSize)
	{
		if (NewSize > _capacity)
		{
			char* tmp = new char[NewSize + 1];
			strcpy(tmp, _str);
			delete[] _str;
			_str = tmp;
			_capacity = NewSize;
		}
	}
	void resize(size_t NewSize, char c = '\0')
	{
		if (NewSize > _size)
		{
			if (NewSize > _capacity)
			{
				reserve(NewSize);
			}
			memset(_str + _size, c, NewSize - _size);
		}
		_size = NewSize;
		_str[_size] = '\0';
	}

2.4 modify

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

String& operator+=(char c)
{
	push_back(c);
	return *this;
}

void append(const char* str)
{
	//先算出要插入字符串的长度
	size_t len = strlen(str);
	if (_size + len > _capacity)//看一下是否大于容量
	{
		//大于二倍按本身扩大，否则按二倍
		reserve(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);
	}
	strcpy(_str + _size, str);
	_size += len;
}

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

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

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

2.5access

//[]运算符重载
char& operator[](size_t index)
{
	assert(index < _size);
	return _str[index];
}
//[]运算符重载
const char& operator[](size_t index)const
{
	assert(index < _size);
	return _str[index];
}

2.6比较

bool bit::string::operator<(const string& s)
{
	return strcmp(_str, s.c_str()) < 0;
}

bool bit::string::operator<=(const string& s)
{
	return _str < s.c_str() || _str == s.c_str();
}

bool bit::string::operator>(const string& s)
{
	return !(_str <= s.c_str());
}

bool bit::string::operator>=(const string& s)
{
	return !(_str < s.c_str());
}

bool bit::string::operator==(const string& s)
{
	return strcmp(_str, s._str) == 0;
}

bool bit::string::operator!=(const string& s)
{
	return !(_str == s.c_str());
}

2.7 find   insert   erase   substr

	size_t find(char c, size_t pos = 0) const
	{
		assert(pos < _size);
		for (int i = pos; i < _size; i++)
		{
			if (_str[i] == c)
			{
				return i;
			}

		}
		return npos;
	}
	size_t find(const char* s, size_t pos = 0) const
	{
		assert(pos < _size);
		const char* ptr = strstr(_str + pos, s);
		if (ptr == nullptr)
		{
			return npos;
		}
		else
		{
			//当前位置减去初始位置,就是差距
			return ptr - _str;
		}
	}
	String& insert(size_t pos, char c)
	{
		assert(pos <= _size);
		if (_size == _capacity)
		{
			reserve(_capacity == 0 ? 4 : _capacity * 2);
		}
		for (size_t i = _size; i >= pos; i--)
		{
			_str[i + 1] = _str[i];
		}
		_str[pos] = c;
		_size++;
		return *this;
	}
	String& insert(size_t pos, const char* str)
	{
		assert(pos <= _size);
		size_t len = strlen(str);
		if (len + _size > _capacity)
		{
			reserve(len + _size > 2 * _capacity ? len + _size : 2 * _capacity);
		}
		//对比上面的加一个字符的，就是+len-1，上面是+1-1
		for (size_t i = _size + len - 1; i >= pos + len - 1; i--)
		{
			_str[i + 1] = _str[i - len + 1];//第一次是把_size位置的\0,，给到_size+len位置
			//
		}

		for (size_t i = 0; i < len; i++)
		{
			_str[pos + i] = str[i];
		}
		_size += len;
		return *this;
	}
	String& erase(size_t pos, size_t len)
	{
		assert(pos <= _size);
		if (_size - pos <= len)
		{
			_str[pos] = '\0';
			_size = pos;
		}
		else
		{
			for (size_t i = pos + len; i <= _size; i++)
			{
				_str[i - len] = _str[i];
			}

			_size -= len;
		}
		return *this;
	}
	
	String substr(size_t pos, size_t len)
	{
		assert(pos < _size);
		if (_size - pos < len)
		{
			len = _size - pos;
		}
		String sub;// = new String[len];
		sub.reserve(len);
		for (int i = 0; i < len; i++)
		{
			sub += _str[pos + i];
		}
		return sub;
	}

2.8<<和>>

ostream& operator<<(ostream& out, const String& s)
{
	//需要重载一个const对象可以调用的begin和end
	for (auto e : s)
	{
		out << e;
	}
	return out;
}
istream& operator>>(istream& in, String& s)
{
	s.clear();
	const int n = 256;
	char buff[n];//提前创建一个256空间的数组存放输入的字符
	int i = 0;

	char ch;
	ch = in.get();
	while (ch != ' ' && ch != '\n')
	{
		buff[i++] = ch;//缓冲区里依次放到buff里
		if (i == n - 1)
		{
			buff[i] = '\0';
			s += buff;//buff满了就给s
			i = 0;//继续循环
		}
		ch = in.get();//从缓冲区里读取
	}
	if (i > 0)//然后把剩余的放到s里
	{
		buff[i] = '\0';
		s += buff;
	}
	return in;
}

到这里string类就结束了，感谢大家的观看，如有错误还请多多指出。

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

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

相关文章

Linux基础三

Linux基础三

拼搏何惧路途难&#xff0c; 汗水淋漓志未残。 砥砺前行心不改&#xff0c; 终能登顶笑开颜。 目录 一&#xff0c;vi编辑器 1&#xff0c;命令模式 2&#xff0c;末行模式 3&#xff0c;编辑模式 二&#xff0c;Linux进程启动的几种方式 2.1前台启动进程 2.2后台启动进程 三&a…
阅读更多...
Git 创建分支进行写作开发

Git 创建分支进行写作开发

第一次链接仓库提交 and 有SSH公匙 第一步&#xff1a; git clone 远程仓库链接clone 远程已有仓库到本地 第二部&#xff1a; cd 文件夹 第三步&#xff1a; git checkout -b <your_branch_name> 创建分支 第四步&#xff1a; git add . 将目前目录下的所有文件…
阅读更多...
加密micropython写的程序为.mpy的方法

加密micropython写的程序为.mpy的方法

2024年7月26日 用虚拟机安装一个Linux&#xff0c;本例为CentOS7的Linux系统。 1.保证Linux能够连接网络。 2.进入root用户&#xff0c;使用下面的命令行安装gcc编译器&#xff1a; yum install gcc 3.安装完成后&#xff0c;查看gcc是否安装成功&#xff0c;用下面的命令…
阅读更多...
Java从入门到精通（十三）~ 枚举和注解

Java从入门到精通（十三）~ 枚举和注解

晚上好&#xff0c;愿这深深的夜色给你带来安宁&#xff0c;让温馨的夜晚抚平你一天的疲惫&#xff0c;美好的梦想在这个寂静的夜晚悄悄成长。 文章目录 目录 前言 一、枚举 1.1 枚举的概念 ​编辑 1.2 枚举的特点 1.3 枚举的实际运用 1. 状态机&#xff0c;描述属性的…
阅读更多...
App Inventor 2 低功耗蓝牙 BlueToothLE 拓展中文文档（完整翻译加强版）

App Inventor 2 低功耗蓝牙 BlueToothLE 拓展中文文档（完整翻译加强版）

低功耗蓝牙&#xff0c;也称为蓝牙LE 或简称 BLE&#xff0c;是一种类似于经典蓝牙的新通信协议&#xff0c;不同之处在于它旨在消耗更少的功耗和成本&#xff0c;同时保持同等的功能。 因此&#xff0c;低功耗蓝牙是与耗电资源有限的物联网设备进行通信的首选。BluetoothLE 扩…
阅读更多...
【C++】C++11中R字符串的作用

【C++】C++11中R字符串的作用

在 C11 中添加了定义原始字符串的字面量 1.定义和基本使用 定义方式为&#xff1a; R"xxx(原始字符串)xxx"其中 () 两边的字符串可以省略&#xff0c;R只会处理括号中的字符串。 原始字面量 R 可以直接表示字符串的实际含义&#xff0c;而不需要额外对字符串做转义…
阅读更多...
文件系统基础 (二)——文件的物理结构

文件系统基础 (二)——文件的物理结构

目录 一. 前言二. 连续(顺序)分配三. 链接分配隐式链接显式链接 三. 索引分配单级索引分配多级索引分配混合索引分配混合索引分配相关计算 五. 总结 一. 前言 文件的物理结构就是研究文件的实现&#xff0c;即文件数据在物理存储设备上是如何分布和组织的。 文件的分配方式&a…
阅读更多...
【计算机网络原理】网络层IP协议的总结和数据链路层以太网协议的总结.

【计算机网络原理】网络层IP协议的总结和数据链路层以太网协议的总结.

˃͈꒵˂͈꒱ write in front ꒰˃͈꒵˂͈꒱ ʕ̯•͡˔•̯᷅ʔ大家好&#xff0c;我是xiaoxie.希望你看完之后,有不足之处请多多谅解&#xff0c;让我们一起共同进步૮₍❀ᴗ͈ . ᴗ͈ აxiaoxieʕ̯•͡˔•̯᷅ʔ—CSDN博客 本文由xiaoxieʕ̯•͡˔•̯᷅ʔ 原创 CSDN 如…
阅读更多...
anaconda searchanaconda show | conda 检索包资源安装指定版本包指定源安装命令package

anaconda searchanaconda show | conda 检索包资源安装指定版本包指定源安装命令package

conda issuehttp://t.csdnimg.cn/ndZZK 目录 常规安装 检索包资源 获取指定包的安装源&安装指令 安装指定包 常规安装 conda 常规安装xxx包 conda install xxx conda install有可能会受限于channel导致报错PackagesNotFoundError: The following packages are not av…
阅读更多...
RedisTemplate、StringRedisTemplate、序列化器配置

RedisTemplate、StringRedisTemplate、序列化器配置

Lettuce和Jedis RedisTemplate是SpringDataRedis中对JedisApi的高度封装&#xff0c;提供了Redis各种操作、 异常处理及序列化&#xff0c;支持发布订阅。 首先我们要知道SpringData是Spring中数据操作的模块&#xff0c;包括对各种数据库的集成&#xff0c;比如我们之前学过…
阅读更多...
SpringBoot轻松实现多数据源切换

SpringBoot轻松实现多数据源切换

一.需求背景 项目需要实现在多个数据源之间读写数据&#xff0c;例如在 A 数据源和 B 数据源读取数据&#xff0c;然后在 C 数据源写入数据 或者 部分业务数据从 A 数据源中读取、部分从B数据源中读取诸如此类需求。本文将简单模拟在SpringBoot项目中实现不同数据源之间读取数…
阅读更多...
数据结构：二分图以及判定二分图

数据结构：二分图以及判定二分图

文章目录 一、二分图的基本知识1、特性2、图示3、检查一个图是否为二分图3.1、着色的算法原理和思路3.2、算法示例&#xff1a;使用 BFS 检查二分图3.3、算法示例&#xff1a;使用 DFS 检查二分图 4、应用 二、例题1.LeetCode&#xff1a;785. 判断二分图2.Acwing&#xff1a;8…
阅读更多...
软件开发中UML的基本概念与UML类图中存在哪些关系与如何绘制？

软件开发中UML的基本概念与UML类图中存在哪些关系与如何绘制？

UML的概述 UML在维基百科中是这样子描述的 可以使用的工具这里网上说的有些花哨，我自己一般使用processon，里面的UML相关功能就很全。 UML类图的相关概念解释 解释一下什么是类图？ 定义系统中的类，描述系统中类的属性和方法，就是描述类的内部结构，表示类与类之间的关…
阅读更多...
手摸手教你撕碎西门子S7通讯协议04--S7COMM请求

手摸手教你撕碎西门子S7通讯协议04--S7COMM请求

1、S7通讯回顾 - &#xff08;1&#xff09;建立TCP连接 Socket.Connect-》已实现 - &#xff08;2&#xff09;发送访问请求 COTP-》已实现 - &#xff08;3&#xff09;交换通信信息 Setup Communication-》本节实现 - &#xff08;4&#xff09;执行相关操作 …
阅读更多...
诱骗IoT恶意软件跟踪CC服务器

诱骗IoT恶意软件跟踪CC服务器

工作背景 在分析 IoT 僵尸网络时&#xff0c;识别C&C 服务器至关重要。C&C 服务器的 IP 地址一直都是商业威胁情报的重要组成部分&#xff0c;由于 C&C 服务器通信协议日渐复杂并且活跃周期较短&#xff0c;时效性和准确性也非常重要。如果可以自动化识别 IoT 恶意…
阅读更多...
深度学习实战笔记3循环神经网络实现

深度学习实战笔记3循环神经网络实现

我们要训练一个基于循环神经网络的字符级语言模型&#xff0c;根据用户提供的文本的前缀生成后续文本。 import math import torch from torch import nn from torch.nn import functional as F from d2l import torch as d2l batch_size, num_steps 32, 35 train_iter, voc…
阅读更多...
防震减灾知识竞赛的规则和流程方案

防震减灾知识竞赛的规则和流程方案

防震减灾知识竞赛的规则主要包括赛制、比赛形式、参赛对象、竞赛内容等方面。 赛制&#xff1a;通常包括选拔赛、分区预赛和全国决赛三个阶段。选拔赛可以根据地区实际情况选择合适的组织形式&#xff0c;预赛和决赛则以现场比赛形式进行&#xff0c;由主办单位统一组织。 比…
阅读更多...
掌握 Spring Boot + MyBatis-Plus 动态数据源切换,只要5分钟！

掌握 Spring Boot + MyBatis-Plus 动态数据源切换,只要5分钟！

数据量猛增&#xff0c;通过动态数据源切换&#xff0c;我们不仅能提高查询效率&#xff0c;还能保证系统的高可用性。 通过将写操作集中在主库&#xff0c;读操作分散到多个从库&#xff0c;可以有效减轻数据库的压力。 在pom.xml中添加以下依赖&#xff1a; xml <depend…
阅读更多...
记录｜LabVIEW从0开始

记录｜LabVIEW从0开始

目录 前言一、表达式节点和公式节点二、脚本与公式2.1 公式 三、Excel表格3.1 位置3.2 案例&#xff1a;波形值存入Excel表中3.3 案例&#xff1a;行写入&#xff0c;列写入 四、时间格式化4.1 获取当前时间4.2 对当前时间进行格式化 更新时间 前言 参考视频&#xff1a; LabVI…
阅读更多...
hadoop学习（二）

hadoop学习（二）

一.MapReduce 1.1定义&#xff1a;是一个分布式运算程序的编程框架 1.2核心功能&#xff1a;将用户编写的业务逻辑代码和自带默认组件整合成一个完整的分布式运算程序&#xff0c;并发运行在一个Hadoop集群上。 1.3优点 1&#xff09;易于编程 它简单的实现一些接口&#…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023