【c++】list模拟实现

已于 2024-03-03 16:56:51 修改
阅读量904 收藏 16
点赞数 17
分类专栏： c++ 文章标签： c++ list windows
于 2024-03-03 16:37:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yyqzjw/article/details/136426633
版权

list的接口

#pragma once
#include<iostream>
#include<assert.h>
using namespace std;
namespace zjw
{
	template<class T>
	struct listnode    
	{
		listnode* <T>_next;
		listnode* <T>_prev;
		T _data;
		listnode(const T& x = T())
			:_prev(nulllptr)
			,_next(nullptr)
			,_data(x)
		{
		
		
		
		
		}






	};
	template<class T>
	struct _list_iterator
	{
		typedef listnode <T>node;
		
		typedef _list_iterator<T>self;
		node* _node;
		_list_iterator(node* n)
			:_node(n)
		{
		}
		self& operator++()
		{
		}

		self& operator--()
		{
		}
		self operator++(int)
		{
		}
		self operator--(int)
		{
		}
		bool operator!=(const self& s)
		{
		
		}
		bool operator==(const self& s)
		{

		}
		T& operator()
		{
		
		}





	};
     template <class T>
	 class list
	 {    typedef listnode <T>node;
	  public:
		 typedef _list_iterator<T>  iterator;
		 list()
		 {
			 empty_init();

		 
		 }
		 void empty_init()
		 {
		 
		 
		 }
		 iterator begin()
		 {
		 
		 }
		 iterator end()
		 {
		 
		 
		 
		 }
		 void clear()
		 {
		 
		 
		 }
		 ~list
		 {
		 
		 
		 }
		 list(const list<T>& it)
		 {
		 
		 
		 }
		 void push_back(const T&x)
		 {
		 
		 
		 
		 }
		 void push_front(const T& x)
		 {



		 }
		 void pop_back()
		 {
		 
		 
		 
		 }
		 void pop_front()
		 {
		 
		 
		 
		 
		 }
		 void swap(list<T>& tmp)
		 {
			 

		 }
		 list<T>& operator=(list<T>it)
		 {
		 
		 
		 
		 }
		 iterator insert(iterator pos ,const T&x)
		 {
		 
		 
		 
		 
		 
		 }
		 iterator erase(iterator pos)
		 {
		 
		 
		 
		 
		 }
	 private :
		 node* _head;


	 };



}

迭代器前置++，前置–，后置++，后置–

self& operator++()
		{ 

		  _node= _node->next;
		  return * this;



		}

		self& operator--()
		{
			_node = _node->_prev;
			return * this;
		}
		self operator++(int)
		{
			self tmp(*this);
			_node = _node->_next;
			return tmp;


		}
		self operator--(int)
		{
			self tmp(*this);
			_node = _node->_prev;
			return tmp;
			
		}

迭代器重载等于，以及不等于，以及解引用访问数据

         bool operator!=(const self& s)
		{
			return s._node != _node;
		
		}
		bool operator==(const self& s)
		{
			return s._node == _node;
		}
		T& operator*()
		{
			return _node->_data;
		
		}

链表的默认构造，以及尾插，获取链表的头和尾巴，以及测试尾插函数

 list()
		 {
			 empty_init();

		 
		 }
		 void empty_init()
		 {
			 _head = new node();
			 _head->_prev = _head;
			 _head->_next = _head;

		 
		 
		 }
		 iterator begin()
		 {
			 return _head->_next;
		 
		 }
		 iterator end()
		 {
			 return _head;
		 
		 
		 }
		 	 void push_back(const T&x)
		 {
			 node* newnode = new node(x);
			 node* tail = _head->_prev;
			 newnode->_next = _head;
			 newnode->_prev = tail;
			 tail->_next = newnode;
			 _head->_prev = newnode;
			 
		 
		 
		 
		 }

尾插测试，以及迭代器测试

 void test1()
	 {
		 list<int>res;
		 res.push_back(1);
		 res.push_back(2);
		 res.push_back(3);
		 res.push_back(4);
		 list<int> ::iterator it = res.begin();
		 while (it != res.end())
		 {
			 cout <<*it << " ";
			 it++;
		  }
 
	 }

在这里插入图片描述

const迭代器的实现

