澳门皇冠金沙网站-澳门皇冠844网站

热门关键词: 澳门皇冠金沙网站,澳门皇冠844网站

解析命令行参数

unordered容器,unorderedmap

散列容器(hash container):
 日常比二叉树的积攒格局能够提供越来越高的走访功能.
#include <boost/unordered_set.hpp>
#include <boost/unordered_map.hpp>
using namespace boost;
散列集合简要介绍:
 unordered库提供七个散列集结类unordered_set和unordered_multiset,STLport也提供hash_set和hash_multiset,它们的接口,用法与stl里的科班提到容器set/multiset同样,只是里面使用散列表代替了二叉树实现,因而查找复杂度由数降为常数。
unordered_set/unordered_multiset简要注脚:
template<class Key, class Hash = boost::hash<Key>,
 class Pred = std::equal_to<Key>,
 class Alloc = std::allocator<Key>>
class unordered_set;

template<class Key, class Hash = boost::hash<Key>,
 class Pred = std::equal_to<Key>,
 class Alloc = std::allocator<Key>>
class unordered_multiset;
与std::set相比,unorder_set的模板扩展了一个计量散列值的沙盘类型参数,平时是boost::hash,最棒不要去改造它,别的相比谓词参数使用std::equal_to<>,实际不是set中的less<>,那是因为散列容器没有供给保险平稳。

散列群集的用法:
 注意散列容器的冬天性,不能够再散列容器上利用binary_search,lower_bound和upper_bound这样用于已序区间的算法,散列容器本人也不提供那样的积极分子函数。
事必躬亲:程序定义了一个模板函数hash_func(),用以操作hash_set/unordered_set,两个的表现是截然等同的,首先应用boost::assign开端化散列会集,以迭代器遍历输出,然后用size()显示容器大小,用clear()清空集结,再用insert()插入多少个要素,用find()查找成分,最终用erase()删除一个成分,那几个都以行业内部容器的标准操作。

#include <iostream>
#include <hash_set>
#include <boost/unordered_set.hpp>
#include <boost/assign/list_of.hpp>
using namespace boost;
using namespace std;
template<typename T>
void hash_func()
{
 using namespace boost::assign;
 T s = (list_of(1), 2, 3, 4, 5);   //开首化数据
 for (T::iterator p = s.begin(); p != s.end(); p) //使用迭代器遍历群集
 { cout<< *p<<" "; }
 cout<<endl;
 cout<<s.size()<<endl;
澳门皇冠844网站, s.clear();
 cout<<s.empty()<<endl;
 s.insert(8);
 s.insert(45);
 cout<<s.size()<<endl;
 cout<<*s.find(8)<<endl;
 s.erase(45);
}

int main()
{
 hash_func<unordered_set<int>>();
 system("pause");
 return 0;
}

散列映射简单介绍:
 unordered库提供多个散列映射类undorderd_map和unordered_multimap,它们的接口,用法与stl里的正儿八经提到容器map/multimap一样,只是中间使用散列表替代了二叉树,模板参数多了散列计算函数,相比较谓词使用equal_to<>。
 unordered_map和unordered_multimap的归纳表明:
template<class Key, class Mapped,
 class Hash = boost::hash<Key>,
 class Pred = std::equal_to<Key>,
 class Alloc = std::allocator<Key>>
class unordered_map;

template<class Key, class Mapped,
 class Hash = boost::hash<Key>,
 class Pred = std::equal_to<Key>,
 class Alloc = std::allocator<Key>>
class unordered_multimap;
散列映射的用法:
 unordered_map/unordered_multimap属于关联式容器,采纳std::pair保存key-value情势的多寡,能够精晓贰个提到数组,提供operator[]重载,用法与正式容器map一样.
 unordered_multimap允许有双重的key-value映射,因而不提供operator[].
