[STL-list]介绍、与vector的对比、模拟实现的迭代器问题

news2024/11/28 19:00:04

一、list使用介绍

  1.  list的底层是带头双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。
  2. 与其他的序列式容器相比(array，vector，deque)，list通常在任意位置进行插入、移除元素的执行效率更好
  3. list最大的缺陷是不支持任意位置的随机访问，比如：要访问list的第6个元素，必须从已知的位置(比如头部或者尾部)迭代到该位置，在这段位置上迭代需要线性的时间开销；
常用接口：

构造函数：

构造函数接口说明
list (size_type n, const value_type& val = value_type())构造的list中包含n个值为val的元素
list()构造空的list
list (const list& x)拷贝构造函数
list (InputIterator first, InputIterator last)用[first, last)区间中的元素构造list

代码演示：

    list<int> l1;                         // 构造空的l1
    list<int> l2(4, 100);                 // l2中放4个值为100的元素
    list<int> l3(l2.begin(), l2.end());  // 用l2的[begin(), end()）左闭右开的区间构造l3
    list<int> l4(l3);                    // 用l3拷贝构造l4

    // 以数组为迭代器区间构造l5
    int array[] = { 16,2,77,29 };
    list<int> l5(array, array + sizeof(array) / sizeof(int));

    // 列表格式初始化C++11
    list<int> l6{ 1,2,3,4,5 };

list iterator的使用

对于迭代器的使用我们可以把它理解为一个指针，指向ist的某个节点

函数声明接口说明
begin + end返回第一个元素的迭代器+返回最后一个元素下一个位置的迭代器
rbegin+ rend返回第一个元素的reverse_iterator,即end位置，返回最后一个元素下一个位置reverse_iterator,即begin位置

【注意】
1. begin与end为正向迭代器，对迭代器执行++操作，迭代器向后移动
2. rbegin(end)与rend(begin)为反向迭代器，对迭代器执行++操作，迭代器向前移动

代码演示：

    list<int> lt(4, 100);  
    list<int>::iterator it = lt.begin();
    while (it != lt.end())
    {
        cout << *it << " ";
        ++it;
    }       
    cout << endl;

    // C++11范围for的方式遍历
    for (auto& e : lt)
        cout << e << " ";
     cout << endl;

list modifiers

函数声明接口说明
push_front在list首元素前插入值为val的元素
pop_front删除list中第一个元素
push_back在list尾部插入值为val的元素
pop_back删除list中最后一个元素
insert在list position 位置中插入值为val的元素
erase删除list position位置的元素
swap交换两个list中的元素
clear清空list中的有效元素

代码演示：

void TestList1()
{
    int array[] = { 1, 2, 3 };
    list<int> L(array, array + sizeof(array) / sizeof(array[0]));

    // 在list的尾部插入4，头部插入0
    L.push_back(4);
    L.push_front(0);

    // 删除list尾部节点和头部节点
    L.pop_back();
    L.pop_front();
}

// insert /erase 
void TestList2()
{
    int array1[] = { 1, 2, 3 };
    list<int> L(array1, array1 + sizeof(array1) / sizeof(array1[0]));

    // 获取链表中第二个节点
    auto pos = ++L.begin();
    cout << *pos << endl;

    // 在pos前插入值为4的元素
    L.insert(pos, 4);

    // 在pos前插入5个值为5的元素
    L.insert(pos, 5, 5);

    // 在pos前插入[v.begin(), v.end)区间中的元素
    vector<int> v{ 7, 8, 9 };
    L.insert(pos, v.begin(), v.end());

    // 删除pos位置上的元素
    L.erase(pos);

    // 删除list中[begin, end)区间中的元素，即删除list中的所有元素
    L.erase(L.begin(), L.end());
}

// resize/swap/clear
void TestList3()
{
    // 用数组来构造list
    int array1[] = { 1, 2, 3 };
    list<int> l1(array1, array1 + sizeof(array1) / sizeof(array1[0]));

    // 交换l1和l2中的元素
    list<int> l2;
    l1.swap(l2);

    // 将l2中的元素清空
    l2.clear();
    cout << l2.size() << endl;
}

