【C++】STL——vector的模拟实现、常用构造函数、迭代器、运算符重载、扩容函数、增删查改

文章目录

  • 1.模拟实现vector
    • 1.1构造函数
    • 1.2迭代器
    • 1.3运算符重载
    • 1.4扩容函数
    • 1.5增删查改

1.模拟实现vector

vector使用文章

在这里插入图片描述

1.1构造函数

在这里插入图片描述

析构函数

在这里插入图片描述

  在C++中，vector是一个动态数组容器，可以根据需要自动调整大小。vector类提供了几个不同的构造函数来创建和初始化vector对象。

  （1）默认构造函数： vector<类型> v; 创建一个空的vector对象v，其中类型是vector中元素的数据类型。这个构造函数将创建一个初始大小为0的vector。

  （2）带有初始大小的构造函数： vector<类型> v(n); 创建一个大小为n的vector对象v，并将所有元素初始化为默认值。例如，如果类型是int，则所有元素将初始化为0。

  （3）带有初始值的构造函数： vector<类型> v(n, 初始值); 创建一个大小为n的vector对象v，并将所有元素初始化为给定的初始值。例如，如果类型是int且初始值为5，则所有元素将初始化为5。

  （4）复制构造函数： vector<类型> v(v2); 创建一个新的vector对象v，其中包含与另一个vector对象v2相同的元素。这个构造函数将复制v2中的所有元素。

  （5）使用迭代器的构造函数： vector<类型> v(begin, end); 创建一个新的vector对象v，其中包含从迭代器begin到迭代器end之间的所有元素。这个构造函数将复制这些元素。

namespace vec
{
	//类模板
	template<class T>
	class vector
	{
	public:
		//带有初始值的构造函数
		vector(size_t n, const T& val = T())
		{
			resize(n, val);
		}
		
		//带有初始值的构造函数
		vector(int n, const T& val = T())
		{
			resize(n, val);
		}

		//使用迭代器的构造函数
		template<class InputIterator>
		vector(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

		//空构造函数
		vector()
		{ }

		构造函数
		//vector()
		//	:_start(nullptr)
		//	,_finish(nullptr)
		//	,_end_of_storage(nullptr)
		//{}

		//深拷贝实现拷贝构造
		vector(const vector<T>& v)
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			_start = new T[v.capacity()];
			//memcpy(_start, v._start, sizeof(T) * v.size());
			for (size_t i = 0; i < v.size(); i++)
			{
				_start[i] = v._start[i];
			}

			_finish = _start + v.size();
			_end_of_storage = _start + v.capacity();
		}

		//析构函数
		~vector()
		{
			if (_start != nullptr)
			{
				delete[] _start;
				_start = nullptr;
				_finish = nullptr;
				_end_of_storage = nullptr;
			}
		}

	private:
		//成员变量给缺省值
		iterator _start = nullptr;
		iterator _finish = nullptr;
		iterator _end_of_storage = nullptr;
	};
}

 

1.2迭代器

在这里插入图片描述
在这里插入图片描述

  和string的迭代器使用类似，begin 函数返回指向字符串的起始位置的迭代器，end 函数返回指向字符串的结束位置的迭代器。这样，就可以使用标准的迭代器操作来遍历字符串，如使用循环来遍历每个字符。

  对于普通的vector类型，编译器调用上面两个类型iterator的迭代器，表示可以对该类型容器可读可写；而对于const类型的vector，编译器就会调用下面两个类型const_iterator的迭代器，表示对该类型容器只有可写权限。

  这样，通过调用begin()和end()函数，可以获取vector容器的起始位置和结束位置的迭代器，然后通过迭代器进行遍历和操作容器中的元素。

//T类指针来实现迭代器
typedef T* iterator;
typedef const T* const_iterator;

//迭代器
iterator begin()
{
	return _start;
}

iterator end()
{
	return _finish;
}

//const修饰的迭代器
const_iterator begin() const
{
	return _start;
}

const_iterator end() const
{
	return _finish;
}

 

