第一，concept可以想象是一组type requirement。如果说type T 是Concept C的一个model，则T必须满足C的所有条件。
      第二，concept可以想成一组type的集合。例如concept input iterator可以涵盖char*、int*、等类型。如果类型T是concept C的model，意思是说T隶属于C所代表的那个type集合。由于集合中的所有类型都满足那一系列条件，所以这个定义与前一个定义相通。
      第三，concept可以想成是一组合法程序。那么像input iterator   这样的concept，其重要在于find以及其他许多算法都会用到它。这个concept自身包含iterator及那些算法共有的性质。

======================================================================================
基本的concepts：

      所谓正规型别（regular type），是同时兼具Assignable、Default Constructible和Equality Comparable的一个model。自定义的型别都应该是正规型别。

Assignalbe：如果我们能够复制某个型别的object，并且可以将数值赋予该型别的变量身上，这个型别便
                     是   Assignable。注意，Assignable不需要有operator==的重载。

Default Constructible：如果某个型别具有一个default constructor，也就是说我们不需要指定任何初值，就可以构
                                    造该型别的object，那么这个型别便属于Default Constructible。

Equality Comparable：  如果我们可以使用operator==对某个型别做相等比较，而且operator==是表示等价关系的
                                      话该型别便是Equality Comparable。


可序性(Ordering)：
LessThan Comparable：如果某个型别能够以某种次序排列，它便隶属于LessThan Comparable。它必须能够以
                                       operator< 作为比较动作，而operator<必须定义出某种一致的可序性。>= 、 <=、>均可
                                       由 operator<定义：x<=y 可以表示为!(y<x)。。。
Strict Weakly Comparable：如果x<y 和 y<x 皆不为真，则x于y便是等价的。这种关系比LessThan Comparable多了
                                             一种等价性传递的性质，但它不同于total ordering，例如：
                                                                  struct name
                                                                {   string first_name;
                                                                     string last_name;
                                                                     }
                                                比较字段限制为first_name，及时两个name
                                                 类型的实例相等，即== 返回true，但两者
                                                  也不是同一的(identical)                                                                     





                  

class line_iterator
{
 istream* in;
 string line;
 bool is_valid;
 void read()
 {
  if (*in)
   getline(*in, line);
  is_valid = (*in) ? true : false;
 }

public:
 typedef input_iterator_tag iterator_category;
 typedef string value_type;
 typedef ptrdiff_t difference_type;
 typedef const string* pointer;
 typedef const string& reference;

public:
 line_iterator() : in(&cin), is_valid(false){}
 
 line_iterator(istream& s) : in(&s){ read(); }
 
 reference operator*() const { return line; }

 pointer operator->() const {return &line; }
 
 line_iterator operator++()
 {
  read();
  return *this;
 }

 line_iterator operator++(int)
 {
  line_iterator tmp = *this;
  read();
  return tmp;
 }

 bool operator==(const line_iterator& i)const
 {
  return (in == i.in && is_valid == i.is_valid) ||
   (is_valid == false && i.is_valid == false);
 }

 bool operator != (const line_iterator& i) const
 {
  return !(*this == i);
 }
};


//测试
int _tmain(int argc, _TCHAR* argv[])
{
 line_iterator iter(cin);
 line_iterator end_of_file;
 vector<string> V(iter, end_of_file);

 sort(V.begin(), V.end());
 copy(V.begin(), V.end(), ostream_iterator<string>(cout, "\n"));
 return 0;
}

 

template<typename T>
struct trivial_container
{
 typedef T     value_type;
 typedef value_type*   pointer;
 typedef const value_type* const_pointer;
 typedef value_type&   reference;
 typedef const value_type& const_reference;

 typedef value_type*   iterator;
 typedef const value_type* const_iterator;
 typedef ptrdiff_t   difference_type;
 typedef size_t    size_type;

 const_iterator begin() const{return 0;}
 const_iterator end() const{return 0;}

 iterator begin(){return 0;}
 iterator end(){return 0;}

 size_type size()const{return 0;}
 bool empty() const{return true;}
 size_type max_size()const{return 0;}

 void swap(trivial_container&){}
};