![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/811e5adc5cac4d7d82a43a8790aa1741.png

我们就可以新增两个带const的begin(),end(),权限平移就可以调动。

	 iterator begin() const
		 {
			 return _head->_next;

		 }
		 iterator end() const
		 {
			 return _head;


		 }

如果我们要修改迭代器所指向位置的值呢？？
在这里插入图片描述
我们应该如何模拟实现一个常量迭代器呢？？
如果按照以下的方式，可以实现吗？？
在这里插入图片描述

所以我们应该怎么实现呢？？
在这里插入图片描述
迭代器中的解引用函数，我们需要让他的返回值不被修改，所以 这个函数的返回值加const 就好了，所以我们在实现一个类，这个类基本和普通迭代器的类一样，只是在解引用函数上有区分。

	template<class T>
	struct const_list_iterator
	{
		typedef    listnode <T>  node;



		typedef const_list_iterator<T> self;


		node* _node;
		const_list_iterator(node* n)
			:_node(n)
		{
		}
		self& operator++()
		{

			_node = _node->_next;
			return *this;



		}

		self& operator--()
		{
			_node = _node->_prev;
			return *this;
		}
		self operator++(int)
		{
			self tmp(*this);
			_node = _node->_next;
			return tmp;


		}
		self operator--(int)
		{
			self tmp(*this);
			_node = _node->_prev;
			return tmp;

		}
		bool operator !=(const self& s)
		{
			return s._node != _node;

		}
		bool operator==(const self& s)
		{
			return s._node == _node;
		}
		const T operator*()
		{
			return _node->_data;

		}
	};

在这里插入图片描述

在这里插入图片描述
这样子，就实现了const 的迭代器，但是重新搞一个类好麻烦呀，于是有大佬就想出了在提供一个模板参数来解决这个问题
在这里插入图片描述

->运算符重载函数

我们可以想一下什么时候会用到->,当指针it指向的是结构体的话，我们可以访问使用
it->data,来访问数据，也可先对指针解引用*it,*it表示拿到这个结构体，然后使用.来访问（*it）.data;

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

		}

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




	 };

测试->

	 void test3()
	 {
		 list<AA>res; 
		 res.push_back(AA(1,1));
		 res.push_back(AA(2, 2));
		 res.push_back(AA(3, 3));
		 res.push_back(AA(4, 4));
		 list<AA> ::iterator it = res.begin();
		 while (it != res.end())
		 {
			 cout << it.operator->()->a1<<":" << it.operator->()->a2 << endl;
			 it++;
	 }
 
	 
	 }

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

这里有一个问题就是->访问也是取数据，但取到的数据能修改吗？这就面临和解引用取数据同样的问题。
我们现在需要做的是const迭代器的不能被将修改，普通的可以修改值
在这里插入图片描述
我发现这里和解引用那里不一样的是，解引用那里是值不可被修改，这里是地址不可被修改
在这里插入图片描述

=运算符重载赋值

	 void swap(list<T>& tmp)
		 {
			 std::swap(_head, tmp._head);

		 }
		 list<T>& operator=(list<T>it)
		 {

			 swap(it);
			 return *this;
		 
		 
		 
		 }

赋值函数测试

 void test4()
	 {
		
		 list<int>res;
		 res.push_back(1);
		 res.push_back(2);
		 res.push_back(3);
		 res.push_back(4);
		 list<int> ret = res;
		 list<int> ::iterator it = ret.begin();
		 while (it != ret.end())
		 {
			 cout << *it << " ";
			 it++;






		 }
		
	 
	 
	 
	 }

在这里插入图片描述

拷贝构造函数

	 list(const list<T>& it)
		 {

			 empty_init();
			 for (auto e : it)
			 {
				 push_back(e);
			 }
		 
		 }

这里与赋值不一样的地方是赋值的话，之前的空间不用放着也没用，就在原空间操作了；拷贝构造是重新开的空间，然后将原来数据尾插到新空间
拷贝构造函数测试

 void test5()
	 {
		 list<int>res;
		 res.push_back(1);
		 res.push_back(2);
		 res.push_back(3);
		 res.push_back(4);
		 list<int> ret(res);
		 list<int> ::iterator it = ret.begin();
		 while (it != ret.end())
		 {
			 cout << *it << " ";
			 it++;
         }

	 
	 
	 }

