这篇笔记主要是其定义和基本的使用：

iostream迭代器的构造函数：

1. istream_iterator<T> in(strm);

创建从输入流strm读取T类型对象的istream_iterator对象

2. istream_iterator<T> in;

istream_iterator对象的超出末端迭代器。

3. ostream_iterator<T> out(strm);

创建将T类型的对象写到输出流strm的ostream_iterator对象

4. ostream_iterator<T> out(strm,delim);

创建将T类型的对象写到输出流strm的ostream_iterator对象，在写入过程中使用delim作为元素的分隔符。delim是以空字符结束的字符数组。

先看istream_iterator一个例子：

#include <iostream>

#include <vector>

#include <iterator>

using namespace std;

int main()

{

istream_iterator<int> cin_it(cin);//read ints from cin

istream_iterator<int> end_of_stream;//end iterator value(eof)

vector<int> vec(cin_it, end_of_stream);

//also should be written like this:

//vector<int> vec;

//while (cin_it != end_of_stream)

//vec.push_back(*cin_it++);

vector<int>::iterator it=vec.begin();

while (it!=vec.end()) {

cout << " " << *it++;

}

cout << endl;

return 0;

}

该程序读取键盘输入，写到vec，直到遇到非法输入。像下面这样：

1 2 3 4af

1 2 3 4

程序循环从cin读取int型数据，并将读入的内容保存在vec。每次循环都会检查cin_it是否为eof。其中eof迭代器定义为空的istream_iterator对象，用作结束迭代器。绑在流上的迭代器在遇到文件或某个错误时，将等于结束迭代器的值。

如程序注释里的，这部分可以用

vector<int> vec(cin_it, end_of_stream)//construct vec from an iterator range

来代替。

这里，用一对标记元素范围的迭代器构造vec对象。这些迭代器是istream_iterator对象，这就意味着这段范围的元素是通过读取所关联的流来获得的。这个构造函数的效果是读cin，直到到达文件结束或输入的不是int型数值为止。读取的元素用于构造vec对象。

在创建istream_iterator时，可直接将它绑定到一个流上。另一种方法是创建时不提供实参，则该迭代器指向超出末端的位置。ostream_iterator不提供超出末端迭代器。

ostream_iterator对象必须与特定的流绑在一起。在创建ostream_iterator时，可提供第二个（可选的）实参，指定将元素写入输出流时使用的分隔符。分隔符必须是C风格字符串。因为它是C风格字符串，所以必须以空字符结束；否则，其行为将是未定义的。

看个ostream_iterator的例子：

#include <iostream>

#include <iterator>

#include <string>

using namespace std;

int main()

{

ostream_iterator<string> out_iter(cout, ":test\n");//write one string per line to the standard output

istream_iterator<string> in_iter(cin),eof;//read strings from standard input and the end iterator

while (in_iter!=eof) {

//write value of in_iter to standard output

//and then increment the iterator to get the next value from cin

*out_iter = *in_iter;//write to standard output here

++out_iter;

++in_iter;

}

return 0;

}

这个程序读cin，并将每个读入的值依次写到cout不同的行。

首先，定一个ostream_stream对象，用于将string类型的数据写到cout中，每个string对象后跟一个”test”和换行符。定义两个istream_iterator对象，用于从cin中读取string对象。while循环类似于前一个例子。但是这一次不是将读取的数据存储在vector对象，而是将读取的数据付给out_iter,从而输出到cout上。

*out_iter = *in_iter;这一句执行时，会向console打印。

输出类似于这个样子：

123

123:test

abc

abc:test

xyz

xyz:test

参考：

1. 《C++Primer》

函数声明：

template<class InputInterator, class Function>

Function for_each(InputIterator first, InputIterator last, Function f);

函数解释：

对其输入范围[first,last)的每一个元素应用函数（或函数对象）f。如果f有返回值，就忽略该返回值。迭代器是输入迭代器，所以f不能写元素。

函数行为类似于这样：

template<class InputIterator, class Function>

Function for_each(InputIterator first, InputIterator last, Function f)

{

while (first!=last)

f(*first++);

return f;

}

关于f的定义：

Unary function taking an element in the range as argument. This can either be a pointer to a function or an object whose class overloads operator().
Its return value, if any, is ignored.