示范:
#include <iostream>
#include <hash_map>
#include <boost/unordered_map.hpp>
#include <boost/assign/list_of.hpp>
#include <boost/typeof/typeof.hpp>
using namespace boost;
using namespace std;
using namespace stdext; 
int main()
{
 using namespace boost::assign;
 //使用assign初始化
 unordered_map<int, string> um = map_list_of(1, "one")(2, "two")(3, "three");
 um.insert(make_pair(10, "ten"));
 cout<<um[10]<<endl;
 um[11] = "eleven";
 um[15] = "fifteen";
 for (BOOST_AUTO(p, um.begin()); p != um.end(); p)
  cout<<p->first<<"-"<<p->second<<",";
 cout<<endl;
 um.erase(11);
 cout<<um.size()<<endl;
 hash_map<int, string> hm = map_list_of(4, "four")(5, "five")(6, "six");
 for (BOOST_AUTO(p, hmbegin()); p != hm.end(); p)
  cout<<p->first<<"-"<<p->second<<",";
 cout<<endl;
 system("pause");
 return 0;
}

天性相比:
示范:程序行使boost随机库random()向容器插入10000个1到100里边的卡尺头,然后试行count和find操作;
#include <iostream>
#include <typeinfo>
#include <hash_map>
#include <set>
#include <boost/unordered_set.hpp>
#include <boost/assign/list_of.hpp>
#include <boost/typeof/typeof.hpp>
#include <boost/random.hpp>
#include <boostProgress.hpp>
using namespace boost;
using namespace std;
using namespace stdext;

template<typename T>
void fill_set(T &c)
{
 variate_generator<mt19937, uniform_int<>> gen(mt19937(), uniform_int<>(0, 100));
 for (int i = 0; i < 一千0; i)//插入一万个整数
  c.insert(gen());
}
template<typename T>
void test_perform()
{
 T c;
 cout<<typeid(c).name()<<endl;
 {
  boost::progress_timer t;
  fill_set(c);
 }
 {
  boost::progress_timer t;
  c.count(10);
 }
 {
  boost::progress_timer t;
  c.find(20);
 }
}

int main()
{
 test_perform<multiset<int>>();
 //test_perform<hash_multiset<int>>();
 test_perform<unordered_multiset<int>>();
 system("pause");
 return 0;
}

高等议题:
里头数据结构:
 unordered库使用“桶(bucket)”来积存成分,散列值同样的要素被归入同七个桶中,当前散列容器的桶的数码能够用成员函数bucket_count()来获得,bucket_size()再次回到桶中的元素数量,举例:
unordered_set<int> us = (list_of(1), 2, 3, 4);
cout<< us.bucket_count()<<endl;
for(int i = 0; i < us.bucket_count(); i)//访问各种桶
{cout<<us.bucket_size(i)<<",";}
 当散列容器中有雅量数量时,桶中的成分数量也会大增,会形成访谈争论。为了加强散列容器的性质,unordered库会在插入成分时自动扩展桶的数目,客户没办法直接钦点桶的数码,但能够在构造函数或许rehash()函数内定最小的桶的数额。例如:
unordered_set<int> us(100);//使用九十多个桶存款和储蓄数据
us.rehash(200);//使用200个桶
 c 0x RT1草案还规定有三个函数max_load_factor(),它能够得到或设定散列容器的最大负荷因子,即桶霜月素的最大平平均数量据,平常最大负荷因子都以1,顾客不该去改造它,过大或过小都尚未意义。

支撑自定义类型:
 unordered库辅助c 内建类型和大好些个规范水库蓄水容量器,但不扶助顾客自定义的品种,因为它不可能测算自定义类型的散列值。
 若是要使unordered帮忙自定义类型,供给定制类模板的第3个和首个参数,也便是供散列函数和异常相比谓词。
 相等比较谓词,unordered库暗中同意使用std::equal_to,那是贰个标准库中的函数对象,它使用operator==,独有自定义类达成了那一个操作符就足以了,不必再非常编写三个函数对象,假诺须要用一个特其他拾贰分决断准绳,那么能够附加写函数对象,传递给unordered容器。
 散列函数则是应当要促成的,这也是为啥它被放在模板参数列表前面包车型客车来由,咱们供给采纳boost.hash库来测算自定义类型的散列值,组轻巧的使用方法是编写叁个hash_value()函数,创造贰个hash函数对象,然后选取它的operator()重临散列值。
上边的代码定义了一个类demo_class,它达成了operator==和散列函数,能够被unordered所包容:
#include <iostream>
#include <typeinfo>
#include <hash_map>
#include <set>
#include <boost/unordered_set.hpp>
#include <boost/assign/list_of.hpp>
#include <boost/typeof/typeof.hpp>
#include <boost/random.hpp>
#include <boost/Progress.hpp>
#include <boost/functional/hash.hpp>
using namespace boost;
using namespace std;
using namespace stdext;
using namespace boost::assign;
struct demo_class
{
 int a;
 friend bool operator==(const demo_class& l, const demo_class& r)
 {  return l.a == r.a; }
};
size_t hash_value(demo_class & s)
{ return boost::hash<int>()(s.a);}