1.3运算符重载

 
赋值运算符重载

  赋值运算符operator=被重载为接受一个vector对象作为参数，并返回一个指向当前对象的引用。在重载实现中，首先创建一个临时的vector对象v，并将传入的vector对象拷贝给v。接着，调用swap函数，将当前对象和临时对象的成员变量进行交换。最后，返回指向当前对象的引用，以支持连续赋值的操作。

  通过这种方式，可以实现高效的赋值操作，避免了逐个元素的拷贝，提高了性能。同时，使用swap函数进行交换，可以确保在异常发生时，不会导致资源泄漏。

在这里插入图片描述

void swap(vector<T>& v)
{
	std::swap(_start, v._start);
	std::swap(_finish, v._finish);
	std::swap(_end_of_storage, v._end_of_storage);
}

//赋值运算符重载，现代写法
vector<T>& operator=(vector<T> v)
{
	swap(v);

	return *this;
}

 

重载operator[]

在这里插入图片描述

  对于普通的版本，我们重载了operator[]运算符，返回一个可读可写的引用。它接受一个参数pos，表示要访问的元素的位置。 在函数内部，通过assert函数进行断言，确保pos在有效的范围内，即小于vector的大小。然后，返回一个对_start[pos]的引用，以实现对指定位置元素的读写操作。

  对于const类型的vector，我们在上一个operator[]运算符的版本添加const进行修饰，返回一个只读的引用。 它也接受一个参数pos，并通过assert函数进行断言，确保pos在有效的范围内。然后，返回一个对_start[pos]的常量引用，以实现对指定位置元素的只读访问。

  通过重载operator[]运算符，可以像使用数组一样，通过下标访问vector容器中的元素。而且，通过重载常量版本的operator[]，可以在常量对象上也能进行只读访问。

//重载operator[] 可读可写
T& operator[](size_t pos)
{
	assert(pos < size());

	return _start[pos];
}

//重载operator[] 只读不可写
const T& operator[](size_t pos) const
{ 
	assert(pos < size());

	return _start[pos];
}

 

1.4扩容函数

reserve和resize

在这里插入图片描述

在这里插入图片描述

  reserve函数用于将vector对象的容量调整为至少为n。 如果n大于当前容量，则需要进行扩容操作。在函数内部，首先获取当前vector的大小，然后创建一个临时的指针tmp，指向一个大小为n的新数组。如果当前vector不为空，就将原有元素逐个拷贝到新数组中。

  注意，如果元素类型是自定义类型，可能会出现浅拷贝问题，不能使用memcpy函数进行内存拷贝。

  resize函数用于调整vector对象的大小为n，并在需要时填充指定的元素值val。 如果n小于当前大小，则将_finish指针移动到新的位置，即截断vector。如果n大于当前大小，则调用reserve函数进行扩容操作。然后，通过循环将新元素值拷贝到vector中，直到_finish指针指向新的位置。这样就实现了将vector的大小调整为n，并在需要时填充指定元素值的功能。

  通过这两个函数，可以实现对vector容器的容量和大小的调整，以及在扩容和调整大小时进行元素的拷贝和填充。这样可以灵活地管理vector容器的内存空间和元素数量。

//扩容函数capacity
void reserve(size_t n)
{
	if (n > capacity())
	{
		size_t sz = size();
		T* tmp = new T[n];
		if (_start)
		{
			//如果是自定义类型，假如string，则会出现浅拷贝
			//memcpy(tmp, _start, sizeof(T) * sz);
			for (size_t i = 0; i < sz; i++)
			{
				tmp[i] = _start[i];
			}

			delete[] _start;
		}

		_start = tmp;
		_finish = _start + sz;
		_end_of_storage = _start + n;
	}
}

//扩容size
void resize(size_t n, const T& val = T())
{
	if (n < size())
	{
		_finish = _start + n;
	}
	else
	{
		reserve(n);

		while (_finish != _start + n)
		{
			*_finish = val;
			++_finish;
		}
	}
}

 

capacity和size

  capacity的大小范围是：_end_of_storage - _start

  size的大小范围是：_finish - _start

  需要注意的是，vector的大小不一定等于容量，而且大小可以小于或等于容量。 当向vector中添加元素时，size大小会增加；当从vector中删除元素时，size大小会减少。当大小超过容量capacity时，vector会自动进行内存的重新分配，通常会分配更大的内存空间，将原有的元素拷贝到新的内存空间中，并释放原有的内存空间。

在这里插入图片描述

在这里插入图片描述