在这里插入图片描述

insert函数和earse函数

因为之前写的双向链表就是借鉴的这里，如果逻辑不清楚，可以去看一下双向链表那一篇文章
（insert）
在这里插入图片描述

 iterator insert(iterator pos ,const T&x)
		 {
			 node* cur = pos._node;
			 node* prev = cur->_prev;
			 node* newnode = new node(x);
			 newnode->_next = cur;
			 newnode->_prev = prev;
			 prev->_next = newnode;
			 cur->_prev = newnode;
			 return newnode;
		 
		 
		 
		 
		 }

(earse)
在这里插入图片描述

 iterator erase(iterator pos)
		 {
			 assert(pos != end());
			 node* cur = pos._node;
			 node* prev = cur->_prev;
			 node* next = cur->_next;
			 prev->_next = next;
			 next->_prev = prev;
			 delete cur;
			 return next;
		 
		 
		 
		 
		 }

这里insert函数迭代器不会失效，而earse函数迭代器会失效，最好earse完，给迭代器传下一个位置的地址。

析构函数

 void clear()
		 { 
			 iterator it = begin();
			 while (it != end())
			 {
				 it = earse(it);//释放完一个结点，返回下一个结点地址
			 }
		 
		 }
		 ~list()
		 {
			 clear();//完成后只剩头节点
			 delete _head;//释放头节点
			 _head = nullptr;//防止野指针
			 cout<<"析构完成“<<endl;
		 
		 }

析构测试

	 void test8()
	 {
		 list<int>res;
		 res.push_back(1);
		 res.push_back(2);
		 res.push_back(3);
		 res.push_back(4);

		
		 
		 list<int> ::iterator it = res.begin();
		 while (it != res.end())
		 {
			 cout << *it << " ";
			 it++;
		 }
		 res.~list();
	 
	 
	 
	 
	 
	 }

在这里插入图片描述

push_front函数，pop_back()函数，pop_front()函数

因为实现了insert和earse,所以这三个就简单了。

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



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

注意这里的end()是最后一个数据的下一个位置，所以要先–
测试头插

 void test6()
	 {
		 list<int>res;
		 res.push_back(1);
		 res.push_back(2);
		 res.push_back(3);
		 res.push_back(4);
		 
		 list<int> ::iterator it = res.begin();
		 while (it != res.end())
		 {
			 cout << *it << " ";
			 it++;






		 }
		 cout << endl;
		 res.push_front(1000);
		 list<int> ::iterator num = res.begin();
		 while (num != res.end())
		 {
			 cout << *num << " ";
			 num++;






		 }
	 
	 
	 
	 
	 }

在这里插入图片描述
测试头删和尾删

void test7()
	 {
		 list<int>res;
		 res.push_back(1);
		 res.push_back(2);
		 res.push_back(3);
		 res.push_back(4);

		 list<int> ::iterator it = res.begin();
		 while (it != res.end())
		 {
			 cout << *it << " ";
			 it++;






		 }
		 cout << endl;
		 res.pop_front();
		 res.pop_back();
		 list<int> ::iterator num = res.begin();
		 while (num != res.end())
		 {
			 cout << *num << " ";
			 num++;






		 }




	 }

在这里插入图片描述
测试这三个间接测试了insert和erase

源码展示

list.h

#pragma once
#include<iostream>
#include<assert.h>
using namespace std;
namespace zjw
{
	template<class T>
	struct listnode
	{
		listnode<T>* _next;
		listnode<T>* _prev;
		T _data;
		listnode(const T& x = T())
			:_prev(nullptr)
			,_next(nullptr)
			,_data(x)
		{
		
		
		
		
		}






	};
	template<class T ,class res,class ptr>
	struct _list_iterator
	{ 
		typedef    listnode <T>  node;



		typedef _list_iterator<T,res,ptr> self;
		
		
		
		node* _node;
		_list_iterator(node* n)
			:_node(n)
		{
		}
		self& operator++()
		{ 

		  _node= _node->_next;
		  return * this;



		}