int main()
{
 unordered_set<demo_class> us;
 demo_class a1;
 a1.a =100;
 cout<<hash_value(a1)<<endl;
 demo_class a2;
 a2.a =100;
 cout<<hash_value(a2)<<endl;

 system("pause");
 return 0;
}
与TR1的差异:
 boost.unordered基本上依附c 0x规范草案来贯彻,但它有个小的”扩大“,扩大了相比操作符operator==和operator !=;注意:那八个操作符不属于c 0x标准,如若前天前后相继要切换来新专门的学问恐怕会遇上不可用移植的标题。

散列容器(hash container): 平时比二叉树的置放方式可以提供更加高的拜望功能. #include boost/unordered_set.hpp #include boost/u...

1.散列容器(hash container)

   散列容器平日比二叉树的蕴藏方式可以提供更加高的拜访功能.

1 #include <boost/unordered_set.hpp>
2 #include <boost/unordered_map.hpp>
3 using namespace boost;

一、命令行深入分析

2.散列集合简单介绍

  unordered库提供五个散列群集类unordered_set和unordered_multiset,STLport也提供hash_set和hash_multiset,它们的接口,用法与stl里的专门的职业提到容器set/multiset同样,只是内部采取散列表代替了二叉树完成,由此查找复杂度由数降为常数。

  unordered_set/unordered_multiset简要评释:

1 template<class Key, class Hash = boost::hash<Key>,
2  class Pred = std::equal_to<Key>,
3  class Alloc = std::allocator<Key>>
4 class unordered_set;
5 
6 template<class Key, class Hash = boost::hash<Key>,
7  class Pred = std::equal_to<Key>,
8  class Alloc = std::allocator<Key>>
9 class unordered_multiset;

  与std::set相比,unorder_set的沙盘扩充了八个企图散列值的模版类型参数,经常是boost::hash,最佳不要去退换它,另外相比较谓词参数使用std::equal_to<>,并非set中的less<>,那是因为散列容器没有需求保持有序。

tprogram_options深入分析命令行参数示例代码:

3.散列集结的用法

  注意散列容器的严节性,无法再散列容器上运用binary_search,lower_bound和upper_bound这样用于已序区间的算法,散列容器本身也不提供这么的分子函数。
  示范:程序定义了一个模板函数hash_func(),用以操作hash_set/unordered_set,两个的变现是一心平等的,首先应用boost::assign开头化散列集结,以迭代器遍历输出,然后用size()展现容器大小,用clear()清空集结,再用insert()插入多个成分,用find()查找成分,最终用erase()删除二个因素,这几个都以明媒正娶容器的正经操作。

 1 #include <iostream>
 2 #include <hash_set>
 3 #include <boost/unordered_set.hpp>
 4 #include <boost/assign/list_of.hpp>
 5 using namespace boost;
 6 using namespace std;
 7 template<typename T>
 8 void hash_func()
 9 {
10    using namespace boost::assign;
11 
12    T s = (list_of(1), 2, 3, 4, 5);   //初始化数据
13    for (T::iterator p = s.begin(); p != s.end();   p) //使用迭代器遍历集合
14    { cout<< *p<<" "; }
15 
16    cout<<endl;
17    cout<<s.size()<<endl;
18 
19    s.clear();
20    cout<<s.empty()<<endl;
21 
22    s.insert(8);
23    s.insert(45);
24 
25    cout<<s.size()<<endl;
26    cout<<*s.find(8)<<endl;
27 
28    s.erase(45);
29 }
30 
31 int main()
32 {
33    hash_func<unordered_set<int>>();
34 
35    system("pause");
36    return 0;
37 }

 

4.散列映射简要介绍

  unordered库提供三个散列映射类undorderd_map和unordered_multimap,它们的接口,用法与stl里的正规提到容器map/multimap一样,只是当中使用散列表替代了二叉树,模板参数多了散列总结函数,相比较谓词使用equal_to<>。
  unordered_map和unordered_multimap的大概表明:

 1 template<class Key, class Mapped,
 2  class Hash = boost::hash<Key>,
 3  class Pred = std::equal_to<Key>,
 4  class Alloc = std::allocator<Key>>
 5 class unordered_map;
 6 
 7 template<class Key, class Mapped,
 8  class Hash = boost::hash<Key>,
 9  class Pred = std::equal_to<Key>,