//返回capacity
size_t capacity() const
{
	return _end_of_storage - _start;
}

//返回size
size_t size() const
{
	return _finish - _start;
}

 

1.5增删查改

push_back

  push_back函数的实现，用于在vector的末尾添加一个元素。

在这里插入图片描述

//尾插
void push_back(const T& v)
{
	if (_finish == _end_of_storage)
	{
		size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
		reserve(newcapacity);
	}

	*_finish = v;
	++_finish;
	//insert(end(),x)
}

 

insert

  insert函数的实现，用于在vector中的pos处插入一个元素。

在这里插入图片描述

//插入
iterator insert(iterator pos, const T& x)
{
	assert(pos >= _start && pos <= _finish);

	//判断是否扩容
	if (_finish == _end_of_storage)
	{
		size_t len = pos - _start;

		size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
		reserve(newcapacity);

		//解决pos迭代器失效问题
		pos = _start + len;
	}

	iterator end = _finish - 1;
	while (end >= pos)
	{
		*(end + 1) = *end;
		end--;
	}

	*pos = x;
	_finish++;

	return pos;
}

 

erase

  erase函数的实现，用于在vector的pos位置删除指定元素。

在这里插入图片描述

//删除
iterator erase(iterator pos)
{
	assert(pos >= _start && pos <= _finish);

	iterator it = pos + 1;
	while (it != _finish)
	{
		*(it - 1) = *it;
		++it;
	}

	--_finish;

	return pos;
}

 

完整实现

#pragma once

#include<assert.h>

namespace vec
{
	//类模板
	template<class T>
	class vector
	{
	public:
		//T类指针来实现迭代器
		typedef T* iterator;
		typedef const T* const_iterator;

		//迭代器
		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

		//const修饰的迭代器
		const_iterator begin() const
		{
			return _start;
		}

		const_iterator end() const
		{
			return _finish;
		}

		//构造函数，将空间填充为val对象
		vector(size_t n, const T& val = T())
		{
			resize(n, val);
		}

		vector(int n, const T& val = T())
		{
			resize(n, val);
		}

		//构造函数，迭代区间进行构造
		template<class InputIterator>
		vector(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

		//空构造函数
		vector()
		{ }

		构造函数
		//vector()
		//	:_start(nullptr)
		//	,_finish(nullptr)
		//	,_end_of_storage(nullptr)
		//{}

		//深拷贝实现拷贝构造
		vector(const vector<T>& v)
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			_start = new T[v.capacity()];
			//memcpy(_start, v._start, sizeof(T) * v.size());
			for (size_t i = 0; i < v.size(); i++)
			{
				_start[i] = v._start[i];
			}

			_finish = _start + v.size();
			_end_of_storage = _start + v.capacity();
		}

		void swap(vector<T>& v)
		{
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_end_of_storage, v._end_of_storage);
		}

		//赋值运算符重载，现代写法
		vector<T>& operator=(vector<T> v)
		{
			swap(v);

			return *this;
		}

		//析构函数
		~vector()
		{
			if (_start != nullptr)
			{
				delete[] _start;
				_start = nullptr;
				_finish = nullptr;
				_end_of_storage = nullptr;
			}
		}

		//扩容函数capacity
		void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t sz = size();
				T* tmp = new T[n];
				if (_start)
				{
					//如果是自定义类型，如果是string，则会出现浅拷贝
					//memcpy(tmp, _start, sizeof(T) * sz);
					for (size_t i = 0; i < sz; i++)
					{
						tmp[i] = _start[i];
					}

					delete[] _start;
				}