		self& operator--()
		{
			_node = _node->_prev;
			return * this;
		}
		self operator++(int)
		{
			self tmp(*this);
			_node = _node->_next;
			return tmp;


		}
		self operator--(int)
		{
			self tmp(*this);
			_node = _node->_prev;
			return tmp;
			
		}
		bool operator !=(const self& s)
		{
			return s._node != _node;
		
		}
		bool operator==(const self& s)
		{
			return s._node == _node;
		}
		res  operator*()
		{
			return _node->_data;
		
		}
	    ptr  operator->()
		{
			return &_node->_data;

		}

	};
	



	
	
     template <class T>
	 class list
	 {
		 typedef    listnode <T>  node;
	 public:
		 typedef _list_iterator<T,T&,T*>  iterator;
		 typedef _list_iterator<T,const T&,const T*>  const_iterator;
		
		 list()
		 {
			 empty_init();

		 
		 }
		 void empty_init()
		 {
			 _head = new node();
			 _head->_prev = _head;
			 _head->_next = _head;

		 
		 
		 }
		 iterator begin()
		 {
			 return _head->_next;
		 
		 }
		 iterator end()
		 {
			 return _head;
		 
		 
		 }
		 const_iterator begin() const
		 {
			 return _head->_next;

		 }
		 const_iterator  end() const
		 {
			 return _head;


		 }
		 iterator erase(iterator pos)
		 {
			 assert(pos != end());
			 node* cur = pos._node;
			 node* prev = cur->_prev;
			 node* next = cur->_next;
			 prev->_next = next;
			 next->_prev = prev;
			 delete cur;
			 return next;




		 }
		 void clear()
		 { 
			 iterator it = begin();
			 while (it != end())
			 {
				 it=erase(it);
			 }
		 
		 }
		 ~list()
		 {
			 clear();
			 delete _head;
			 _head = nullptr;
			 cout << "析构完成" << endl;
		 
		 }
		 list(const list<T>& it)
		 {

			 empty_init();
			 for (auto e : it)
			 {
				 push_back(e);
			 }
		 
		 }
		 void push_back(const T&x)
		 {
			 node* newnode = new node(x);
			 node* tail = _head->_prev;
			 newnode->_next = _head;
			 newnode->_prev = tail;
			 tail->_next = newnode;
			 _head->_prev = newnode;
			 
		 
		 
		 
		 }
		 void push_front(const T& x)
		 {
			 insert(begin(), x);



		 }
		 void pop_back()
		 {
			 erase(--end());
		 
		 
		 }
		 void pop_front()
		 {
		 
			 erase(begin());
		 
		 
		 }
		 void swap(list<T>& tmp)
		 {
			 std::swap(_head, tmp._head);

		 }
		 list<T>& operator=(list<T>it)
		 {

			 swap(it);
			 return *this;
		 
		 
		 
		 }
		 iterator insert(iterator pos ,const T&x)
		 {
			 node* cur = pos._node;
			 node* prev = cur->_prev;
			 node* newnode = new node(x);
			 newnode->_next = cur;
			 newnode->_prev = prev;
			 prev->_next = newnode;
			 cur->_prev = newnode;
			 return newnode;
		 
		 
		 
		 
		 }
	
	 private :
		 node* _head;


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

		 {

		 }




	 };
	 void print_list(const list<AA>it)
	 {
		 list<AA>::const_iterator res =it.begin();
		 while (res!=it.end())
		 {
			
			 cout << res.operator->()->a1 << ":" << res->a2 << endl;
			 res++;







		 }
	 }
	/* void test1()
	 {
		 list<int>res;
		 res.push_back(1);
		 res.push_back(2);
		 res.push_back(3);
		 res.push_back(4);
		  list<int> ::iterator it = res.begin();
		 while (it != res.end())
		 {
			 cout <<*it << " ";
			 it++;
		 





		 }

	 
	 
	 
	 
	 
	 
	 
	 
	 }*/
	 //void test2()
	 //{
		// list<int>res;
		// res.push_back(1);
		// res.push_back(2);
		// res.push_back(3);
		// res.push_back(4);
		// print_list(res);
	 //
	 //
	 //
	 //
	 //
	 //}

	/* void test3()
	 {
		 list<AA>res; 
		 res.push_back(AA(1,1));
		 res.push_back(AA(2,2));
		 res.push_back(AA(3, 3));
		 res.push_back(AA(4, 4));
	
		 print_list(res);
		 }*/

