当前位置: 首页 > news >正文

湘西网站建设公司搜索推广渠道有哪些

湘西网站建设公司,搜索推广渠道有哪些,土巴兔装修公司靠谱吗,网站制作报价表文章目录1.list 底层2. list的模拟实现1. list_node 类设计2. list类如何调用类型3 .push_back(正常实现)4. 迭代器的实现第一个模板参数Tconst迭代器第二个模板参数Ref第三个模板参数Ptr对list封装的理解5. insert6.push_back与 push_front(复用)7. erase8. pop_back与pop_fro…

文章目录

    • 1.list 底层
    • 2. list的模拟实现
      • 1. list_node 类设计
      • 2. list类如何调用类型
      • 3 .push_back(正常实现)
      • 4. 迭代器的实现
        • 第一个模板参数T
        • const迭代器
        • 第二个模板参数Ref
        • 第三个模板参数Ptr
        • 对list封装的理解
      • 5. insert
      • 6.push_back与 push_front(复用)
      • 7. erase
      • 8. pop_back与pop_front (复用)
      • 9. clear 清空数据
      • 10. 迭代器区间构造
      • 12. 拷贝构造
        • 传统写法
        • 现代写法
      • 13. 赋值
    • 3.完整代码

1.list 底层

list为任意位置插入删除的容器,底层为带头双向循环链表

begin() 代表第一个结点,end()代表最后一个结点的下一个

2. list的模拟实现

1. list_node 类设计

template<class T>struct list_node{list_node<T>* _next;list_node<T>* _prev;T _data;};

C++中,Listnode作为类名,而next和prev都是类指针,指针引用成员时使用->,而对象引用成员时使用 .
通过显示实例化,将两个类指针指定类型为T


2. list类如何调用类型

Listnode 代表类型
Listnode 代表类名 + 模板参数 才是类型
而_head 以及创建新节点前都需加上类型

3 .push_back(正常实现)

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

当我们想要创建一个节点时,需要调用node的构造函数
typedef list_node node ,node是由 list_node 类提供的


list_node(const T& x=T())//list类的构造函数:_next(nullptr), _prev(nullptr), _data(x){}

最好在构造函数处提供全缺省,对于内置类型int可以使用0,但对于自定义类型来说就不可以,所以为了满足泛型的要求,使用匿名对象调用默认构造函数

4. 迭代器的实现

若在数组上有一个int类型的指针,解引用是int类型的数据,再++可以加载下一个位置,因为物理空间是连续的


同样若在链表上,解引用类型为 node,再++不能到下一个节点,因为物理空间不连续
所以构造迭代器通过封装节点的指针来进行构造 (后面会讲)

第一个模板参数T

创建一个_list_iterator的类,来实现迭代器功能