10  class Alloc = std::allocator<Key>>
11 class unordered_multimap;

[cpp] view plaincopy澳门皇冠844网站 1澳门皇冠844网站 2

5.散列映射的用法

  unordered_map/unordered_multimap属于关联式容器,采纳std::pair保存key-value情势的数据,能够知晓叁个涉及数组,提供operator[]重载,用法与正统容器map同样.
  unordered_multimap允许有双重的key-value映射,因而不提供operator[].
  示范:

 1 #include <iostream>
 2 #include <hash_map>
 3 #include <boost/unordered_map.hpp>
 4 #include <boost/assign/list_of.hpp>
 5 #include <boost/typeof/typeof.hpp>
 6 using namespace boost;
 7 using namespace std;
 8 using namespace stdext; 
 9 int main()
10 {
11    using namespace boost::assign;
12 
13    //使用assign初始化
14    unordered_map<int, string> um = map_list_of(1, "one")(2, "two")(3, "three");
15 
16    um.insert(make_pair(10, "ten"));
17    cout<<um[10]<<endl;
18 
19    um[11] = "eleven";
20    um[15] = "fifteen";
21    for (BOOST_AUTO(p, um.begin()); p != um.end();   p)
22       cout<<p->first<<"-"<<p->second<<",";
23    cout<<endl;
24 
25    um.erase(11);
26    cout<<um.size()<<endl;
27 
28    hash_map<int, string> hm = map_list_of(4, "four")(5, "five")(6, "six");
29    for (BOOST_AUTO(p, hmbegin()); p != hm.end();   p)
30       cout<<p->first<<"-"<<p->second<<",";
31    cout<<endl;
32 
33    system("pause");
34    return 0;
35 }

  品质比较:

  示范:程序采纳boost随机库random()向容器插入一千0个1到100之间的整数,然后推行count和find操作;

 1 #include <iostream>
 2 #include <typeinfo>
 3 #include <hash_map>
 4 #include <set>
 5 #include <boost/unordered_set.hpp>
 6 #include <boost/assign/list_of.hpp>
 7 #include <boost/typeof/typeof.hpp>
 8 #include <boost/random.hpp>
 9 #include <boostProgress.hpp>
10 using namespace boost;
11 using namespace std;
12 using namespace stdext;
13 
14 template<typename T>
15 void fill_set(T &c)
16 {
17    variate_generator<mt19937, uniform_int<>> gen(mt19937(), uniform_int<>(0, 100));
18    for (int i = 0; i < 10000;   i)//插入一万个整数
19     c.insert(gen());
20 }
21 template<typename T>
22 void test_perform()
23 {
24    T c;
25    cout<<typeid(c).name()<<endl;
26    {
27       boost::progress_timer t;
28       fill_set(c);
29    }
30    {
31       boost::progress_timer t;
32       c.count(10);
33    }
34    {
35       boost::progress_timer t;
36       c.find(20);
37    }
38 }
39 
40 int main()
41 {
42    test_perform<multiset<int>>();
43    //test_perform<hash_multiset<int>>();
44    test_perform<unordered_multiset<int>>();
45    system("pause");
46    return 0;
47 }

  高等议题:

  内部数据结构:
   unordered库使用“桶(bucket)”来存款和储蓄成分,散列值同样的因素被放入同一个桶中,当前散列容器的桶的数目能够用成员函数bucket_count()来获得,bucket_size()再次来到桶中的成分数量,举例:

1 unordered_set<int> us = (list_of(1), 2, 3, 4);
2 cout<< us.bucket_count()<<endl;
3 for(int i = 0; i < us.bucket_count();   i)//访问每个桶
4 {cout<<us.bucket_size(i)<<",";}

  当散列容器中有多量数量时,桶中的成分数量也会扩张,会招致访谈争辨。为了进步散列容器的习性,unordered库会在插入成分时自动扩大桶的多寡,客户不能够直接钦定桶的数据,但能够在构造函数也许rehash()函数钦定最小的桶的数量。比方:

1 unordered_set<int> us(100);//使用100个桶存储数据
2 us.rehash(200);//使用200个桶

  c 0x RT1草案还分明有一个函数max_load_factor(),它能够获得或设定散列容器的最大负荷因子,即桶中元素的最大平平均数量据,平日最大负荷因子都以1,客户不应当去改造它,过大或过小都未有意义。

  帮助自定义类型:
     1)unordered库帮忙c 内建档期的顺序和大多数规范水库蓄水体量器,但不帮助客商自定义的类别,因为它不能够测算自定义类型的散列值。
     2)假若要使unordered支持自定义类型,供给定制类模板的第三个和第3个参数,也正是供散列函数和相当比较谓词。
     3)相等相比谓词,unordered库暗中同意使用std::equal_to,那是三个标准库中的函数对象,它选取operator==,仅有自定义类达成了那些操作符就足以了,不必再极其编写四个函数对象,倘诺要求用贰个特意的十二分判别法规,那么能够附加写函数对象,传递给unordered容器。
     4)散列函数则是必须要落到实处的,那也是为什么它被放在模板参数列表前边的原原本本的经过,大家须要运用boost.hash库来计算自定义类型的散列值,组轻巧的使用办法是编写多少个hash_value()函数,创造一个hash函数对象,然后使用它的operator()再次回到散列值。
  下边包车型客车代码定义了三个类demo_class,它完结了operator==和散列函数,能够被unordered所包容:

 1 #include <iostream>
 2 #include <typeinfo>
 3 #include <hash_map>
 4 #include <set>
 5 #include <boost/unordered_set.hpp>
 6 #include <boost/assign/list_of.hpp>
 7 #include <boost/typeof/typeof.hpp>
 8 #include <boost/random.hpp>
 9 #include <boost/Progress.hpp>
10 #include <boost/functional/hash.hpp>
11 using namespace boost;
12 using namespace std;
13 using namespace stdext;
14 using namespace boost::assign;
15 struct demo_class
16 {
17    int a;
18    friend bool operator==(const demo_class& l, const demo_class& r)
19    {  return l.a == r.a; }
20 };
21 
22 size_t hash_value(demo_class & s)
23 { return boost::hash<int>()(s.a);}
24 
25 int main()
26 {
27    unordered_set<demo_class> us;
28 
29    demo_class a1;
30    a1.a =100;
31    cout<<hash_value(a1)<<endl;
32 
33    demo_class a2;
34    a2.a =100;
35    cout<<hash_value(a2)<<endl;
36 
37    system("pause");
38    return 0;
39 }

  与TR1的差异:

   boost.unordered基本上依靠c 0x规范草案来兑现,但它有个小的”扩大“,扩张了比较操作符operator==和operator !=;注意:那八个操作符不属于c 0x标准,如若今后程序要切换来新专门的学业大概会遇见不可用移植的难点。

 

  1. #include <iostream>  
  2. using namespace std;  
  3.   
  4. #include <boost/program_options.hpp>  
  5. namespace po = boost::program_options;  
  6.   
  7. int main(int argc, char*argv[])  
  8. {  
  9.     //int level;  
  10.     po::options_description desc("Allowed options");  
  11.     desc.add_options()  
  12.         ("help", "produce help message")  
  13.         //("help,h", "produce help message")  
  14.         ("compression", po::value<int>(), "set compression level");  
  15.         //("compression", po::value<int>(&level)->default_value(1), "set compression level");  
  16.   
  17.     po::variables_map vm;  
  18.     po::store(po::parse_command_line(argc, argv, desc), vm);  
  19.     po::notify(vm);  
  20.   
  21.     if(vm.count("help"))  
  22.     {  
  23.         cout<<desc<<endl;  
  24.         return 1;  
  25.     }  
  26.   
  27.     if(vm.count("compression"))  
  28.     {  
  29.         cout<<"compression level was set to "<<vm["compression"].as<int>()<<"."<<endl;  
  30.         //cout<<"compression level: "<<level<<endl;  
  31.     }  
  32.     else  
  33.     {  
  34.         cout<<"compression level was not set."<<endl;  
  35.     }  
  36.   
  37.     return 0;  
  38. }  

 

运转结果:

 

输入参数:--help

本文由澳门皇冠金沙网站发布于编辑程序,转载请注明出处:解析命令行参数