其他接口

二、与vector对比

vectorlist
底
层
结
构		动态顺序表，一段连续空间带头结点的双向循环链表
随
机
访
问		支持随机访问，访问某个元素效率O(1)不支持随机访问，访问某个元素效率O(N)
插
入
和
删
除		任意位置插入和删除效率低，需要搬移元素，时间复杂度为O(N)，插入时有可能需要增容，增容：开辟新空间，拷贝元素，释放旧空间，导致效率更低任意位置插入和删除效率高，不需要搬移元素，时间复杂度为
O(1)
空
间
利
用
率		底层为连续空间，不容易造成内存碎片，空间利用率高，缓存利用率高底层节点动态开辟，小节点容易造成内存碎片，空间利用率低，缓存利用率低
迭
代
器		原生态指针对原生态指针(节点指针)进行封装
迭
代
器
失
效		在插入元素时，要给所有的迭代器重新赋值，因为插入
元素有可能会导致重新扩容，致使原来迭代器失效，删
除时，当前迭代器需要重新赋值否则会失效		插入元素不会导致迭代器失效，删除元素时，只会导致当前迭代器失效，其他迭代器不受影响
使
用
场
景		需要高效存储，支持随机访问，不关心插入删除效率大量插入和删除操作，不关心随机访问

vector与list排序效率对比：

void test_op1()
{
	srand(time(0));
	const int N = 1000000;

	list<int> lt1;
	list<int> lt2;

	vector<int> v;

	for (int i = 0; i < N; ++i)
	{
		auto e = rand() + i;
		lt1.push_back(e);
		v.push_back(e);
	}

	int begin1 = clock();
	// 
	sort(v.begin(), v.end());
	int end1 = clock();

	int begin2 = clock();
	lt1.sort();
	int end2 = clock();

	printf("vector sort:%d\n", end1 - begin1);
	printf("list sort:%d\n", end2 - begin2);
}

 

void test_op2()
{
	srand(time(0));
	const int N = 1000000;

	list<int> lt1;
	list<int> lt2;

	for (int i = 0; i < N; ++i)
	{
		auto e = rand();
		lt1.push_back(e);
		lt2.push_back(e);
	}

	int begin1 = clock();
	// vector

	vector<int> v(lt2.begin(), lt2.end());
	// 
	sort(v.begin(), v.end());

	// lt2
	lt2.assign(v.begin(), v.end());

	int end1 = clock();

	int begin2 = clock();
	lt1.sort();
	int end2 = clock();

	printf("list copy vector sort copy list sort:%d\n", end1 - begin1);
	printf("list sort:%d\n", end2 - begin2);
}

可见list的排序效率是非常低的，甚至将list的数据导入vector中排完序在导回来的效率都比直接在list中排序的效率快，这是因为list不支持下标随机访问，只能依靠迭代器迭代到指定位置访问，而排序过程中避免不了需要访问大量中间元素，所以list并不适合对数据进行排序

三、list迭代器问题

链表节点与链表结构

节点包含三部分：前驱指针、后驱指针、数据。list封装了头节点的指针，可以根据该指针对后续节点进行遍历

    template<class T>
	struct ListNode
	{
		ListNode* _next;
		ListNode* _prev;
		T _data;
        //节点的构造函数
		ListNode(const T& x = T())
			:_next(nullptr)
			,_prev(nullptr)
			,_data(x)
		{}
	};

    template<class T>
	class list
	{
        void Empty_Init()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
			_size = 0;
		}

		//构造函数
		list()
		{
			Empty_Init();
		}

	private:
		Node* _head;
		size_t _size;
	};