template<class T>struct _list_iterator{typedef list_node<T> node;typedef _list_iterator<T> self;node* _node;_list_iterator(node* n):_node(n){}T& operator*()//解引用 {return _node->_data;}_list_iterator<T>& operator++()//返回迭代器{_node = _node->_next;//指向下一个节点return *this;}bool operator!=(const self&s){return _node != s._node;}};

在list类中,调用迭代器实现begin()和end()功能
typedef _list_iterator<T,T&,T*> iterator,
通过typedef 将_list_node类模板定义为iterator


iterator begin(){return iterator(_head->_next);//通过匿名对象访问第一个数据}iterator end(){return iterator(_head);//通过匿名对象访问最后一个数据的下一个}

在list类中实现begin()和end(),内部调用_list_node类的构造函数


在这里插入图片描述

const迭代器

在这里插入图片描述

假设第一个代表的是T * ,而第二个代表的 T * const,保护迭代器本身不可以被修改,而我们想要保护迭代器指向的内容不可被修改即 const T*


复制_list_iterator类中的内容,并将名字修改为const_list_iterator
只需修改*operator类型为cosnt T& ,说明解引用后的数据返回不能被修改


template<class T>struct _list_const_iterator{typedef list_node<T> node;typedef _list_const_iterator<T> self;node* _node;_list_const_iterator(node* n):_node(n){}const T& operator*()//解引用 {return _node->_data;}self& operator++()//前置++{_node = _node->_next;//指向下一个节点return *this;}self& operator++(int)//后置++{self ret = *this;_node = _node->_next;return ret;}self& operator--()//前置--{_node = _node->_prev;return *this;}self& operator--(int)//后置--{self ret = *this;_node = _node->_prev;return ret;}bool operator!=(const self& s)//!={return _node != s._node;}bool operator==(const self& s)//=={return _node == s._node;}};

在这里插入图片描述

第二个模板参数Ref

迭代器和const迭代器只有 *operator 的返回值不同,
只需在模板中添加一个参数即可使用一个迭代器实现迭代器和const 迭代器的功能

在这里插入图片描述


在这里插入图片描述

第三个模板参数Ptr

对于内置类型int使用解引用找到对应数据,而自定义类型需使用->寻找下一个节点


AA作为自定义类型,想要找到下一个节点需要使用->,在迭代器中 重载 - >

it->_a1,实际上是 it->->_a1,
it->返回值为AA* ,再通过这个指针使用->指向_a1
但是为了增强可读性,省略了一个->
it->_a1 实际上为 it.operator->()->._a1


在这里插入图片描述


在这里插入图片描述

对list封装的理解

在不考虑封装的情况下,两者等价


从物理空间上来看,it与pnode都是指向1的地址



pnode作为一个原生指针,解引用指针就会拿到这个地址,找到这个地址指向空间的内容
++pnode,找到下一个节点的地址,但是下一个节点不一定是要的节点
*it 识别成为自定义类型就会调用函数

5. insert

void insert(iterator pos,const T&x)//在pos位置前插入x{node* cur = pos._node;node* prev = cur->_prev;node* newnode = new node(x);prev->_next = newnode;newnode->_prev = prev;newnode->_next = cur;cur->_prev = newnode;}

6.push_back与 push_front(复用)

两者都可以通过复用 insert的方式实现

void push_back(const T&x)//尾插{/*node* tail = _head->_prev;node* newnode = new node(x);tail->_next = newnode;newnode->_prev = tail;newnode->_next = _head;_head->_prev = newnode;*/insert(end(), x);}void push_front(const T&x)//头插{insert(begin(), x);}

7. erase

void erase(iterator pos)//删除pos位置{//头节点不可以删除assert(pos != end());node* cur = pos._node;node* prev = cur->_prev;node* next = cur->_next;prev->_next = next;next->_prev = prev;delete cur;}

由于头节点不可以删除,所以使用assert断言的方式

8. pop_back与pop_front (复用)

                void pop_back()//尾删{erase(--end());}void pop_front()//头删{erase(begin());}

9. clear 清空数据

void clear()//清空数据//但是要注意不要把head清掉{iterator it = begin();while (it != end()){it=erase(it);//为了防止迭代器失效设置返回值//返回值为当前节点的下一个}}

迭代器失效是指迭代器所指向的节点失效 即节点被删除了
erase函数执行后,it所指向的节点被删除,因此it无效,在下一次使用it时,必须先给it赋值



为了防止迭代器失效所以使erase设置返回值,返回值为当前节点的下一个

10. 迭代器区间构造

void empty_init(){_head = new node;_head->_next = _head;_head->_prev = _head;}
template <class Iterator>list(Iterator first, Iterator last){empty_init();while (first != last){push_back(*first);++first;}}

想要尾插的前提时,需要有头节点的存在,所以设置一个函数对头节点初始化


12. 拷贝构造

传统写法

void empty_init(){_head = new node;_head->_next = _head;_head->_prev = _head;}
list(const list<T>& It)//拷贝构造  传统写法{empty_init();//初始化头节点for (auto e : It){push_back(e);}}

现代写法

void swap(list<T>& tmp){std::swap(_head, tmp._head);}list(const list<T>& It)//拷贝构造现代写法{empty_init();//将头节点初始化list<T> tmp(It.begin(), It.end());swap(tmp);}

通过调用std中的swap来达到交换的目的

13. 赋值

void swap(list<T>& tmp){std::swap(_head, tmp._head);}
list<T>& operator=(list<T> It){swap(It);return *this;}

参数不可以使用 list &,虽然可以达到赋值的目的,但是It的值也会发生改变


在这里插入图片描述


在这里插入图片描述

3.完整代码

#include<iostream>
#include<list>
#include<assert.h>
using namespace std;
namespace yzq
{template<class T>struct list_node{list_node<T>* _next;list_node<T>* _prev;T _data;list_node(const T& x=T())//构造函数:_next(nullptr), _prev(nullptr), _data(x){}};//迭代器template<class T,class Ref,class Ptr>struct _list_iterator{typedef list_node<T> node;typedef _list_iterator<T,Ref,Ptr> self;node* _node;_list_iterator(node* n):_node(n){}Ref operator*()//解引用 {return _node->_data;}Ptr operator->()//->{return &_node->_data;}self& operator++()//前置++{_node = _node->_next;//指向下一个节点return *this;}self& operator++(int)//后置++{self ret = *this;_node = _node->_next;return ret;}self& operator--()//前置--{_node = _node->_prev;return *this;}self& operator--(int)//后置--{self ret = *this;_node = _node->_prev;return ret;}bool operator!=(const self&s)//!={return _node != s._node;}bool operator==(const self& s)//=={return _node == s._node;}};//const迭代器//template<class T>//struct _list_const_iterator//{//	typedef list_node<T> node;//	typedef _list_const_iterator<T> self;//	node* _node;//	_list_const_iterator(node* n)//		:_node(n)//	{//	}//	const T& operator*()//解引用 //	{//		return _node->_data;//	}//	self& operator++()//前置++//	{//		_node = _node->_next;//指向下一个节点//		return *this;//	}//	self& operator++(int)//后置++//	{//		self ret = *this;//		_node = _node->_next;//		return ret;//	}//	self& operator--()//前置--//	{//		_node = _node->_prev;//		return *this;//	}//	self& operator--(int)//后置--//	{//		self ret = *this;//		_node = _node->_prev;//		return ret;//	}//	bool operator!=(const self& s)//!=//	{//		return _node != s._node;//	}//	bool operator==(const self& s)//==//	{//		return _node == s._node;//	}//};template <class T>class list{typedef list_node<T> node;public:typedef _list_iterator<T,T&,T*> iterator;typedef _list_iterator<T, const T&, const T*> const_iterator;//const迭代器//typedef _list_const_iterator<T> const_iterator;void empty_init(){_head = new node;_head->_next = _head;_head->_prev = _head;}list()//构造函数{empty_init();}template <class Iterator>list(Iterator first, Iterator last){empty_init();while (first != last){push_back(*first);++first;}}//list(const list<T>& It)//拷贝构造//{//	empty_init();//初始化头节点//	for (auto e : It)//	{//		push_back(e);//	}//}void swap(list<T>& tmp){std::swap(_head, tmp._head);}list(const list<T>& It)//拷贝构造现代写法{empty_init();//将头节点初始化list<T> tmp(It.begin(), It.end());swap(tmp);}list<T>& operator=(list<T> It)//赋值{swap(It);return *this;}~list()//析构函数{//将头节点也要释放掉clear();delete _head;_head = nullptr;}void clear()//清空数据//但是要注意不要把head清掉{iterator it = begin();while (it != end()){it=erase(it);//为了防止迭代器失效设置返回值//返回值为当前节点的下一个}}void push_back(const T&x)//尾插{/*node* tail = _head->_prev;node* newnode = new node(x);tail->_next = newnode;newnode->_prev = tail;newnode->_next = _head;_head->_prev = newnode;*/insert(end(), x);}void push_front(const T&x)//头插{insert(begin(), x);}void insert(iterator pos,const T&x)//在pos位置前插入x{node* cur = pos._node;node* prev = cur->_prev;node* newnode = new node(x);prev->_next = newnode;newnode->_prev = prev;newnode->_next = cur;cur->_prev = newnode;}iterator erase(iterator pos)//删除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 iterator(next);}void pop_back()//尾删{erase(--end());}void pop_front()//头删{erase(begin());}iterator begin(){return iterator(_head->_next);//通过匿名对象访问第一个数据}iterator end(){return iterator(_head);//通过匿名对象访问最后一个数据的下一个}const_iterator begin()const{return const_iterator(_head->_next);}const_iterator end()const{return const_iterator(_head);}private:node* _head;};/*void test(const list<int>&e){list<int>::const_iterator it = e.begin();while (it != e.end()){cout << *it << " ";++it;}cout << endl;}void test2(){const list<int> v;test(v);}*///void test1()//{//	list<int> v;//	v.push_back(1);//	v.push_back(2);//	v.push_back(3);//	v.push_back(4);//	list<int>::iterator it= v.begin();//	while (it != v.end())//	{//		cout << *it << " ";//		++it;//	}//	cout << endl;//}/*struct AA{int	_a1;int _a2;AA(int a1=0,int a2=0):_a1(a1),_a2(a2){}};*//*void test3(){list<AA>v;v.push_back(AA(1, 1));v.push_back(AA(2, 2));v.push_back(AA(3, 3));list<AA>::iterator it = v.begin();while (it != v.end()){cout << it->_a1 << " :"<<it->_a2<<" ";cout << endl;it++;}}*///void test4()//{//	list<int> v;//	v.push_back(1);//	v.push_back(2);//	v.push_back(3);//	v.push_back(4);// 1 2 3 4//	for (auto e : v)//	{//		cout << e << " ";//	}//	cout << endl;//	v.clear();//	v.push_back(4);//  4//	for (auto e : v)//	{//		cout << e << " ";//	}//}//void test4()//{//	list<int> v;//	v.push_back(1);//	v.push_back(2);//	v.push_back(3);//	v.push_back(4);// 1 2 3 4//	for (auto e : v)//	{//		cout << e << " ";//	}//	cout << endl;//	list<int> v2(v);//	for (auto e : v2)// 1 2 3 4//	{//		cout << e << " ";//	}//}void test4(){list<int> v;v.push_back(1);v.push_back(2);//v1 = 1 2list<int> v2;v2.push_back(5);v2.push_back(6);//v2=5 6v2 = v;for (auto e : v2)// v2=1 2 {cout << e << " ";}cout << endl;for (auto e : v)// v1=1 2{cout << e << " ";}}
}	int main()
{yzq::test4();return 0;
}
http://www.zhongyajixie.com/news/42067.html

相关文章:

  • 公司管理济南优化网站关键词
  • 外贸网站用什么空间福州搜索排名提升
  • 网站入口你明白我的意思吧windows优化大师收费
  • 做微信的微网站费用多少合适百度推广app
  • 游戏网站怎么制作廊坊seo网站管理
  • 怎么做传奇私服广告网站外链网站
  • 网站推广策略成功的案例搜索引擎优化的主要策略
  • 温州好的网站推广百度快照怎么打开
  • 做国际物流需要哪些网站做一个网站的步骤
  • 校园网站模板有免费做网站的吗
  • wordpress接入qq互联七台河网站seo
  • 网站设置访问权限谷歌seo排名工具
  • 网站文章没有被收录一站式网络推广服务
  • 网站群系统建设标准seo海外
  • 政府网站解决方案免费seo网站的工具
  • 专业的营销型网站建设公司长春seo代理
  • wordpress缓存插件对比seo网站推广方式
  • 做响应式网站设计做图怎么搞广州网络seo公司
  • 北京万网网站备案seo优化效果怎么样
  • 体育课程网站建设沈阳网站制作
  • 经营性商务网站建设需要备案吗seo页面内容优化
  • 那种漂亮的网站怎么做的软文是什么意思
  • 为什么原网站建设公司不愿意透露域名管理权限给客户网络营销与直播电商专业学什么
  • 唯一做魅惑的网站seo培训教程视频
  • 厦门广告公司网站建设北京网站维护公司
  • 争对银行排队做一网站2020年度关键词有哪些
  • 西安英文网站建设网络营销推广方案案例
  • emlog与wordpress区别优化网站哪个好
  • 北京网页网站设计制作武汉做seo公司
  • python做网站点登入没反映公众号开发网站公司