				_start = tmp;
				_finish = _start + sz;
				_end_of_storage = _start + n;
			}
		}

		//扩容size
		void resize(size_t n, const T& val = T())
		{
			if (n < size())
			{
				_finish = _start + n;
			}
			else
			{
				reserve(n);

				while (_finish != _start + n)
				{
					*_finish = val;
					++_finish;
				}
			}
		}

		//尾插
		void push_back(const T& v)
		{
			if (_finish == _end_of_storage)
			{
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
			}

			*_finish = v;
			++_finish;
			//insert(end(),x)
		}

		//返回capacity
		size_t capacity() const
		{
			return _end_of_storage - _start;
		}

		//返回size
		size_t size() const
		{
			return _finish - _start;
		}

		//重载operator[] 可读可写
		T& operator[](size_t pos)
		{
			assert(pos < size());

			return _start[pos];
		}

		//重载operator[] 只读不可写
		const T& operator[](size_t pos) const
		{ 
			assert(pos < size());

			return _start[pos];
		}

		//插入
		iterator insert(iterator pos, const T& x)
		{
			assert(pos >= _start && pos <= _finish);

			//判断是否扩容
			if (_finish == _end_of_storage)
			{
				size_t len = pos - _start;

				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);

				//解决pos迭代器失效问题
				pos = _start + len;
			}

			iterator end = _finish - 1;
			while (end >= pos)
			{
				*(end + 1) = *end;
				end--;
			}

			*pos = x;
			_finish++;

			return pos;
		}

		//删除
		iterator erase(iterator pos)
		{
			assert(pos >= _start && pos <= _finish);

			iterator it = pos + 1;
			while (it != _finish)
			{
				*(it - 1) = *it;
				++it;
			}

			--_finish;

			return pos;
		}

	private:
		//成员变量给缺省值
		iterator _start = nullptr;
		iterator _finish = nullptr;
		iterator _end_of_storage = nullptr;
	};

	//打印
	template<class T>
	void print(const T& v)
	{
		for (auto e : v)
		{
			cout << e << " ";
		}
		cout << endl;
	}
}

 
测试代码

#define _CRT_SECURE_NO_WARNINGS 1

#include<iostream>
#include<vector>
#include<string>
using namespace std;

#include"vector.h"

void test_vector1()
{
	vec::vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);

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

	for (size_t i = 0; i < v1.size(); i++)
	{
		v1[i]++;
	}

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

	vec::print(v1);
}

void test_vector2()
{
	vec::vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);

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

	v1.insert(v1.begin(), 10);

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

	vec::vector<int>::iterator p = v1.begin() + 3;
	//insert迭代器可能会失效
	//insert建议不要使用这个形参迭代器
	v1.insert(p, 100);

	*p += 10;

	vec::print(v1);
}