如何设定list迭代器

        在string与vector的模拟实现中，迭代器使用的都是原生指针T*，这是因为原生指针可以满足迭代器的要求，++可以指向下一个元素，解引用可以访问该元素，他们可以使用原生指针的根本原因是他们储存数据的结构都是连续的物理地址。

        在list中原生指针Node*不能满足我们的要求，因为list的节点都是依靠指针连接起来的，其物理地址并不是连续的，++指向的并不是下一个元素，而是指向了跳过了一个Node的大小的的地址，并且迭代器希望解引用直接可以访问节点中的数据，而*（Node*）却是一个节点类型，所以在list中使用原生指针并不符合迭代器的要求。

         所以我们可以自己新建一个类，作为迭代器的类型，在其中封装了头节点，就可以访问该链表了，并且我们在该类中可以通过运算符重载改变++与解引用的行为，这样就可以使用迭代器访问链表数据了

    template<class T>
	struct ListIterator
	{
		typedef ListNode<T> Node;
		typedef ListIterator<T> Self;

		Node* _node;
		ListIterator(Node* _node)
			:_node(_node)
		{}

		T& operator*()
		{
			return _node->_data;
		}

		//前置++
		Self& operator++()
		{
			_node = _node->_next;
			return *this;
		}
        //后置++
		Self operator++(int)
		{
			Self tmp(_node);
			_node = _node->_next;
			return tmp;
		}

	};
    
    template<class T>
	class list
	{
        void Empty_Init()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
			_size = 0;
		}
    
		//构造函数
		list()
		{
			Empty_Init();
		}
        
        iterator begin()
		{
			//隐式类型转换
			return _head->_next;
		}

		iterator end()
		{
			//隐式类型转换
			return _head;
		}
	private:
		Node* _head;
		size_t _size;
	};
完善迭代器功能  
operator->的重载

        但是上述代码具有一定的局限性，例如当T为一个结构体A时，*iterator返回的是结构体A，想要访问结构体中的数据还需要用 . 例如：*(it).a1，但是这样写有点多次一举，因为迭代器it本身就是指向节点的指针，访问数据可以直接使用 ->,例如：it->a1,所以我们还需要将->重载一下

  T* operator->()
 {
    //返回数据的地址
	return &_node->_data;
 }

结构体Ａ存储在节点的＿data中，这里返回了＿data的地址，如果按照正常的思路进行访问，应该按照如下的方式：it.operator->()->_a1 应该是两个箭头，第一个箭头代表运算符的重载，第二个代表指针解引用访问数据。
但是编译器为了方便查看会进行优化，将两个箭头变成了一个箭头 it->_a1 ，这样直接可以访问

const迭代器

const的本质就是为了禁止对成员进行修改，所以我们只需要const迭代器只需要对非const迭代器稍加修改即可

    template<class T>
	struct ListConstIterator
	{
		typedef ListNode<T> Node;
		typedef ListConstIterator<T> Self;

		Node* _node;
		ListConstIterator(Node* _node)
			:_node(_node)
		{}

		const T& operator*()
		{
			return _node->_data;
		}

		const T* operator->()
		{
			return &_node->_data;
		}

	};

但是这样const迭代器与非const迭代器这两个类的重合度非常高，仅仅是函数返回值前是否加用const修饰的区别，所以我们可以利用模板

    typedef ListIterator<T,T&,T*> iterator;
    typedef ListIterator<T,const T&,const T*> const_iterator;
    ---------------------------------
    template<class T,class Ref,class Ptr>
	struct ListIterator
	{
		typedef ListNode<T> Node;
		typedef ListIterator<T, Ref, Ptr> Self;

		Node* _node;
		ListIterator(Node* _node)
			:_node(_node)
		{}

		Ref operator*()
		{
			return _node->_data;
		}

		Ptr operator->()
		{
			return &_node->_data;
		}
		//前置++
		Self& operator++()
		{
			_node = _node->_next;
			return *this;
		}

		Self operator++(int)
		{
			Self tmp(_node);
			_node = _node->_next;
			return tmp;
		}
	};
完整代码：
#include<iostream>
using namespace std;
namespace zyq
{
	template<class T>
	struct ListNode
	{
		ListNode* _next;
		ListNode* _prev;
		T _data;

		ListNode(const T& x = T())
			:_next(nullptr)
			,_prev(nullptr)
			,_data(x)
		{}
	};

