stl源码剖析 详细学习笔记 set map
//
// set map.cpp
// 笔记
//
// Created by fam on 15/3/23.
//
//
//---------------------------15/03/23----------------------------
//set
{
/*
set概述:
1:所有的元素都会被自动排序,
2:所有的元素只有"键"没有“值”
或者说他们的“值”就是“键”
3:不允许出现两个相同的键值
4:不能通过迭代器改变set的值,因为set的值就是键,
如果可以改变,我们要先删除键,平衡二叉树,再加改变后的键,再平衡
这么做严重破坏了set的组织,iterator也会变得无效,到底是指向之前的位置
还是指向改变后的位置等等。所以stl中不允许改变set的值。
5:set用RB_tree作为底层机制(废话,不然干嘛花大篇幅介绍RB_tree)
*/
//class
template<class Key,
class Compare = less<Key>,
class Alloc = alloc>
class set
{
public:
typedef Key key_type;
typedef Key value_type;
typedef Compare key_compare;
typedef Compare value_compare;
private:
//identity<value_type>
可以根据key值得到value值
typedef rb_tree<key_type, value_type,
identity<value_type>, key_compare, Alloc> rep_type;
rep_type t;
public:
//由于上面说的set不能改变值,所以指针和迭代器引用这些
全都用RB_tree中的const类型的来指定
typedef typename rep_type::const_pointer pointer;
typedef typename rep_type::const_pointer const_pointer;
typedef typename rep_type::const_reference reference;
typedef typename rep_type::const_reference const_reference;
typedef typename rep_type::const_iterator iterator;
typedef typename rep_type::const_iterator const_iterator;
typedef typename rep_type::const_reverse_iterator reverse_iterator;
typedef typename rep_type::const_reverse_iterator const_reverse_iterator;
typedef typename rep_type::size_type size_type;
typedef typename rep_type::difference_type difference_type;
set() : t(Compare()){}
explicit set(const Compare& comp) : t(comp){}
//inset_unique
是不允许相同值出现的插入
template<class InputIterator>
set(InputIterator first, InputIterator last)
: t(Compare()){ t.insert_unique(first, last);}
template<class InputIterator>
set(InputIterator first, InputIterator last,const Compare& comp)
: t(comp){t.insert_unique(first, last);}
set(const set<Key, Compare, Alloc>& x): t(x.t){}
set<Key, Compare, Alloc>&
operator=(const set<Key, Compare, Alloc>& x)
{
t = x.t;
return *this;
}
key_compare key_comp()
const { return t.key_comp();}
//set中的值就是键
所以调用key_comp()
value_compare value_comp()
const {return t.key_comp();}
iterator begin()
const {return t.begin();}
iterator end()
const {return t.end();}
reverse_iterator rbegin()
const {return t.rbegin();}
reverse_iterator rend()
const {return t.end();}
bool empty()
const { return t.empty();}
size_type size()
const { return t.size();}
size_type max_size()
const { return t.max_size();}
void swap(set<Key, Compare, Alloc>& x) { t.swap(x.t);}
//insert erase
typedef pair<iterator,
bool> pair_interator_bool;
pair<iterator,
bool> inset(const value_type& x)
{
pair<typename rep_type::iterator,
bool> p =t.insert_unique(x);
return pair<iterator,
bool>(p.first, p.second);
}
iterator insert(iterator position,
const value_type& x)
{
typedef typename rep_type::iterator rep_iterator;
return t.insert_unique((rep_iterator&)position, x);
}
template<class InputIterator>
void insert(InputIterator first, InputIterator last)
{
t.insert_unique(first, last);
}
void erase(iterator position)
{
typedef typename rep_type::iterator rep_iterator;
t.erase((rep_iterator&)position);
}
size_type erase(const key_type& x)
{
return t.erase(x);
}
void erase(iterator first, iterator last)
{
typedef typename rep_type::iterator rep_iterator;
t.erase((rep_iterator&)first, (rep_iterator&)last);
}
void clear() { t.clear();}
//
iterator find(const key_type& x)
const { return t.find(x); }
size_type count(const key_type& x)
const { return t.count(x); }
iterator lower_bound(const key_type& x)
const
{
return t.lower_bound(x);
}
iterator upper_bound(const key_type& x)
const
{
return t.upper_bound(x);
}
pair<iterator,iterator> equal_range(const key_type& x)
const
{
return t.equal_range(x);
}
friend bool
operator== __STL_NULL_TMPL_ARGS (const set&,
const set&);
friend bool
operator< __STL_NULL_TMPL_ARGS (const set&,
const set&);
};
template<class Key,
class Compare, class Alloc>
inline bool
operator==(const set<Key, Compare, Alloc>& x,
const set<Key, Compare, Alloc>& y)
{
return x.t == y.t;
}
template<class Key,
class Compare, class Alloc>
inline bool
operator<(const set<Key, Compare, Alloc>& x,
const set<Key, Compare, Alloc>& y)
{
return x.t < y.t;
}
//
总结
//没什么好总结的,这里只是不断调用底层的东西,没有技术可言
}
//map
{
/*
map概述:
和set不同的就是,多了一个值的概念,每一个键都可以存储一个实值
排序是根据key(键)来排序的。一般都是根据key来取其中的值。
和set一样的原理,我们不能改变键。和set不同的是,可以改变data(实值)
实值只是节点所存储的东西,当然可以改,改了不会影响排序
*/
//struct pair
template<class T1,
class T2>
struct pair
{
typedef T1 first_type;
typedef T2 second_type;
T1 first;
T2 second;
pair() : first(T1()), second(T2()){}
pair(const T1& a,const T2& b) : first(a), second(b){}
};
template<class Key,
class T, class Compare = less<Key>,
class Alloc = alloc>
class map
{
public:
typedef Key key_type;
typedef T data_type;
typedef T mapped_type;
typedef pair<const Key, T> value_type;
typedef Compare key_compare;
typedef Compare value_compare;
class value_compare
:
public binary_function<value_type, value_type,
bool>
{
friend class map<Key, T, Compare, Alloc>;
protected:
Compare comp;
value_compare(Compare c) : comp(c) {}
public:
bool operator()(const value_type& x,
const value_type& y)
const
{
return comp(x.first, y.first);
}
};
private:
typedef rb_tree<key_type, value_type,
select1st<value_type>, key_compare, Alloc> rep_type;
rep_type t;
public:
typedef typename rep_type::pointer pointer;
typedef typename rep_type::const_pointer const_pointer;
typedef typename rep_type::reference reference;
typedef typename rep_type::const_reference const_reference;
typedef typename rep_type::iterator iterator;
typedef typename rep_type::const_iterator const_iterator;
typedef typename rep_type::reverse_iterator reverse_iterator;
typedef typename rep_type::const_reverse_iterator const_reverse_iterator;
typedef typename rep_type::size_type size_type;
typedef typename rep_type::difference_type difference_type;
map() : t(Compare()){}
explicit map(const Compare& comp) : t(comp){}
//inset_unique
是不允许相同值出现的插入
template<class InputIterator>
map(InputIterator first, InputIterator last)
: t(Compare()){ t.insert_unique(first, last);}
template<class InputIterator>
map(InputIterator first, InputIterator last,const Compare& comp)
: t(comp){t.insert_unique(first, last);}
map(const set<Key, Compare, Alloc>& x): t(x.t){}
map<Key, Compare, Alloc>&
operator=(const map<Key, Compare, Alloc>& x)
{
t = x.t;
return *this;
}
key_compare key_comp()
const { return t.key_comp();}
value_compare value_comp()
const { return t.value_compare(t.key_comp());}
iterator begin()
const { return t.begin();}
iterator end()
const { return t.end();}
reverse_iterator rbegin()
const { return t.rbegin();}
reverse_iterator rend()
const { return t.end();}
bool empty()
const { return t.empty();}
size_type size()
const { return t.size();}
size_type max_size()
const { return t.max_size();}
void swap(set<Key, Compare, Alloc>& x) { t.swap(x.t);}
//map可以根据
键 来取
值, 如果不存在就插入一个新的
键值对
T&
operator[] (const key_type& k)
{
return (*((insert(value_type(k,T()))).first)).second;
}
//insert erase
pair<iterator,
bool> inset(const value_type& x)
{
pair<typename rep_type::iterator,
bool> p =t.insert_unique(x);
return pair<iterator,
bool>(p.first, p.second);
}
iterator insert(iterator position,
const value_type& x)
{
typedef typename rep_type::iterator rep_iterator;
return t.insert_unique((rep_iterator&)position, x);
}
template<class InputIterator>
void insert(InputIterator first, InputIterator last)
{
t.insert_unique(first, last);
}
void erase(iterator position)
{
typedef typename rep_type::iterator rep_iterator;
t.erase((rep_iterator&)position);
}
size_type erase(const key_type& x)
{
return t.erase(x);
}
void erase(iterator first, iterator last)
{
typedef typename rep_type::iterator rep_iterator;
t.erase((rep_iterator&)first, (rep_iterator&)last);
}
void clear() { t.clear();}
//
iterator find(const key_type& x)
const { return t.find(x); }
size_type count(const key_type& x)
const { return t.count(x); }
iterator lower_bound(const key_type& x)
const
{
return t.lower_bound(x);
}
iterator upper_bound(const key_type& x)
const
{
return t.upper_bound(x);
}
pair<iterator,iterator> equal_range(const key_type& x)
const
{
return t.equal_range(x);
}
friend bool
operator== __STL_NULL_TMPL_ARGS (const set&,
const set&);
friend bool
operator< __STL_NULL_TMPL_ARGS (const set&,
const set&);
};
template<class Key,
class Compare, class Alloc>
inline bool
operator==(const set<Key, Compare, Alloc>& x,
const set<Key, Compare, Alloc>& y)
{
return x.t == y.t;
}
template<class Key,
class Compare, class Alloc>
inline bool
operator<(const set<Key, Compare, Alloc>& x,
const set<Key, Compare, Alloc>& y)
{
return x.t < y.t;
}
/*
总结:
map和set不同的是有了data这个概念,并且可以更改这个data值了
set插入时插的就是key, map插入时插的是value(键值对)
插入时,函数会调用keyofvalue仿函数取得value的key
之后排序会根据key_compare(也就是模版参数中的Compare)来比较key的大小
最后都是用key来比较的,不同的是set存的值也是key,map存的值是data。
*/
}
//multiset 和multimap
/*
这两个容器和之前的基本相同,不同的就是把inset_unique改成inset_equel
具体的底层实现在RB_tree
中已经实现了,只要调用就行了
*/
stl源码剖析 详细学习笔记 set map的更多相关文章
- stl源码剖析 详细学习笔记 hashtable
//---------------------------15/03/24---------------------------- //hashtable { /* 概述: sgi采用的是开链法完成h ...
- stl源码剖析 详细学习笔记 RB_tree (1)
// // RB_tree_STL.cpp // 笔记 // // Created by fam on 15/3/21. // // #include "RB_tree_STL.h&q ...
- stl源码剖析 详细学习笔记heap
// // heap.cpp // 笔记 // // Created by fam on 15/3/15. // // //---------------------------15/03/15 ...
- stl源码剖析 详细学习笔记 空间配置器
//---------------------------15/04/05---------------------------- /* 空间配置器概述: 1:new操作包含两个阶段操作 1>调 ...
- stl源码剖析 详细学习笔记 算法(1)
//---------------------------15/03/27---------------------------- //算法 { /* 质变算法:会改变操作对象之值 所有的stl算法都 ...
- stl源码剖析 详细学习笔记 算法总览
//****************************基本算法***************************** /* stl算法总览,不在stl标准规格的sgi专属算法,都以 *加以标 ...
- stl源码剖析 详细学习笔记 RB_tree (2)
//---------------------------15/03/22---------------------------- //一直好奇KeyOfValue是什么,查了下就是一个和仿函数差不多 ...
- stl源码剖析 详细学习笔记priority_queue slist
// // priority_queue.cpp // 笔记 // // Created by fam on 15/3/16. // // //------------------------- ...
- stl源码剖析 详细学习笔记stack queue
// // stack.cpp // 笔记 // // Created by fam on 15/3/15. // // //---------------------------15/03/1 ...
随机推荐
- percona pt toolkit 总结
##=====================================================##pt-osc之工作流程:1.检查更改表是否有主键或唯一索引,是否有触发器2.检查修改表 ...
- Android 的提权(root)原理【转】
Android的内核就是Linux,所以Android获取root其实和Linux获取root权限是一回事儿. su还需要所有者(Owner)是root才能正确的给其他程序赋予root权限.linux ...
- Questions about UIUC and USC
Questions about UIUC and USC I am admitted to University of Illinois at Urbana-Champaign (UIUC) Prof ...
- VC Debug和Release区别
https://msdn.microsoft.com/en-us/library/xz7ttk5s.aspx Optimizing Your Code Visual Studio 2015 The ...
- C#程序如何捕捉未try/catch的异常——不弹“XXX已停止工作”报错框
诚意满满直接上代码: static void Main(string[] args) { //Main函数中增加此句 AppDomain.CurrentDomain.UnhandledExceptio ...
- Alpha 任务状态总览(持续更新)
Alpha 任务状态总览(持续更新) Part 0 · 简 要 目 录 Part 1 · 流 程 Part 2 · 总 任 务 量 安 排 Part 3 · 爬 虫 任 务 Part 4 · 接 口 ...
- zepto.js不支持scrollTop的解决办法
zepto.js不支持animate({ scrollTop: 100},1000); 可以在移动端使用原生window.scrollTop(x,y);简便
- An Introduction to Protocol Oriented Programming in Swift
swift面向协议编程的根本原因在于值类型的存在:面向对象必须要有引用类型的支持: Protocol Oriented approach was introduced to resolve some ...
- 最好用的jquery列表拖动排列(由项目提取)
版权声明:本文为博主原创文章,未经博主同意不得转载. https://blog.csdn.net/wuchengzeng/article/details/31766235 最好的jquery列表拖动排 ...
- MYSQL一次千万级连表查询优化(二) 作为一的讲解思路
这里摘自网上,仅供自己学习之用,再次鸣谢 概述: 交代一下背景,这算是一次项目经验吧,属于公司一个已上线平台的功能,这算是离职人员挖下的坑,随着数据越来越多,原本的SQL查询变得越来越慢,用户体验特别 ...