void test_vector3()
{
	vec::vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	v1.push_back(5);

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

	//v1.erase(v1.begin());
	auto it = v1.begin()+4;
	v1.erase(it);

	//erase以后，迭代器失效了，不能访问it指向的空间
	//因为vs会对其进行强制检查，访问会报错
	cout << *it << endl;
	++it;
	cout << *it << endl;

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

void test_vector4()
{
	vec::vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	for (auto e : v1)
	{
		cout << e << " ";
	}
	cout << endl;

	vec::vector<int> v2(v1);
	for (auto e : v1)
	{
		cout << e << " ";
	}
	cout << endl;

	vec::vector<int> v3;
	v3 = v1;
	vec::print(v3);
}

void test_vector5()
{
	vector<string> v1;
	v1.push_back("11111");
	v1.push_back("22222");
	v1.push_back("33333");
	v1.push_back("44444");
	v1.push_back("55555");

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

	vector<string> v2(v1);
	for (auto& e : v2)
	{
		cout << e << " ";
	}
	cout << endl;
}

int main()
{
	//test_vector1();
	//test_vector2();
	//test_vector3();
	//test_vector4();
	test_vector5();
	return 0;
}

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

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

相关文章

java 版本企业招标投标管理系统源码，多个行业+及时准确+全程电子化

java 版本企业招标投标管理系统源码，多个行业+及时准确+全程电子化

&#xfeff; 项目说明 随着公司的快速发展&#xff0c;企业人员和经营规模不断壮大&#xff0c;公司对内部招采管理的提升提出了更高的要求。在企业里建立一个公平、公开、公正的采购环境&#xff0c;最大限度控制采购成本至关重要。符合国家电子招投标法律法规及相关规范&am…
阅读更多...
Electron 系统通知 Notification 实践指南

Electron 系统通知 Notification 实践指南

系统通知是桌面应用的常见功能&#xff0c;用于给用户发送提醒&#xff08;刷下存在感 &#x1f642;&#xff09;&#xff0c;还能帮定点击事件以便后续的操作。 Electron 自带通知模块&#xff0c;下方代码是一个简单的示例 const { Notification } require(electron)cons…
阅读更多...
【C#教程】零基础从入门到精通

【C#教程】零基础从入门到精通

今天给大家分享一套零基础从入门到精通&#xff1a;.NetCore/C#视频教程&#xff1b;这是2022年最新整理的、590G的开发教程资料。课程涵盖了.Net各方面的知识&#xff0c;跟着这个教程学习&#xff0c;就足够了。 课程分类 1、C#从基础到精通教程&#xff1b; 2、Winform从…
阅读更多...
Framework开发的热度从未下降~

Framework开发的热度从未下降~

近几日&#xff0c;统计局也发布了就业相关数据&#xff0c;全国失业青年达600多万&#xff0c;面对此数据&#xff0c;我们能想到的是实际的失业人数肯定会比公布的数据要多很多&#xff0c;尤其是表示 “一周工作一小时以上” 也纳入了就业范围。 反观有一批Android开发在如此…
阅读更多...
【数据挖掘torch】 基于LSTM电力系统负荷预测分析（Python代码实现）

【数据挖掘torch】 基于LSTM电力系统负荷预测分析（Python代码实现）

&#x1f4a5;&#x1f4a5;&#x1f49e;&#x1f49e;欢迎来到本博客❤️❤️&#x1f4a5;&#x1f4a5; &#x1f3c6;博主优势&#xff1a;&#x1f31e;&#x1f31e;&#x1f31e;博客内容尽量做到思维缜密&#xff0c;逻辑清晰&#xff0c;为了方便读者。 ⛳️座右铭&a…
阅读更多...
解决 MyBatis-Plus + PostgreSQL 中的 org.postgresql.util.PSQLException 异常

解决 MyBatis-Plus + PostgreSQL 中的 org.postgresql.util.PSQLException 异常

&#x1f337;&#x1f341; 博主猫头虎 带您 Go to New World.✨&#x1f341; &#x1f984; 博客首页——猫头虎的博客&#x1f390; &#x1f433;《面试题大全专栏》 文章图文并茂&#x1f995;生动形象&#x1f996;简单易学&#xff01;欢迎大家来踩踩~&#x1f33a; &a…
阅读更多...
用C语言构建一个手写数字识别神经网络

用C语言构建一个手写数字识别神经网络

(原理和程序基本框架请参见前一篇 "用C语言构建了一个简单的神经网路") &#xff11;&#xff0e;准备训练和测试数据集 从http://yann.lecun.com/exdb/mnist/下载手写数字训练数据集, 包括图像数据train-images-idx3-ubyte.gz 和标签数据 train-labels-idx1-ubyte.…
阅读更多...
Mac 安装配置adb命令环境（详细步骤）

Mac 安装配置adb命令环境（详细步骤）

一、注意&#xff1a;前提要安装java环境。 因为android sdk里边开发的一些包都是依赖java语言的&#xff0c;所以&#xff0c;首先要确保已经配置了java环境。 二、在Mac下配置android adb命令环境&#xff0c;配置方式如下&#xff1a; 1、下载并安装IDE &#xff08;andr…
阅读更多...
Django的生命周期流程图(补充)、路由层urls.py文件、无名分组和有名分组、反向解析(无名反向解析、有名反向解析)、路由分发、伪静态

Django的生命周期流程图(补充)、路由层urls.py文件、无名分组和有名分组、反向解析(无名反向解析、有名反向解析)、路由分发、伪静态

一、orm的增删改查方法&#xff08;补充&#xff09; 1. 查询resmodels.表名(类名).objects.all()[0]resmodels.表名(类名).objects.filter(usernameusername, passwordpassword).all()res models.表名(类名).objects.first() # 判断&#xff0c;判断数据是否有# res如果查询…
阅读更多...
UE4 unlua学习笔记

UE4 unlua学习笔记

将这三个插件放入Plugins内并重新编译 创建一个BlueprintLibrary&#xff0c;声明一个全局函数 在这里声明路径 点击Create Lua Template 在Content的Script即可生成对应的lua文件打开它&#xff01; 显示以上lua代码 打印Hello Unlua 创建该UI&#xff0c;就会在创建UI的Con…
阅读更多...
第5章 最佳实践

第5章 最佳实践

过去的错误 不要怪罪JavaScript 游览器遇到不合法的html会想尽办法将他展现出来游览器遇到不合法的js将拒绝执行它们并报错写js要保障自己代码的健壮性 质疑一切 写js功能前一定要考虑这个功能的合理性&#xff0c;避免造成不可预见的后果写js功能前一定要考虑用户的游览器…
阅读更多...
企业级IT应用运维监控层次架构设计

企业级IT应用运维监控层次架构设计

企业基本都有自己的IT系统&#xff0c;而每个IT系统都有自己的监控系统。 企业级的IT应用监控架构是一种综合性的解决方案&#xff0c;涉及到很多层级和相应的工具。随着企业IT系统的规模和复杂程度的不断增加&#xff0c;监控和管理系统也面临着越来越大的挑战。 大家有时在…
阅读更多...
视频监控汇聚平台EasyCVR告警消息生成后，合成录像显示不了是什么原因？

视频监控汇聚平台EasyCVR告警消息生成后，合成录像显示不了是什么原因？

智能视频监控平台TSINGSEE青犀视频EasyCVR具备视频融合汇聚能力&#xff0c;作为安防视频监控综合管理平台&#xff0c;它支持多协议接入、多格式视频流分发&#xff0c;可支持的主流标准协议有国标GB28181、RTSP/Onvif、RTMP等&#xff0c;以及支持厂家私有协议与SDK接入&…
阅读更多...
Redis事务、管道

Redis事务、管道

一.Redis事务 1.概念 可以一次执行多个命令&#xff0c;本质是一组命令的集合。一个事务中的所有命令都会序列化&#xff0c;按顺序地串行化执行而不会被其它命令插入&#xff0c;不许加塞 2.Redis事务与数据库事物的区别 3.常用命令 4.事务执行情况 正常执行 即整个过程…
阅读更多...
【应用层】HTTPS协议详细介绍

【应用层】HTTPS协议详细介绍

文章目录 前言一、什么是"加密"二、常见的加密方式三、数据摘要&#xff08;数据指纹&#xff09;四、证书总结 前言 HTTPS也是一个应用层协议&#xff0c;是在HTTP协议的基础上引入了一个加密层&#xff0c;由于HTTP协议内容都是按照文本的方式明文传输的&#xff…
阅读更多...
郑州https数字证书

郑州https数字证书

很多注重隐私的网站都注重网站信息的安全&#xff0c;比如购物网站就需要对客户的账户信息以及支付信息进行安全保护&#xff0c;否则信息泄露&#xff0c;客户与网站都有损失&#xff0c;网站也会因此流失大量客户。而网站使用https证书为客户端与服务器之间传输的信息加了一个…
阅读更多...
深度学习笔记-暂退法（Drop out）

深度学习笔记-暂退法（Drop out）

背景 在机器学习的模型中&#xff0c;如果模型的参数太多&#xff0c;而训练样本又太少&#xff0c;训练出来的模型很容易产生过拟合的现象。在训练神经网络的时候经常会遇到过拟合的问题&#xff0c;过拟合具体表现在&#xff1a;模型在训练数据上损失函数较小&#xff0c;预…
阅读更多...
day50-Insect Catch Game（捉虫游戏）

day50-Insect Catch Game（捉虫游戏）

50 天学习 50 个项目 - HTMLCSS and JavaScript day50-Insect Catch Game&#xff08;捉虫游戏&#xff09; 效果 index.html <!DOCTYPE html> <html lang"en"><head><meta charset"UTF-8" /><meta name"viewport"…
阅读更多...
【【STM32学习-3】】

【【STM32学习-3】】

STM32学习-3 下面是对c语言的稍微复习 这个是我们设置好的文件 以后拖出去用就可以了 这里加入关于指针的感想 关于指针数组和数组指针的想法 常规的东西是int a10; int * p&a; &#xff08;p指向了a元素&#xff0c;意思是p等于a的地址 类型是int*&#xff09;就是 整型指…
阅读更多...
C语言假期作业 DAY 10

C语言假期作业 DAY 10

一、选择题 1、求函数返回值&#xff0c;传入 -1 &#xff0c;则在64位机器上函数返回&#xff08; &#xff09; int func(int x) { int count 0; while (x) { count; x x&(x - 1);//与运算 } r eturn count; } A: 死循环 B: 64 C: 32 D: 16 答案解析 正确答案&#xff…
阅读更多...
最新文章

Copyright @ 2022~2023