	//template<class T>
	//struct ListIterator
	//{
	//	typedef ListNode<T> Node;
	//	typedef ListIterator<T> Self;

	//	Node* _node;
	//	ListIterator(Node* _node)
	//		:_node(_node)
	//	{}

	//	T& operator*()
	//	{
	//		return _node->_data;
	//	}

	//     T* operator->()
	//	{
	//		return &_node->_data;
	//	}

	//	//前置++
	//	Self& operator++()
	//	{
	//		_node = _node->_next;
	//		return *this;
	//	}

	//	Self operator++(int)
	//	{
	//		Self tmp(_node);
	//		_node = _node->_next;
	//		return tmp;
	//	}

	//	bool operator!=(const Self& it)
	//	{
	//		return !(_node == it._node);
	//	}

	//	bool operator==(const Self& it)
	//	{
	//		return _node == it._node;
	//	}

	//};

	//template<class T>
	//struct ListConstIterator
	//{
	//	typedef ListNode<T> Node;
	//	typedef ListConstIterator<T> Self;

	//	Node* _node;
	//	ListConstIterator(Node* _node)
	//		:_node(_node)
	//	{}

	//	const T& operator*()
	//	{
	//		return _node->_data;
	//	}

	//	const T* operator->()
	//	{
	//		return &_node->_data;
	//	}

	//	//前置++
	//	 Self& operator++()
	//	{
	//		_node = _node->_next;
	//		return *this;
	//	}

	//	Self operator++(int)
	//	{
	//		Self tmp(_node);
	//		_node = _node->_next;
	//		return tmp;
	//	}

	//	bool operator!=(const Self& it)
	//	{
	//		return !(_node == it._node);
	//	}

	//	bool operator==(const Self& it)
	//	{
	//		return _node == it._node;
	//	}
	//};

	template<class T,class Ref,class Ptr>
	struct ListIterator
	{
		typedef ListNode<T> Node;
		typedef ListIterator<T, Ref, Ptr> Self;

		Node* _node;
		ListIterator(Node* _node)
			:_node(_node)
		{}

		Ref operator*()
		{
			return _node->_data;
		}

		Ptr operator->()
		{
			return &_node->_data;
		}
		//前置++
		Self& operator++()
		{
			_node = _node->_next;
			return *this;
		}

		Self operator++(int)
		{
			Self tmp(_node);
			_node = _node->_next;
			return tmp;
		}

		bool operator!=(const Self& it)
		{
			return !(_node == it._node);
		}

		bool operator==(const Self& it)
		{
			return _node == it._node;
		}

	};
	template<class T>
	class list
	{
	public:
		typedef ListNode<T> Node;
		//typedef ListIterator<T> iterator;
		//typedef ListConstIterator<T> const_iterator;
		typedef ListIterator<T,T&,T*> iterator;
		typedef ListIterator<T,const T&,const T*> const_iterator;

		iterator begin()
		{
			//隐式类型转换
			return _head->_next;
		}

		iterator end()
		{
			//隐式类型转换
			return _head;
		}

		const_iterator begin() const
		{
			//隐式类型转换
			return _head->_next;
		}

		const_iterator end() const
		{
			//隐式类型转换
			return _head;
		}

		void Empty_Init()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
			_size = 0;
		}

		//构造函数
		list()
		{
			Empty_Init();
		}

		//拷贝构造
		list(const list<T>& lt)
		{
			Empty_Init();
			for (auto& e : lt)
			{
				push_back(e);
			}
		}

		void swap(list<T> lt)
		{
			std::swap(_head, lt._head);
			std::swap(_size, lt._size);
		}

		//赋值运算符重载
		list<T>& operator=(list<T> lt)
		{
			swap(lt);
			return *this;
		}

		~list()
		{
			iterator it = begin();
			while (it != end())
			{
				it=erase(it);
			}
			delete _head;
			_head = nullptr;
		}

		size_t size()
		{
			return _size;
		}