例子：

//for_each example

#include <iostream>

#include <algorithm>

#include <vector>

using namespace std;

void myfunction(int i)

{

cout << "myfunction: " << i << endl;

}

struct myclass

{

void operator()(int i) { cout << "myclass: " << i << endl; }

}myobject;

int main()

{

vector<int> myvector;

myvector.push_back(10);

myvector.push_back(20);

myvector.push_back(30);

cout << "myvector contains: " << endl;

for_each(myvector.begin(),myvector.end(),myfunction);

cout << "myvector contains: " << endl;

for_each(myvector.begin(),myvector.end(),myobject);

return 0;

}

输出：

myvector contains:

myfunction: 10

myfunction: 20

myfunction: 30

myvector contains:

myclass: 10

myclass: 20

myclass: 30

二：方法

1.构造函数，map有6个构造函数。但是我们通常用map<type1,type2> m;这种方法来构造一个map实例。

2.数据插入，map通常用下面的三种方式插入数据。

1),用insert方法插入pair数据。

  1: void main( VOID )
  2: {
  3: map<string,int> m;
  4: m.insert(pair<string,int>("sa",67));
  5: m.insert(make_pair<string,int>("sd",565));//用make_pair方法(函数)产生pair对象。
  6: map<string,int>::iterator it = m.begin();
  7: while(it!=m.end())
  8: {
  9: cout<<it->first<<" "<<it->second<<endl;
 10: it++;
 11: }
 12: }

2,)用insert函数插入value_type数据。

  1: void main( VOID )
  2: {
  3: map<string,int> m;
  4: m.insert(map<string,int>::value_type("sd",5));
  5: map<string,int>::iterator it = m.begin();
  6: while(it!=m.end())
  7: {
  8: cout<<it->first<<" "<<it->second<<endl;
  9: it++;
 10: }
 11: }

其实这个方法和上面的本质上是一样的。因为valud_type 就是pair类型的，只是换个方法而已，可以通过 cout<<typeid(map<string,int>::value_type).name()来获得 value_type的类型，得到类型为

struct std::pair<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > const ,int>说明是个struct pair类型的。

3,)通过重载[]来插入数据。

  1: void main( VOID )
  2: {
  3: map<string,int> m;
  4: cout<<typeid(map<string,int>::value_type).name()<<endl;
  5: m["ds"] = 4;
  6: m["ds"] = 10;
  7: map<string,int>::iterator it = m.begin();
  8: while(it!=m.end())
  9: {
 10: cout<<it->first<<" "<<it->second<<endl;
 11: it++;
 12: }
 13: }

这种法式是通过重载[]来实现的，但是需要注意的是，这种法式和前两种有本质的区别，看下面的代码

m.insert(pair<string,int>("ds",5));

m.insert(pair<string,int>("ds",15));

当关键字相同的时候，不会改变他的值，也就是说在调用insert函数的时候，会检查，这个关键字是否存在了，如果存在，那么就不做任何操作。否则插入新的数据。

m["ds"] = 4;

m["ds"] = 10;

这种方式插入数据是不会做检查的，会直接在那个点上写上关键字和值，也就是说。ds项的值将是10.

3，数据遍历。

stl里的容器的遍历都是通过迭代器来遍历的。即便是用数组的方式，也是通过迭代器。数据遍历也有三种法式，1，向前迭代器，2，用反向迭代器，3，数组，第一种方式前面也就有说明。下面讲第二第三种，

反向迭代器的方式。

这样是以相反的法式输出的。

数组方式

void main( VOID )
{
map<string,int> m;
m["ds"] = 4;
m["as"] = 10;
m.insert(pair<string,int>("cs",5));
m["bs"] = 123;
map<string,int>::iterator it = m.begin();
for(int i=1;i<=m.size();i++)
{
cout<<m[it->first]<<endl;//这里是用重载[]来得到value的。
it++;
}
}

4 .数据的查找（包括判定这个关键字是否在map中出现）

在这里我们将体会，map在数据插入时保证有序的好处。

要判定一个数据（关键字）是否在map中出现的方法比较多，这里标题虽然是数据的查找，在这里将穿插着大量的map基本用法。

这里给出三(2)种数据查找方法