	/* void test4()
	 {
		
		 list<int>res;
		 res.push_back(1);
		 res.push_back(2);
		 res.push_back(3);
		 res.push_back(4);
		 list<int> ret = res;
		 list<int> ::iterator it = ret.begin();
		 while (it != ret.end())
		 {
			 cout << *it << " ";
			 it++;






		 }
		
	 
	 
	 
	 }*/
	/* void test5()
	 {
		 list<int>res;
		 res.push_back(1);
		 res.push_back(2);
		 res.push_back(3);
		 res.push_back(4);
		 list<int> ret(res);
		 list<int> ::iterator it = ret.begin();
		 while (it != ret.end())
		 {
			 cout << *it << " ";
			 it++;






		 }
	

	 
	 
	 }*/
	/* void test6()
	 {
		 list<int>res;
		 res.push_back(1);
		 res.push_back(2);
		 res.push_back(3);
		 res.push_back(4);
		 
		 list<int> ::iterator it = res.begin();
		 while (it != res.end())
		 {
			 cout << *it << " ";
			 it++;






		 }
		 cout << endl;
		 res.push_front(1000);
		 list<int> ::iterator num = res.begin();
		 while (num != res.end())
		 {
			 cout << *num << " ";
			 num++;






		 }
	 
	 
	 
	 
	 }*/
	/* void test7()
	 {
		 list<int>res;
		 res.push_back(1);
		 res.push_back(2);
		 res.push_back(3);
		 res.push_back(4);

		 list<int> ::iterator it = res.begin();
		 while (it != res.end())
		 {
			 cout << *it << " ";
			 it++;






		 }
		 cout << endl;
		 res.pop_front();
		 res.pop_back();
		 list<int> ::iterator num = res.begin();
		 while (num != res.end())
		 {
			 cout << *num << " ";
			 num++;






		 }




	 }*/
	 void test8()
	 {
		 list<int>res;
		 res.push_back(1);
		 res.push_back(2);
		 res.push_back(3);
		 res.push_back(4);

		
		 
		 list<int> ::iterator it = res.begin();
		 while (it != res.end())
		 {
			 cout << *it << " ";
			 it++;
		 }
		 res.~list();
	 
	 
	 
	 
	 
	 }


	 



}

.cpp