		/*void push_back(const T& x)
		{
			Node* newnode = new Node(x);
			Node* tail = _head->_prev;

			tail->_next = newnode;
			newnode->_prev = tail;
			newnode->_next = _head;
			_head->_prev = newnode;
			_size++;
		}*/

		void push_back(const T& x)
		{
			insert(end()  , x);
		}

		void  push_front(const T& x)
		{
			insert(begin(), x);
		}

		void pop_back()
		{
			erase(--end());
		}

		void pop_front()
		{
			erase(begin());
		}

		void insert(iterator pos, const T& x)
		{
			Node* newnode = new Node(x);
			Node* cur = pos._node;
			Node* prev = cur->_prev;

			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = cur;
			cur->_prev = newnode;
			_size++;
		}

		iterator erase(iterator pos)
		{
			Node* prev = pos._node->_prev;
			Node* next = pos._node->_next;
			prev->_next = next;
			next->_prev = prev;
			delete pos._node;
			_size--;
			return next;
		}

	private:
		Node* _head;
		size_t _size;
	};

	template<class T>
	void PrintList(const list<T>& clt)
	{
		typename list<T>::const_iterator it = clt.begin();
		while (it != clt.end())
		{
			cout << *it << " ";
			it++;
		}
		cout << endl;
	}

	void testlist1()
	{
		list<int> lt;
		lt.push_back(1);
		lt.push_back(2);
		lt.push_back(3);
		lt.push_back(4);
		list<int>::iterator it = lt.begin();
		while (it != lt.end())
		{
			cout << *it << " ";
			it++;
		}
		cout << endl;
		/*lt.push_back(9);
		lt.pop_front();*/
		PrintList(lt);
		list<int> lt1(lt);
		PrintList(lt1);
		list<int> lt2;
		lt2 = lt;
		PrintList(lt2);
	}

	struct A
	{
		int _a1;
		int _a2;
		A(int a1 = 0, int a2 = 0)
			:_a1(a1)
			, _a2(a2)
		{}
	};

	void testlist2()
	{
		list<A> lt;
		lt.push_back({ 1,2 });
		lt.push_back(A(1,2));
		list<A>::iterator it = lt.begin();
		while (it != lt.end())
		{
			//cout << (*it)._a1 << " " << (*it)._a2 << " ";
			cout << it->_a1 << " " << it->_a2 << " ";
			it++;
		}
		cout << endl;
	}
}

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

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

相关文章

nginx部署前端教程

nginx部署前端教程

目录 一、前言二、部署三、注意四、参考 一、前言 一般来说现在的软件项目&#xff0c;都是分用户端以及管理端的&#xff0c;并且是前后端分离的&#xff0c;这里我来记录一下部署两个前端的教程。 部署前端之前需要的准备工作是部署springBoot后端程序&#xff0c;这里我do…
阅读更多...
性能分析-nginx

性能分析-nginx

tomcat 像kyj项目请求直接对接 tomcat&#xff0c;tomcat的连接池就会直接影响“并发用户数” 如果这种情况下做性能测试的时候&#xff0c;并发用户数不能满足要求&#xff0c;可以适当加大线程池的配置。 如&#xff1a;项目性能测试发现项目所在机器&#xff0c;资源利用率…
阅读更多...
conda创建虚拟环境太慢，Collecting package metadata (current_repodata.json): failed

conda创建虚拟环境太慢，Collecting package metadata (current_repodata.json): failed