第一种：用count函数来判定关键字是否出现，其缺点是无法定位数据出现位置,由于map的特性，一对一的映射关系，就决定了count函数的返回值只有两个，要么是0，要么是1，出现的情况，当然是返回1了

第二种：用find函数来定位数据出现位置，它返回的一个迭代器，当数据出现时，它返回数据所在位置的迭代器，如果map中没有要查找的数据，它返回的迭代器等于end函数返回的迭代器

#include <iostream>
#include <fstream>
#include <string>
#include <map>
using namespace std;
void main()
{
//定义map 对象
map<string,int> word;
//定义指针
map<string,int>::iterator it;
//向word 插入元素 ("a",9)
word.insert (map<string,int>::value_type("a",9));
//查找 键是"a"的元素，返回指向元素的指针。
it=word.find ("a");
//如果元素不存在，指针指向word.end().
if(it!=word.end ())
cout<<it->second<<endl; //输出元素的值
//查找 键是"a"的元素，
int result=word.count ("a");
//如果键存在返回1，否则返回0
if(result)
cout<<word["a"]<<endl; //输出元素的值
cout<<endl;
}

5.数据清空，或判空，

清空数据用clear函数，判断数据是否是空用empty函数。

6.数据删除。

数据删除用erase函数，这个函数有3个重载函数，用的时候，可随机而用。注意用这个函数后，相关的迭代器将会失效。

三：pair是stl里(目前我知道的)定义的一个struct，在msdn上查到如下的信息。

template<class Type1, class Type2>

struct pair