#include"list.h"
int main()
{

	zjw::test8();

}
#小多子
关注
专栏目录
模拟实现list超详解（C++）
m0_67430750的博客
04-25 3238
简易版list模拟实现超详解
C++ list模拟实现
Han同学
12-25 3119
C++模拟实现list
【C++】list模拟实现
chuxinchangcun的博客
01-10 6272
由源码可以得知,list的底层是带头双向循环链表—list实际上是一个带头双向循环链表,要实现list,则首先需要实现一个结点类,而一个结点需要存储的信息为:数据、前驱指针、后继指针而对于该结点类的成员函数来说,我们只需实现一个构造函数即可,因为该结点类只需要根据数据来构造一个结点即可,而结点的释放则由list的析构函数来完成, 构造函数 构造函数直接根据所给数据构造一个结点即可,构造出来的结点的数据域存储的就是所给数据,而前驱指针和后继指针均初始化为空指针即可 若构造结点时未传入数据,则默认以list
C++ —— 模拟实现list
weixin_59913110的博客
12-03 891
模拟实现了list容器的常用接口，初步认识模板的用法。
【C++】list的模拟实现
qq_62939852的博客
03-11 1638
C++中，Listnode作为类名，而next和prev都是类指针，指针引用成员时使用->，而对象引用成员时使用 .若在数组上有一个int类型的指针，解引用是int类型的数据，再++可以加载下一个位置，因为物理空间是连续的。erase函数执行后，it所指向的节点被删除，因此it无效，在下一次使用it时，必须先给it赋值。同样若在链表上，解引用类型为 node，再++不能到下一个节点，因为物理空间不连续。++pnode，找到下一个节点的地址，但是下一个节点不一定是要的节点。
【C++】list的模拟实现【完整理解版】
m0_74044018的博客
09-10 1193
list的模拟实现，主讲你不理解的地方，每个地方都会详细解释，重在理解
【C++】List模拟实现
Renswc的博客
05-31 3147
C++中的list是一种双向链表（doubly linked list）的实现。它是C++标准库中的一种容器，可以存储一系列元素，并且允许在任意位置插入、删除和访问元素。对于双向链表有疑问的可以点击查看数据结构——带头双向循环链表详解对于list大部分和前面学习过的vector类似，关键点在于理解list的迭代器的封装以及const迭代器，还有list实现包括了三个类，它们分别都有类模板，容易绕晕，需要好好理解清楚
【爱上C++】list用法详解、模拟实现
2301_76677973的博客
07-22 4761
文档在这里→官方文档←list是可以在常数范围内（ 时间复杂度为O(1) ）在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代(双向迭代器)。list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效。
【C++】list类模拟实现
qq_66314292的博客
11-09 2247
list类的模拟实现
C++——list的使用及其模拟实现
Forward♞的博客
01-28 1699
作为标准模板库中的容器，list同样也是一个类模板如果要定义一个list对象，就需要指定其存储的数据类型T。list
C++ 模拟实现list(迭代器)实现代码
01-01
C++ 模拟实现list(迭代器) 实现代码： #pragma once; #include #include #include using namespace std; template struct __ListNode { T _data; __ListNode* _next; __ListNode* _prev; __ListNode(const T&...
C++模拟实现list
03-11
C++模拟实现list
【C语言系统编程】【第三部分：网络编程】3.2 数据传输和协议
10-03 1513
在进行网络编程时，有时需要设计并实现自定义协议，以满足特定应用的需求。自定义协议设计需要考虑到数据的传输、安全、效率等多方面因素。清晰性：协议应具有清晰的语法和语义，使开发者能快速理解和实现。扩展性：协议应允许未来的功能扩展，而不破坏现有功能。安全性：数据传输过程中应考虑加密和校验，以保证数据不被篡改。高效性：应尽可能减少网络带宽占用，提升数据传输效率。容错性：协议应能处理各种网络异常情况，如数据丢失、重复和延迟。
使用socket编程来实现一个简单的C/S模型（TCP协议）
caiji0169的博客
10-02 1718
下图是基于TCP协议的客户端/服务器程序的一般流程：服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。数据传输的过程：建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，
将脚本编译为pyd文件
cdinten的专栏
10-01 448
Python虽然作为一种解释性语言，通常是使用解释器处理脚本的方式完成工作，但是也具有和很多其他诸如C、C#语言等类似的方式，可以将.py文件编译为*.pyd文件，即Python动态链接库文件。关于动态链接库的优缺点这里就不展开细说了，具体介绍如何编译及使用。要将Python文件编译成.pyd文件，可以使用Cython，以下是基本的操作步骤。
windows C++-创建数据流代理(三)
最新发布
苏洛的博客
10-08 286
控制流指的是程序中操作的执行顺序。 控制流是通过使用条件语句、循环等控制结构调节的。 此外，数据流指的是一种编程模型，在这种模型中，只有当所有需要的数据都可用时，才会进行计算。 数据流编程模型与消息传递这一概念相关，其中程序的独立组件通过发送消息相互通信。 异步代理同时支持控制流和数据流编程模型。 尽管控制流模型适用于许多情况，但数据流模型也适用于其他一些情况，例如，当代理接收数据并执行基于该数据的有效负载的操作时。
第 21 章 一条记录的多幅面孔——事务的隔离级别与 MVCC
weixin_45740473的博客
10-02 1033
并发的事务在运行过程中会出现一些可能的引发一致性问题SQL 标准中有4种隔离级别版本链ReadView。
C++：图的最短路径问题
han2205277149的博客
10-04 1105
最短路径问题是图的一个比较典型的应用问题。例如，给定某公路网的n个城市以及这些城市之间相通公路的距离，能否找到城市A到城市B之间一条距离最近的通路呢？如果将城市用顶点表示城市间的公路用边表示，公路的长度作为边的权值，这个问题就归结为在网图中求顶点A和顶点B的最短路径。
C++访问权限
qq_51365682的博客
10-02 119
保护权限 protect 成员类内可以访问 类外不可以访问 子类可以访问父类中的保护内容。私有权限private 成员类内可以访问 类外不可以访问 子类不可以访问负类私有内容。公共权限 public 成员类内可以访问 类外可以访问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

#小多子

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值