(省流版&#xff1a;只看加粗红色&#xff0c;末尾也有哦) 平时不怎么用conda&#xff0c;在前公司用服务器的时候用的是公司的conda源&#xff0c;在自己电脑上直接用python创建虚拟环境完事儿&#xff0c;所以对conda的配置并不熟悉~~【狗头】。但是python虚拟环境的最大缺点…
阅读更多...
每日面经：计算机网络part1

每日面经：计算机网络part1

1. 计算机网络的组成部分有哪些&#xff1f; a. 硬件设备&#xff1a;计算机网络由各种硬件设备组成&#xff0c;包括计算机、服务器、路由器、交换机、网卡等。这些设备通过物理连接&#xff08;如网线、光纤&#xff09;相互连接。 b. 协议&#xff1a;计算机网络中的通信需…
阅读更多...
二、计算机网络物理层基础知识

二、计算机网络物理层基础知识

一、物理层 物理层接口特性&#xff1a;解决如何在连接各种计算机传输媒体上的传输数据比特流&#xff0c;而不是指具体的传输媒体 物理层的主要任务 &#xff1a;确定与传输媒体接口有关的一些特性>定义标准 1、机械特性&#xff1a;定义物理连接的特性&#xff0c;规定物理…
阅读更多...
【C++】RapidJSON 设置支持 std::string，防止编译报错

【C++】RapidJSON 设置支持 std::string，防止编译报错

问题 rapidjson 创建 json 数据&#xff0c;使用 std::string 字符串进行赋值&#xff0c;编译时&#xff0c;抱一堆错误 .... rapidjson/include/rapidjson/document.h:690:5: note: candidate expects 0 arguments, 1 provided [build] make[2]: *** [main/CMakeFiles/ma…
阅读更多...
软件杯 深度学习人体语义分割在弹幕防遮挡上的实现 - python

软件杯 深度学习人体语义分割在弹幕防遮挡上的实现 - python

文章目录 1 前言1 课题背景2 技术原理和方法2.1基本原理2.2 技术选型和方法 3 实例分割4 实现效果5 最后 1 前言 &#x1f525; 优质竞赛项目系列&#xff0c;今天要分享的是 &#x1f6a9; 深度学习人体语义分割在弹幕防遮挡上的应用 该项目较为新颖&#xff0c;适合作为竞…
阅读更多...
基于Springboot4S店车辆管理系统

基于Springboot4S店车辆管理系统

采用技术 基于Springboot4S店车辆管理系统的设计与实现~ 开发语言&#xff1a;Java 数据库&#xff1a;MySQL 技术&#xff1a;SpringBootMyBatis 工具&#xff1a;IDEA/Ecilpse、Navicat、Maven 页面展示效果 管理员功能 首页 销售员管理 维修员管理 客户管理 供应…
阅读更多...
前端开发之Element树结构组件el-input的type=“password“时候账号密码自动填充解决方案

前端开发之Element树结构组件el-input的type=“password“时候账号密码自动填充解决方案

Element树结构组件el-input的type“password“时候账号密码自动填充解决方案 前言效果图解决方案 前言 在使用element的input的password当参数和login的参数相同时&#xff0c;在浏览器保存的用户名密码会自动填充&#xff0c;导致input附加上默认值 使用场景一般是在用户管理…
阅读更多...
海量智库 | ANY权限原理介绍

海量智库 | ANY权限原理介绍

ANY权限是Vastbase中的一种特殊的管理权限&#xff0c;用户能够通过ANY权限执行更广泛的操作&#xff0c;更加便利的管理数据库。 本文将为您介绍ANY权限管理的相关原理。 ANY权限管理相关解释 ANY权限管理&#xff0c;是对数据库内的某一类对象的所有实体进行特定的权限管理…
阅读更多...
数据产品+AI产品 通关上岸，创建能带来商业价值的AI产品，学习AI产品开发

数据产品+AI产品 通关上岸，创建能带来商业价值的AI产品，学习AI产品开发

数据产品 AI产品 通关上岸，创建能带来商业价值的AI产品，学习AI产品开发流程 数据产品+AI产品 通关上岸，创建能带来商业价值的AI产品，学习AI产品开发 - 百创网-源码交易平台_网站源码_商城源码_小程序源码 人工智能快速渗入到各个行业，AI产品经理缺口高达6.8万，成为稀缺…
阅读更多...
数字电子基础——编码器

数字电子基础——编码器

编码器 编码&#xff1a;用文字、符号或数字表示特定对象的过程。在数字电路中&#xff0c;采用二进制进行编码 编码器&#xff1a;实现编码功能的电路 二进制编码器 用 n n n 位二进制代码对 N 2 n N2^n N2n 个信号进行编码的电路 应用举例 【例】设计一个能将 I 0 、…
阅读更多...
【cocos creator】【编辑器插件】cocos creator文件复制时，解决cocos creator uuid冲突

【cocos creator】【编辑器插件】cocos creator文件复制时，解决cocos creator uuid冲突

&#xff01;&#xff01;&#xff01;修改前先备份 1、将文件夹放在packages文件夹下 2、打开项目&#xff0c;选择要刷新uuid的文件夹 3、菜单栏点击 扩展->refresh-uuid 4、等控制台提示&#xff1a;资源uuid刷新完成&#xff0c;重启项目&#xff08;&#xff01;&#…
阅读更多...
JavaScript(二)-Web APIS

JavaScript(二)-Web APIS

文章目录 Web API 基本认知作用和分类什么是DOMDOM树DOM对象获取DOM对象操作元素内容操作元素属性操作元素常用属性操作元素样式属性自定义属性 定时器-间歇函数定时器函数的理解定时器函数使用间歇函数 事件监听与绑定事件监听事件监听版本事件类型事件对象什么是事件对象获取…
阅读更多...
转让名称带中国的金融控股集团公司要多少钱

转让名称带中国的金融控股集团公司要多少钱

随着公司的发展和市场竞争的影响&#xff0c;越来越多的创业者希望注册一家好名称的公司&#xff0c;以提高企业知名度和竞争力。但是&#xff0c;注册中字头无地域公司需要满足一定的条件和流程。本文将对中字头无地域公司注册条件及流程进行详细的介绍。可以致电咨询我或者来…
阅读更多...
Sketch是免费软件吗？这款软件支持导入！

Sketch是免费软件吗？这款软件支持导入！

Sketch 是一款针对网页、图标、插图等设计的矢量绘图软件。Sketch 的操作界面非常简单易懂&#xff0c;帮助全世界的设计师创作出许多不可思议的作品。但是同时&#xff0c;Sketch 也有一些痛点&#xff1a;使用 Sketch 需要安装 InVision、Abstract 、Zeplin 等插件&#xff0…
阅读更多...
粉丝答疑：电脑蓝屏了怎么办？

粉丝答疑：电脑蓝屏了怎么办？

昨天大白在直播的时候&#xff0c;有粉丝朋友在直播间问到了大白电脑蓝屏了怎么办&#xff1f;今天也特意帮粉丝朋友整理和收集了常见电脑蓝屏代码大全。 电脑蓝屏代码大全及解决办法合集 代码 含意 0 0x00000000 作业完成。 1 0x00000001 不正确的函数。 2 0x00000002 系…
阅读更多...
qt自定义窗口在拖动过程中出现抖动且拖动后位置看上去不对

qt自定义窗口在拖动过程中出现抖动且拖动后位置看上去不对

自定义窗口拖动 引言开发环境关键性代码运行结果原因分析改进代码运行结果globalPos()globalPosition()再次修改代码运行结果区别 引言 本文旨在一个问题的记录&#xff1a;自定义窗口拖动的过程中&#xff0c;窗口不能很好的跟随鼠标移动&#xff0c;此外会出现窗口拖动时抖动…
阅读更多...
剑指Offer题目笔记29（动态规划矩阵路径问题）

剑指Offer题目笔记29（动态规划矩阵路径问题）

面试题98: 问题&#xff1a; ​ 一个机器人从m x n的格子的左上角出发&#xff0c;它每一步只能向下走或者向右走&#xff0c;计算机器人从左上角到达右下角的路径数量。 解决方案&#xff1a; 机器人每走一步都有两个选择&#xff0c;要么向下走要么向右走。一个任务需要多…
阅读更多...
curl下载nexus中的jar包

curl下载nexus中的jar包

下载并保持原名称 curl -u admin:password -O "http://127.0.0.1:8081/repository/maven-snapshots/com/edgej/edgej-modules-research/1.0-SNAPSHOT/edgej-modules-research-1.0-20240407.090116-1.jar"下载并重命名 curl -u admin:password -o "edgej-modul…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023