{

typedef Type1 first_type;

typedef Type2 second_type

Type1 first;

Type2 second;

pair( );

pair(

const Type1& __Val1,

const Type2& __Val2

);

template<class Other1, class Other2>

pair(

const pair<Other1, Other2>& _Right

);

与之相关的是make_pair函数。是个模板函数。

template<class Type1, class Type2> pair<Type1, Type2> make_pair( Type1 _Val1, Type2 _Val2 );

四：关于map的迭代器，

对数据的插入，遍历，查找等操作，迭代器将不会失效，但是删除操作会失效。这与vector等序列式容器是不一样的。

五：效率

因为内部RB-TREE所以大多数的操作的时间复杂度都是O(logN)，空间分析，在这些节点不保存数据的情况下就需要，左右孩子指针，指向父节点的指针，说明红黑的枚举值。

六：map的key的比较：

value_compare value_comp ( ) const;

其返回值是一个比较类的对象，这个类是map::value_compare，并且是map的一个内部类。

返回的这个对象可以用来通过比较两个元素的value来判决它们对应的key在map的位置谁在前面谁在后面。

下面是一个简单的例子，看一下就会更明白了:

#include <iostream>
#include <map>
using namespace std;
int main ()
{
map<char,int> mymap;
map<char,int>::iterator it;
pair<char,int> highest;
mymap['x']=1001;
mymap['y']=2002;
mymap['z']=3003;
cout << "mymap contains:\n";
highest=*mymap.rbegin(); // last element
it=mymap.begin();
do {
cout << (*it).first << " => " << (*it).second << endl;
} while ( mymap.value_comp()(*it++, highest) );
return 0;
}

输出结果:

mymap contains:

x => 1001

y => 2002

z => 3003

解释一下，上面语句while里面的mymap.value_comp()(*it++, highest)在这样的条件下会返回true:

*it++对应的key在map中排在highest对应的key的前面时。

01 #include <algorithm>
02 #include <stdio.h>
03
04 int main()
05 {
06     size_t indexs = -1;
07     size_t ps = 100;
08     int index = -1;
09     int p = 100;
10     printf("%d\n",std::min(p,index));
11     printf("%d\n",std::min(ps,indexs));
12     return 0;
13 }

其实是很简单的题目，不过要对size_t类型有一个了解才行。

关于size_t的来源：

数据类型"socklen_t"和int应该具有相同的长度。否则就会破坏 BSD套接字层的填充.POSIX开始的时候用的是size_t, Linus Torvalds(他希望有更多的人,但显然不是很多) 努力向他们解释使用size_t是完全错误的,因为在64位结构中 size_t和int的长度是不一样的,而这个参数(也就是accept函数的第三参数)的长度必须和int一致,因为这是BSD套接字接口标准.最终POSIX的那帮家伙找到了解决的办法,那就是创造了一个新的类型"socklen_t".Linux Torvalds说这是由于他们发现了自己的错误但又不好意思向大家伙儿承认,所以另外创造了一个新的数据类型 。

size_t在C语言中就有了，size_t和ssize_t是ANSI C提供的标准头文件里定义的一个"数据类型"，其实并不是新的数据类型，不是关键字，是通过typedef从已有数据类型定义而来。

ANSI C总共提供了24个头文件。

<cstddef>里这么定义了

#include <stddef.h>

using ::size_t

using::ptrdiff_t

在/usr/lib/gcc/i486-linux-gnu/4.4/include下面

<stddef.h>里面我找到了这么几句：

#ifndef __SIZE_TYPE__

#define __SIZE__TYPE__ long unsigned int

#endif

#if !(defined(__GUNU__) && defined (size_t))

typedef __SIZE_TYPE__ size_t;

#ifdef __BEOS

typedef long ssize_t

…

没太看明白，不过从网上找到了不错的一个解释：

size_t是为了方便系统之间的移植而定义的。

在32位系统上定义为 unsigned int

在64位系统上定义为 unsigned long

更准确的说法是在32位系统上是32位无符号整型

在64位系统上是64位无符号整型

size_t一般用来表示一种计数，比如有多少东西被拷贝等。

sizeof操作符的结果类型是size_t,

该类型保证能容纳实现所建立的最大对象的字节大小。

它的意义大致是"适于计量内存中可容纳的数据项目的个数的无符号整数类型"。

所以，它在数组下标和内存管理函数之类的地方广泛使用

ssize_t:

这个数据类型用来表示可以被执行读写操作的数据块的大小。它和size_t类似，但必须是signed。

再来看下size_t与size_type的区别：

我觉得有一句话总结的很好：

size_t是全局的，而size_type是跟容器相关的。

找了下相关的文件：

/c++/4.3/bits/stl_tree.h,stl_list.h,stl_deque.h等直接这么定义了

typedef size_t size_type

stl_mutiset.h则这么定义的：

typedef typename _Rep_type::size_type size_type;

那么size_type到底是一种什么样的类型呢？

string类类型和许多其他库类型都定义了一些配套类型（companion type）。通过这些配套类型，库类型的使用就能与机器无关。size_type就是这些配套类型中的一种。

size_type被定义为与unsigned型（unsigned int, unsigned long）具有相同的含义，而且可以保证足够大能够存储任意string对象的长度。为而来使用由string类型定义的size_type类型。程序员必须加上作用于操作符来说明所使用的size_type类型是由string类定义的。

我们为什么不适用int变量来保存string的size呢？

使用int变量的问题是：有些机器上的int变量的表示范围太小，甚至无法存储实际并不长的string对象。如在有16位int型的机器上，int类型变量最大只能表示32767个字符的string对象。而能容纳一个文件内容的string对象轻易就能超过这个数字，因此，为了避免溢出，保存一个string对象的size的最安全的方法就是使用标准库类型string：：size_type().

一点注意：虽然是在学习标准库string的时候巧遇了size_type类型，但是，其实vector库也可以定义size_type类型，在vector库中还有一个difference_type类型，该类型用来存储任何两个迭代器对象间的距离，所以是signed类型的。

啰啰嗦嗦说了这么多，其实关于这个问题文章里红字标注的部分就足够了。其他的看下加深印象即可，最开始的程序结果输出为：

-1 100。

#include <iostream>
#include <deque>
#include <algorithm>

using namespace std;

int main()
{
 deque<double> values;
 ostream_iterator<double> output(cout," ");

 values.push_front(2.2);//只适用于list和deque,而不适于vector
 values.push_front(2.3);
 values.push_back(1.1);

 cout << "values contains: ";
 for ( int i=0;i<values.size();i++)
  cout << values[i] << ' ';

 values.pop_front();
 cout << "\nAfter pop_front values contains: ";
 copy(values.begin(),values.end(),output);

 values[1]=5.4;
 cout << "\nAfter values[1]=5.4 values contains: ";
 copy(values.begin(),values.end(),output);
 cout << endl;
 return 0;
}