From: Dariusz Murakowski <murakdar@mit.edu>
Date: Wed, 20 Aug 2014 20:26:56 +0000 (-0400)
Subject: STL compliant sorted vector class (std::map replacement) from CodeProject.
X-Git-Url: http://src.murakowski.org/?a=commitdiff_plain;h=6d15f6a14df7cc31db311e4c55c9cda2f8037701;p=VirEvoDyn.git

STL compliant sorted vector class (std::map replacement) from CodeProject.

Source:
http://www.codeproject.com/Articles/3217/An-STL-compliant-sorted-vector?display=Print

Introduction:

sorted_vector adapts a std::vector to the interface required by
std::set/std::multiset, thereby providing set/multiset and vector
functionality (random access) in one container.

Tests show that sorted_vector's element retrieval (find) speed
outperforms that of std::set/std::multiset by a factor of 2 (on most
machines). On the downward side is the poor performance of
sorted_vector's insert member function, because it inserts an element
somewhere in the middle of the sorted vector in order to preserve the
sort order. By using sorted_vector's low level interface one can solve
this performance bottleneck by inserting a bunch of objects using a
series of push_back's followed by a call to the member function sort,
which restores the sort order.

sorted_vector should be preferred over std::set/std::multiset if many
small elements must be stored. Most STL implementations use a variant of
a balanced tree to implement set and multiset, which imposes a per
element storage overhead of 3 pointers. The most important reason to use
a std::set/std::multiset instead of sorted_vector is the need to keep
iterators into a set/multiset while inserting more elements into the
set. These iterators remain valid in the case of a set/multiset, but are
invalidated in the case of a sorted_vector container.
---

diff --git a/main.cpp b/main.cpp
new file mode 100644
index 0000000..6fb6acc
--- /dev/null
+++ b/main.cpp
@@ -0,0 +1,387 @@
+
+#pragma warning(disable:4786)
+
+#include <set>
+#include "sorted_vector.h"
+#include <iostream>
+#include "assert.h"
+#include <time.h>
+#include <iomanip>
+
+struct STest{
+    std::string s;
+    int         id;
+};
+
+STest MakeSTest()
+{
+    static int id= 0;
+    int nLen= rand()%10;
+    char* letters[]={"0","1"};
+    STest stest;
+            
+    for(int i=0;i<nLen;i++){
+        stest.s+= letters[rand()%2];
+    }
+    stest.id= ++id;
+    return stest;
+}
+
+bool operator<(const STest& t0,const STest& t1)
+{
+    int nCmp;
+    return (nCmp=t0.s.compare(t1.s))<0||nCmp==0 && t0.id<t1.id;
+}
+
+
+class SimpTimer{
+public:
+    SimpTimer(const char* msg):m_msg(msg),m_start(clock()){}
+    ~SimpTimer()
+    {
+        m_stop = clock();
+        std::cout   <<  "CPU usage ("   << std::setw(35) <<  m_msg.c_str()    <<  ") = " 
+                    << (double)(m_stop - m_start)/ CLOCKS_PER_SEC
+                    <<  " seconds"   <<  std::endl;
+    }
+private:
+    time_t m_start, m_stop;
+    std::string     m_msg;
+};
+
+
+template<class It,class Pred>
+bool is_unique(It beg,It beyond,Pred pred)
+{
+    return std::adjacent_find(beg,beyond,std::not2(pred))==beyond;
+}
+template<class FwIt,class Pred>
+FwIt unsorted_find(FwIt beg,FwIt beyond,Pred pred)
+{
+    for(FwIt prev    ;(prev=beg)!=beyond && ++beg!=beyond;){
+        if( pred(*beg,*prev) ){
+            return prev;
+        }
+    }
+    return beyond;
+}
+template<class T>
+void TestSet(std::vector<T>& v)
+{
+    std::set<T> std_set;
+    {SimpTimer t("build std::set");
+        for(unsigned i=0;i<v.size();i++){
+            std_set.insert(v[i]);
+        }
+    }
+    {SimpTimer t("find in std::set");
+        for(unsigned i=0;i<v.size();i++){
+            std::set<T>::iterator it= std_set.find(v[i]);
+            std::set<T>::size_type nCount= std_set.count(v[i]);
+            assert(     nCount==0 && it==std_set.end()
+                    ||  nCount!=0 && it!=std_set.end());
+        }
+    }
+}
+template<class T>
+void TestSortedVector_AsSet(std::vector<T>& v)
+{   
+    codeproject::sorted_vector<T,true> svec;
+    {SimpTimer t("build sortedvec_set (naiv)");
+        for(unsigned i=0;i<v.size();i++){
+            svec.insert(v[i]);
+        }
+    }
+    assert(is_unique(svec.begin(),svec.end(),svec.key_comp()));
+    codeproject::sorted_vector<T,true> svec1;
+    {SimpTimer t("build sortedvec_set (opt.)");
+        codeproject::sorted_vector<T,true>::Cont& vec= svec1.get_container();
+        for(unsigned i=0;i<v.size();i++){
+            vec.push_back(v[i]);
+            
+        }
+        svec1.sort();
+    }
+    assert(svec==svec1);
+    assert(is_unique(svec1.begin(),svec1.end(),svec1.key_comp()));
+
+    {SimpTimer t("find in sortedvec_set");
+        for(unsigned i=0;i<v.size();i++){
+            codeproject::sorted_vector<T,true>::iterator it= svec1.find(v[i]);
+            codeproject::sorted_vector<T,true>::size_type nCount= svec1.count(v[i]);
+            assert(     nCount==0 && it==svec1.end()
+                    ||  nCount!=0 && it!=svec1.end());
+        }
+    }
+    for(unsigned i=0;i<v.size();i++){svec1.erase(v[i]);}
+    assert(svec1.empty());
+}
+template<class T>
+void TestMultiSet(std::vector<T>& v)
+{
+    std::multiset<T> svec;
+
+    {SimpTimer t("build multiset");
+        for(unsigned i=0;i<v.size();i++){
+            svec.insert(v[i]);
+        }
+    }
+    assert(unsorted_find(svec.begin(),svec.end(),svec.key_comp())==svec.end());
+    {SimpTimer t("find in multiset");
+        for(unsigned i=0;i<v.size();i++){
+            std::multiset<T>::iterator it= svec.find(v[i]);
+            std::multiset<T>::size_type nCount= svec.count(v[i]);
+            assert(     nCount==0 && it==svec.end()
+                    ||  nCount!=0 && it!=svec.end());
+        }
+    }
+}
+
+template<class T>
+void TestSortedVector_AsMultiSet(std::vector<T>& v)
+{
+    codeproject::sorted_vector<T> svec;
+    {SimpTimer t("build sortedvec_multiset (naiv)");
+        for(unsigned i=0;i<v.size();i++){
+            svec.insert(v[i]);
+        }
+    }
+    codeproject::sorted_vector<T> svec1;
+    {SimpTimer t("build sortedvec_multiset (opt.)");
+    codeproject::sorted_vector<T>::Cont& vec= svec1.get_container();
+        for(unsigned i=0;i<v.size();i++){
+            vec.push_back(v[i]);
+            
+        }
+        svec1.stable_sort();
+    }
+    assert(svec==svec1);
+    assert(unsorted_find(svec.begin(),svec.end(),svec.key_comp())==svec.end());
+    {SimpTimer t("find in sortedvec_multiset");
+        for(unsigned i=0;i<v.size();i++){
+            int n= rand();
+            codeproject::sorted_vector<T>::iterator it= svec1.find(v[i]);
+            codeproject::sorted_vector<T>::size_type nCount= svec1.count(v[i]);
+            assert(     nCount==0 && it==svec1.end()
+                    ||  nCount!=0 && it!=svec1.end());
+        }
+    }
+/*test various functions*/
+    const codeproject::sorted_vector<T> svec2(svec);
+    assert(svec==svec2);
+    for(unsigned i=0;i<v.size();i++){assert(svec2.find(v[i])!=svec2.end());}
+    codeproject::sorted_vector<T> svec3(v.begin(),v.end());
+    assert(svec3==svec2);
+    codeproject::sorted_vector<T> svec4(v.begin(),v.begin()+(v.end()-v.begin())/2);
+    svec4= svec3;
+    assert(svec4==svec3);
+    while(svec4.size()>0){
+        svec4.pop_back();
+    }
+}
+
+
+
+
+template<class T>
+void ExecTests(std::vector<T>& v)
+{
+    std::cout   <<  "std::set versus 'sorted_vector as set'"   <<  std::endl; 
+    TestSet(v);
+    TestSortedVector_AsSet(v);
+    std::cout    <<  "std::multiset versus 'sorted_vector as multiset'" <<  std::endl;
+    TestMultiSet(v);
+    TestSortedVector_AsMultiSet(v);
+}
+
+template<class T,class Pred>
+void TestSetOperations(const std::vector<T>& v0,
+                       const std::vector<T>& v1,
+                       const std::vector<T>& v2,
+                       Pred pred)
+{
+//A) compute the result of the set-operation: (v0-v1)+v2 - intersect(v1,v2)
+    codeproject::sorted_vector<T,true,Pred> svec(v0.begin(),v0.end(),pred);
+    codeproject::sorted_vector<T,true,Pred> svec_v1(pred); svec_v1= v1;
+    codeproject::sorted_vector<T,true,Pred> svec_v2(pred); svec_v2= v2;
+    unsigned i,j;
+    for(i=0;i<v1.size();i++){svec.erase(v1[i]);}
+    for(j=0;j<v2.size();j++){svec.insert(v2[j]);}
+    unsigned m;
+    for(m=0;m<svec_v1.size();m++){
+        if( svec_v2.find(svec_v1[m])!=svec_v2.end() ){
+            svec.erase(svec_v1[m]);
+        }
+    }
+//B) compute the result of the set-operation (v0+v2)-v1
+    codeproject::sorted_vector<T,true,Pred> svec1(v0.begin(),v0.end(),pred);
+    for(unsigned k=0;k<v2.size();k++){svec1.insert(v2[k]);}
+    for(unsigned l=0;l<v1.size();l++){svec1.erase(v1[l]);}
+    codeproject::sorted_vector<T,true,Pred>::size_type nSize= svec.size();
+    codeproject::sorted_vector<T,true,Pred>::size_type nSize1= svec1.size();
+//test whether results are the same
+    assert(svec==svec1);
+}
+
+
+codeproject::sorted_vector<int,true> 
+BuildIntersection(std::vector<int>& v0,std::vector<int>& v1)
+{
+    codeproject::sorted_vector<int,true> svec(v0.begin(),v0.end());
+    codeproject::sorted_vector<int,true> svecIntersection;
+    for(unsigned  i=0;i<v1.size();i++){
+        if( svec.find(v1[i])!=svec.end() ){
+            svecIntersection.insert(v1[i]);
+        }
+    }
+    return svecIntersection;
+}
+codeproject::sorted_vector<int,true> 
+BuildIntersection1(std::vector<int>& v0,std::vector<int>& v1)
+{
+    codeproject::sorted_vector<int,true> svec(v0.begin(),v0.end());
+    codeproject::sorted_vector<int,true> svecIntersection;
+    codeproject::sorted_vector<int,true>::Cont& vInterSect= 
+                            svecIntersection.get_container();
+    for(unsigned i=0;i<v1.size();i++){
+        if( svec.find(v1[i])!=svec.end() ){
+            vInterSect.push_back(v1[i]);
+        }
+    }
+    svecIntersection.sort();
+    return svecIntersection;
+}
+
+
+struct ltstr
+{
+  bool operator()(const char* s1, const char* s2) const
+  {
+    return strcmp(s1, s2) < 0;
+  }
+};
+
+int SGITest()
+{
+  using namespace std;
+  using namespace codeproject;
+  const int N = 6;
+  const char* a[N] = {"isomer", "ephemeral", "prosaic", 
+                      "nugatory", "artichoke", "serif"};
+  const char* b[N] = {"flat", "this", "artichoke",
+                      "frigate", "prosaic", "isomer"};
+
+  sorted_vector<const char*,true,ltstr> A(a, a + N);
+  sorted_vector<const char*,true,ltstr> B(b, b + N);
+  sorted_vector<const char*,true,ltstr> C;
+
+  cout << "Set A: ";
+  copy(A.begin(), A.end(), ostream_iterator<const char*>(cout, " "));
+  cout << endl;
+  cout << "Set B: ";
+  copy(B.begin(), B.end(), ostream_iterator<const char*>(cout, " "));   
+  cout << endl;
+
+  cout << "Union: ";
+  set_union(A.begin(), A.end(), B.begin(), B.end(),
+            ostream_iterator<const char*>(cout, " "),
+            ltstr());   
+  cout << endl;
+  return 0;
+}
+
+void TestAllSet()
+{
+    using namespace std;
+	using namespace codeproject;
+    typedef sorted_vector<const char*,true,ltstr> StrSet;
+    StrSet months;
+    months.insert("jan");
+    months.insert("feb");
+    months.insert("mar");
+    months.insert("apr");
+    months.insert("may");
+    months.insert("jun");
+    months.insert("jul");
+    months.insert("aug");
+    months.insert("sep");
+    months.insert("oct");
+    months.insert("nov");
+    months.insert("dec");
+    StrSet::iterator it= months.find("jul");
+    assert(strcmp(*it,"jul")==0);
+    cout    <<  "previous of jul (in alphabetical order) is " << (it[-1]) <<  endl;
+    cout    <<  "next of jul (in alphabetical order) is " << (it[1])  <<  endl;
+
+    cout << "months in alphabetical order: "    <<  endl;
+    copy(months.begin(),months.end(),ostream_iterator<const char*>(cout," ")); 
+    cout << endl	<<	"months in reverse alphabetical order: "   <<  endl;
+    copy(months.rbegin(),months.rend(),ostream_iterator<const char*>(cout," "));
+    /*test count*/
+    {
+        for(StrSet::iterator it= months.begin();it!=months.end();++it){
+            assert(months.count(*it)==1);
+        }
+    }
+    /*test copy construction and comparison operators*/
+    StrSet monthsCopy(months);
+    assert(     months==monthsCopy 
+            &&  months<=monthsCopy && months>=monthsCopy
+            &&  !(months<monthsCopy) && !(months>monthsCopy));
+
+    std::pair<StrSet::iterator,StrSet::iterator> pairMismatch=
+                    mismatch(months.begin(),months.end(),monthsCopy.begin());
+    assert(pairMismatch.first==months.end() && pairMismatch.second==monthsCopy.end());
+
+    /*test insertion of already present element*/
+    copy(months.begin(),months.end(),inserter(monthsCopy,monthsCopy.begin()));
+    assert(months.size()==monthsCopy.size());
+
+    /*test insert member functions*/
+    months.insert(monthsCopy.begin(),monthsCopy.end());
+    assert(months==monthsCopy);
+    StrSet months1(months.begin(),months.begin()+3);
+    months1.insert(months.begin()+1,months.end());
+    assert(months1==months);
+    months1.insert("aug");
+    months1.insert("xxx");
+	months1.insert(months1.find("xxx"),"yyy");
+    months1.insert("zzz");
+    assert(months1>months && months1.size()==months.size()+3);
+    /*test erase member functions*/
+    months1.erase(months1.find("xxx"),months1.end());
+    assert(months1.size()==months.size());
+
+    /*test lower_bound,upper_bound,equal_range*/
+    assert( strcmp(*months.lower_bound("jul"),"jul")==0);
+   
+
+    cout << endl;
+}
+
+
+int main()
+{
+//timed tests
+    std::vector<int> v;
+    int i;
+    for(i=0;i<50000;i++){v.push_back(rand());}
+    std::cout   <<  "--------------Tests with element type int-------------"   <<  std::endl;
+    ExecTests(v);
+ 
+    std::vector<STest> vt;
+    for(i=0;i<50000;i++){vt.push_back(MakeSTest());}
+     std::cout   <<  "-Tests with element type 'STest' (string,int)--------"   <<  std::endl;
+    ExecTests(v);
+
+//set operations-test
+    std::vector<int> v1,v2;
+    for(i=0;i<10000;i++){v1.push_back(rand());}
+    for(i=0;i<10000;i++){v2.push_back(rand());}
+    TestSetOperations(v,v1,v2,std::greater<int>());
+
+    assert(BuildIntersection(v1,v2)==BuildIntersection1(v1,v2));
+    SGITest();
+	TestAllSet();
+    return 0;
+}
\ No newline at end of file
diff --git a/sorted_vector.dsp b/sorted_vector.dsp
new file mode 100644
index 0000000..fabd10c
--- /dev/null
+++ b/sorted_vector.dsp
@@ -0,0 +1,104 @@
+# Microsoft Developer Studio Project File - Name="sorted_vector" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=sorted_vector - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "sorted_vector.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "sorted_vector.mak" CFG="sorted_vector - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "sorted_vector - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "sorted_vector - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "sorted_vector - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD BASE RSC /l 0x807 /d "NDEBUG"
+# ADD RSC /l 0x807 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib  kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib  kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+
+!ELSEIF  "$(CFG)" == "sorted_vector - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ  /c
+# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ  /c
+# ADD BASE RSC /l 0x807 /d "_DEBUG"
+# ADD RSC /l 0x807 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib  kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib  kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+
+!ENDIF 
+
+# Begin Target
+
+# Name "sorted_vector - Win32 Release"
+# Name "sorted_vector - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=.\main.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=.\sorted_vector.h
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project
diff --git a/sorted_vector.h b/sorted_vector.h
new file mode 100644
index 0000000..b02c0dc
--- /dev/null
+++ b/sorted_vector.h
@@ -0,0 +1,301 @@
+/* STL-conforming "sorted vector" container
+ *
+ * (C) 2002 Martin Holzherr (holzherr@infobrain.com). All rights reserved.
+ *
+ * Permission is granted to use, distribute and modify this code provided that:
+ *   · this copyright notice appears,
+ *   · 
+ * The author welcomes any suggestions on the code or reportings of actual
+ * use of the code. Please send your comments to holzherr@infobrain.com.
+ *
+ * The author makes NO WARRANTY or representation, either express or implied,
+ * with respect to this code, its quality, accuracy, merchantability, or
+ * fitness for a particular purpose.  This software is provided "AS IS", and
+ * you, its user, assume the entire risk as to its quality and accuracy.
+ *
+ * Created:			November 19th, 2002
+ * Last modified:	November 27th, 2002 
+						(changed namespace from std to codeproject;
+						uses template member functions for MSCVER>=1300)
+								
+ */
+
+#ifndef SORTED_VECTOR_
+#define SORTED_VECTOR_
+#define VERSION_SORTED_VECTOR_ 0x00010010
+
+
+#include <algorithm>
+#include <vector>
+#include <utility>
+#include <functional>
+
+#pragma pack(push,8)
+#pragma warning(push,3)
+
+
+namespace codeproject{
+		// TEMPLATE CLASS sorted_vector
+
+	template<class K, bool bNoDuplicates= false,class Pr = std::less<K>, class A = std::allocator<K> >
+	class sorted_vector {
+public:
+	typedef sorted_vector<K,bNoDuplicates,Pr,A> Myt_;
+    typedef std::vector<K,A>		Cont;
+	typedef Cont::allocator_type	allocator_type;
+	typedef Cont::size_type			size_type;
+	typedef Cont::difference_type	difference_type;
+	typedef Cont::reference			reference;
+	typedef Cont::const_reference	const_reference;
+	typedef Cont::value_type		value_type;
+    typedef K						key_type;
+	typedef Cont::iterator			iterator;
+	typedef Cont::const_iterator	const_iterator;
+    typedef Pr						key_compare;
+    typedef Pr						value_compare;
+
+	typedef Cont::const_reverse_iterator
+									const_reverse_iterator;
+	typedef Cont::reverse_iterator	reverse_iterator;
+
+    typedef std::pair<iterator, iterator> Pairii_;
+	typedef std::pair<const_iterator, const_iterator> Paircc_;
+    typedef std::pair<iterator, bool> Pairib_;
+	explicit sorted_vector(const Pr& pred = Pr(),const A& al = A())
+		:key_compare_(pred),vec_(al){}
+#if (_MSC_VER >= 1300)
+	template<class It>
+	sorted_vector(It first, It beyond, 
+					const Pr& pred = Pr(),const A& al = A())
+		:key_compare_(pred),vec_(first,beyond,al)
+        {stable_sort();}
+#else
+    sorted_vector(const_iterator first, const_iterator beyond, 
+					const Pr& pred = Pr(),const A& al = A())
+        :key_compare_(pred),vec_(first,beyond,al)
+        {stable_sort();}
+#endif
+	sorted_vector(const Myt_& x)
+		: vec_(x.vec_),key_compare_(x.key_compare_)
+        {}
+    ~sorted_vector()                {}
+    Myt_& operator=(const Myt_& x) {vec_.operator=(x.vec_);
+                                     key_compare_= x.key_compare_;
+                                     return *this;}
+    Myt_& operator=(const Cont& x){vec_.operator=(x);
+                                    sort();return *this;}
+		
+	void				reserve(size_type n)	{vec_.reserve(n);}
+	iterator			begin()					{return vec_.begin(); }
+	const_iterator		begin() const			{return vec_.begin(); }
+    iterator			end()					{return vec_.end();}
+    const_iterator		end() const				{return vec_.end();}
+    reverse_iterator	rbegin()				{return vec_.rbegin();}
+    const_reverse_iterator rbegin() const   
+												{return vec_.rbegin();}
+
+    reverse_iterator rend()						{return vec_.rend();}
+    const_reverse_iterator rend() const     
+												{return vec_.rend();}
+
+
+    size_type size() const						{return vec_.size();}
+    size_type max_size() const					{return vec_.max_size();}
+    bool empty() const							{return vec_.empty();}
+    A get_allocator() const						{return vec_.get_allocator();}
+    const_reference at(size_type p) const		{return vec_.at(p);}
+    reference at(size_type p)					{return vec_.at(p);}
+	const_reference operator[](size_type p) const
+												{return vec_.operator[](p);}
+		
+	reference operator[](size_type p)			{return vec_.operator[](p);}
+    reference front()							{return vec_.front();}
+	const_reference front() const				{return vec_.front();}
+    reference back()							{return vec_.back();}
+    const_reference back() const				{return vec_.back();}
+    void pop_back()								{vec_.pop_back();}
+
+    void assign(const_iterator first, const_iterator beyond)					
+												{vec_.assign(first,beyond);}
+	void assign(size_type n, const K& x = K())
+												{vec_.assign(n,x);}
+/*insert members*/
+   Pairib_ insert(const value_type& x)
+		{
+            if(bNoDuplicates){
+                iterator p= lower_bound(x);
+                if(p==end()||key_compare_(x,*p)){
+                    return Pairib_(InsertImpl_(p,x),true);
+                }else{
+                    return Pairib_(p,false);
+                }
+            }else{
+                iterator p= upper_bound(x);
+                return Pairib_(InsertImpl_(p,x),true);
+            }
+        }
+   iterator insert(iterator it, const value_type& x)//it is the hint
+        {
+           if(it!=end() ){
+               if(bNoDuplicates){
+                   if(key_compare_(*it,x)){
+                       if((it+1)==end()||KeyCompare_Gt_(*(it+1),x)){//use hint
+                            return InsertImpl_(it+1,x);
+                       }else if(KeyCompare_Geq_(*(it+1),x)){
+                           return end();
+                       }
+                    }
+               }else{
+                   if(	KeyCompare_Leq_(*it,x)
+					   &&((it+1)==end()||KeyCompare_Geq_(*(it+1),x))){
+                       return InsertImpl_(it+1,x);
+                   }
+               }
+           }
+           return insert(x).first;
+        }
+#if (_MSC_VER >= 1300)
+  template<class It>
+	void insert(It first, It beyond)
+    {
+        size_type n= std::distance(first,beyond);
+        reserve(size()+n);
+        for( ;first!=beyond;++first){
+            insert(*first);
+        }
+    }
+#else
+   void insert(const_iterator first, const_iterator beyond)
+        {
+            size_type n= std::distance(first,beyond);
+            reserve(size()+n);
+            for( ;first!=beyond;++first){
+                insert(*first);
+            }
+        }
+#endif
+    iterator erase(iterator p)          {return vec_.erase(p);}
+	iterator erase(iterator first, iterator beyond)
+                                        {return vec_.erase(first,beyond);}
+    size_type erase(const K& key)     
+        {
+            Pairii_ begEnd= equal_range(key);
+            size_type n= std::distance(begEnd.first,begEnd.second);
+            erase(begEnd.first,begEnd.second);
+            return n;
+        }
+    void clear()                        {return vec_.clear();}
+		
+    bool Eq_(const Myt_& x) const      
+		{return (size() == x.size()
+		&& std::equal(begin(), end(), x.begin())); }
+	bool Lt_(const Myt_& x) const
+        {return (std::lexicographical_compare(begin(), end(),
+										x.begin(), x.end()));}
+	void swap(Myt_& x)
+        {vec_.swap(x.vec_);std::swap(key_compare_,x.key_compare_);}
+        
+	friend void swap(Myt_& x, Myt_& Y_)
+		{x.swap(Y_); }
+
+	key_compare key_comp() const			{return key_compare_; }
+    value_compare value_comp() const		{return (key_comp()); }
+	iterator find(const K& k)
+		{	iterator p = lower_bound(k);
+			return (p==end()||key_compare_(k, *p))? end():p;
+		}
+	const_iterator find(const K& k) const
+		{const_iterator p = lower_bound(k);
+        return (p==end()||key_compare_(k,*p))?end():p;}
+	size_type count(const K& k) const
+		{Paircc_ Ans_ = equal_range(k);
+        size_type n = std::distance(Ans_.first, Ans_.second);
+        return (n); }
+	iterator lower_bound(const K& k)
+        {return std::lower_bound(begin(), end(), k, key_compare_); }
+	const_iterator lower_bound(const K& k) const
+        {return std::lower_bound(begin(), end(), k, key_compare_); }
+	iterator upper_bound(const K& k)
+		{return std::upper_bound(begin(), end(), k, key_compare_); }
+	const_iterator upper_bound(const K& k) const
+		{return std::upper_bound(begin(), end(), k, key_compare_); }
+	Pairii_ equal_range(const K& k)
+        {return std::equal_range(begin(), end(), k, key_compare_); }
+	Paircc_ equal_range(const K& k) const
+		{return std::equal_range(begin(), end(), k, key_compare_); }
+
+/*functions for use with direct std::vector-access*/
+    Cont& get_container()
+        {return vec_;}
+    void sort()//restore sorted order after low level access 
+        {   std::sort(vec_.begin(),vec_.end(),key_compare_);
+            if( bNoDuplicates ){
+                vec_.erase(Unique_(),vec_.end());
+            }
+        }
+    void stable_sort()//restore sorted order after low level access 
+        {   std::stable_sort(vec_.begin(),vec_.end(),key_compare_);
+            if( bNoDuplicates ){
+                erase(Unique_(),end());
+            }
+        }   
+protected:
+    iterator Unique_()
+        {   iterator front_= vec_.begin(),out_= vec_.end(),end_=vec_.end();
+            bool bCopy_= false;
+            for(iterator prev_; (prev_=front_)!=end_ && ++front_!=end_; ){
+                if( key_compare_(*prev_,*front_)){
+                    if(bCopy_){
+                        *out_= *front_;
+                        out_++;
+                    }
+                }else{
+                    if(!bCopy_){out_=front_;bCopy_=true;}
+                }
+            }
+            return out_;
+        }
+    iterator InsertImpl_(iterator p,const value_type& x)
+        {return vec_.insert(p,x);}
+    bool KeyCompare_Leq_(const K& ty0,const K& ty1)
+        {return !key_compare_(ty1,ty0);}
+    bool KeyCompare_Geq_(const K& ty0,const K& ty1)
+        {return !key_compare_(ty0,ty1);}
+    bool KeyCompare_Gt_(const K& ty0,const K& ty1)
+        {return key_compare_(ty1,ty0);}
+
+    key_compare         key_compare_;
+    Cont                vec_;
+};
+
+
+template<class K,bool bNoDuplicates,class Pr, class A> inline
+	bool operator==(const sorted_vector<K, bNoDuplicates,Pr,A>& x,
+		            const sorted_vector<K, bNoDuplicates,Pr,A>& Y_)
+	{return x.Eq_(Y_); }
+template<class K,bool bNoDuplicates,class Pr, class A> inline
+	bool operator!=(const sorted_vector<K, bNoDuplicates,Pr,A>& x,
+		            const sorted_vector<K, bNoDuplicates,Pr,A>& Y_)
+	{return !(x == Y_); }
+template<class K,bool bNoDuplicates,class Pr, class A> inline
+	bool operator<(const sorted_vector<K, bNoDuplicates,Pr,A>& x,
+		            const sorted_vector<K, bNoDuplicates,Pr,A>& Y_)
+	{return x.Lt_(Y_);}
+template<class K,bool bNoDuplicates,class Pr,class A> inline
+	bool operator>(const sorted_vector<K, bNoDuplicates,Pr,A>& x,
+		            const sorted_vector<K, bNoDuplicates,Pr,A>& Y_)
+	{return Y_ < x; }
+template<class K,bool bNoDuplicates,class Pr, class A> inline
+	bool operator<=(const sorted_vector<K, bNoDuplicates,Pr,A>& x,
+		            const sorted_vector<K, bNoDuplicates,Pr,A>& Y_)
+	{return !(Y_ < x); }
+template<class K, bool bNoDuplicates,class Pr,class A> inline
+	bool operator>=(const sorted_vector<K, bNoDuplicates,Pr,A>& x,
+		            const sorted_vector<K, bNoDuplicates,Pr,A>& Y_)
+	{return (!(x < Y_)); }
+}
+#pragma warning(pop)
+#pragma pack(pop)
+#elif VERSION_SORTED_VECTOR_ != 0x00010010
+#error You have included two sorted_vector.h with different version numbers
+#endif
diff --git a/sorted_vector_doc.html b/sorted_vector_doc.html
new file mode 100644
index 0000000..a0d2302
--- /dev/null
+++ b/sorted_vector_doc.html
@@ -0,0 +1,875 @@
+<!DOCTYPE HTML>
+
+
+<html>
+<head>
+	<title>An STL compliant sorted vector - CodeProject</title> 
+	<link type="text/css" rel="stylesheet" href="//dj9okeyxktdvd.cloudfront.net/App_Themes/CodeProject/Css/Main.min.css?dt=2.8.140814.1">
+<link type="text/css" rel="stylesheet" href="//dj9okeyxktdvd.cloudfront.net/App_Themes/CodeProject/Css/print.min.css?dt=2.8.140814.1">
+
+	
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+<meta name="Description" content="A template container which implements set/multiset functionality using a vector; Author: Martin Holzherr; Updated: 29 Nov 2002; Section: STL; Chapter: Platforms, Frameworks &amp; Libraries; Updated: 29 Nov 2002" />
+<meta name="Keywords" content="C++, Windows, Visual-Studio, STL, Dev, Intermediate,STL,Platforms, Frameworks &amp; Libraries,Free source code, tutorials" />
+<meta name="Author" content="Martin Holzherr" />
+<meta name="Rating" content="General" />
+<meta name="Robots" content="index, follow, NOODP" />
+<meta name="Revisit-After" content="1 days" />
+<meta name="application-name" content="CodeProject" />
+
+<link rel="dns-prefetch" href="//ajax.googleapis.com" /> 
+<link rel="canonical" href="/Articles/3217/An-STL-compliant-sorted-vector" />
+
+
+<link rel="alternate" type="application/rss+xml" title="CodeProject Latest articles - All Topics" href="http://www.codeproject.com/WebServices/ArticleRSS.aspx?cat=1" />
+<link rel="alternate" type="application/rss+xml" title="CodeProject Latest articles - Android" href="http://www.codeproject.com/WebServices/ArticleRSS.aspx?cat=22" />
+<link rel="alternate" type="application/rss+xml" title="CodeProject Latest articles - iOS" href="http://www.codeproject.com/WebServices/ArticleRSS.aspx?cat=25" />
+<link rel="alternate" type="application/rss+xml" title="CodeProject Latest articles - C++" href="http://www.codeproject.com/WebServices/ArticleRSS.aspx?cat=2" />
+<link rel="alternate" type="application/rss+xml" title="CodeProject Latest articles - C#" href="http://www.codeproject.com/WebServices/ArticleRSS.aspx?cat=3" />
+<link rel="alternate" type="application/rss+xml" title="CodeProject Latest articles - Web" href="http://www.codeproject.com/WebServices/ArticleRSS.aspx?cat=23" />
+<link rel="alternate" type="application/rss+xml" title="CodeProject Lounge Postings" href="http://www.codeproject.com/webservices/LoungeRSS.aspx" />
+<link rel="search" type="application/opensearchdescription+xml" title="CodeProject" href="http://www.codeproject.com/info/OpenSearch.xml" />
+
+	<base target="_top" />
+	<link rel="icon" href="/favicon.ico" type="image/ico" >
+<link rel="shortcut icon" href="/favicon.ico"  type="image/ico" >
+<link rel="apple-touch-icon" href="/images/FavIcon-Apple.png" type="image/png" >
+<script type="text/javascript" language="Javascript">//<![CDATA[
+function defrm () { /* thanks twitter */ document.write = ''; window.top.location = window.self.location;  setTimeout(function() { document.body.innerHTML = ''; }, 0);  window.self.onload = function(evt) { document.body.innerHTML = ''; }; }if (window.top !== window.self) {  try {  if (window.top.location.host) { /* will throw */ } else { defrm(); /* chrome */ }  } catch (ex) { defrm(); /* everyone else */ } }if (typeof(DemoUrl)!='undefined')   document.write(unescape('%3Cme')+'ta http'+'-equiv="re'+'fresh"                  con'+'tent="1;url='+DemoUrl+unescape('"%3CE'));
+
+//]]>
+</script>
+
+	
+
+
+
+
+<script type="text/javascript">
+	var _gaq = _gaq || [];
+	_gaq.push(['_setAccount', 'UA-1735123-1']);
+	_gaq.push(['_trackPageview']);
+	_gaq.push(['_setDomainName', 'www.codeproject.com']);
+	_gaq.push(['_setSessionTimeout', '1200']); 
+
+	(function () {
+		var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+		ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+		(document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(ga);
+	})(); 
+</script>
+
+
+</head>	
+
+<body class="unknown unknown0">
+
+<a class="access-link" href="#Main"><img alt="Click here to Skip to main content" src="//dj9okeyxktdvd.cloudfront.net/Images/t.gif" /></a>
+
+
+
+
+
+<div class="page-background">
+
+	
+	
+
+	
+
+	<table id="ctl00_Bn" style="width:100%;height:135px" cellpadding="0" cellspacing="0" class="banner fluid">
+	<tr valign="bottom">
+		<td class="blank-background" style="height:31px">&nbsp;</td>
+		<td class="blank-background" rowspan="3" style="width:250px;height:135px"><a href="/"><img id="ctl00_Logo" tabindex="1" title="CodeProject" src="//dj9okeyxktdvd.cloudfront.net/App_Themes/CodeProject/Img/logo250x135.gif" alt="Home" height="135" width="250" border="0" /></a></td>
+		<td class="blank-background align-right" style="width:728px;height:31px"></td>
+		<td class="blank-background" style="height:31px">&nbsp;</td>
+	</tr>
+	<tr valign="middle">
+		<td class="theme1-background" style="height:94px">&nbsp;</td>
+		<td class="theme1-background ad"></td>
+		<td class="theme1-background" style="height:94px">&nbsp;</td>
+	</tr>
+	<tr valign="top">
+		<td style="height: 14px;"></td>
+		<td style="height: 14px;" class="blank-background"></td>
+		<td style="height: 14px;"></td>
+	</tr>
+</table>
+
+
+	<a href="#Main"><img alt="Click here to Skip to main content" class="access-link" src="//dj9okeyxktdvd.cloudfront.net/Images/t.gif" /></a>
+
+	
+	
+	
+
+	<div id="A" class="container-content-wrap fluid print"> 
+
+	<div itemscope itemtype="http://schema.org/Article" class="container-content"> 
+
+		<div class="clearfix">
+			<div class="float-left container-breadcrumb">
+				<div><a href="/script/Content/SiteMap.aspx">Articles</a> &#187; <a href="/Chapters/8/Platforms-Frameworks-Libraries.aspx">Platforms, Frameworks & Libraries</a> &#187; <a href="/KB/stl/"><span itemprop="articleSection">STL</span></a> &#187; <a href="/KB/stl/#Collections+and+Iterators">Collections and Iterators</a></div>
+			</div>
+
+			<div class="align-left float-right padded-top" style="width">
+				
+			</div>
+
+			<div class="float-right article-nav">
+				
+				
+			</div>
+
+			<div class="align-right float-left">
+				
+			</div>
+		</div>
+
+		<table class="extended container-article-parts" cellpadding="0" cellspacing="0">
+        <tr valign="top">
+		<td width="117px">
+
+			
+
+		</td>
+		<td>
+			
+			<div id="AT" class="container-article  fluid tight"> 
+				<div class="article">
+
+					<form name="aspnetForm" method="post" action="/Articles/3217/An-STL-compliant-sorted-vector?display=Print" id="aspnetForm" style="margin:0;padding:0">
+<input type="hidden" name="__VIEWSTATE" id="__VIEWSTATE" value="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" />
+
+
+					
+					 
+					<div class="header">
+					    <a name="Main"></a>
+
+					    
+					    <a name="_articleTop" id="_articleTop"></a>
+					    <div class="title">
+					        
+					        <h1 id="ctl00_ArticleTitle" itemprop="name">An STL compliant sorted vector</h1> 
+					    </div>
+
+                        <div style="height:34px">
+					        
+					        <div class="entry float-left">
+                                
+                                <div class="float-left">
+
+						            <span class="author"><a href="/script/Membership/View.aspx?mid=6888" rel="author"><span itemprop="author" itemscope itemtype="http://schema.org/Person"><span itemprop="name">Martin Holzherr</span></span></a></span>, 
+						            <span class="date" itemprop="dateModified" content="2002-11-29 00:00:00">
+							            28 Nov 2002</span>
+			
+						            <div id="ctl00_CurRat" class="tooltip anchorLink" style="cursor:pointer;margin-top: 5px">
+				
+							            
+
+<table cellpadding="0" cellspacing="0" class="small-text" itemprop="aggregateRating" itemscope itemtype="http://schema.org/AggregateRating"> 
+<tr>
+	
+	<td class="nowrap">
+
+		
+			<meta itemprop="bestRating" content="5"> 
+			<meta itemprop="worstRating" content="1">
+		
+
+		<span id="ctl00_ArticleRating_VI">
+		<div class="nowrap rating-stars-large" style="position:relative;">
+	<div class="clipped align-left float-left">
+		<img src="//dj9okeyxktdvd.cloudfront.net/script/Ratings/Images/stars-fill-lg.png" border="0" />
+	</div><div class="clipped" style="position:relative;">
+		<img src="//dj9okeyxktdvd.cloudfront.net/script/Ratings/Images/stars-empty-lg.png" border="0" style="position:absolute;top:0;right:0;" />
+	</div>
+</div>
+		</span>
+
+		
+	</td>
+	
+	<td id="ctl00_ArticleRating_VR" class="nowrap">
+		&nbsp;
+		<span id="ctl00_ArticleRating_VotesR">&nbsp;<span itemprop="ratingValue" class="rating">4.56</span> (<span itemprop="ratingCount" class="count">13</span> votes)</span>
+		
+	</td>
+
+</tr>
+
+</table>
+
+
+							            <div id="ctl00_RB" class="speech-bubble-container-up">
+								            <div class="speech-bubble-up" style="width:150px !important">
+									                        
+<div>
+<table class="feature" width="100%" height="20px" title="Voting Distribution. Recent data only" cellpadding="0" cellspacing="0"><tr class="chart-row"><td class="chart-column"><img src="//dj9okeyxktdvd.cloudfront.net/Images/t.gif" width="20pxpx" height="1px" border="0px" alt="" title="" /><br /><span title="0 votes">1</span></td>
+<td class="chart-column"><img src="//dj9okeyxktdvd.cloudfront.net/Images/t.gif" width="20pxpx" height="1px" border="0px" alt="" title="" /><br /><span title="0 votes">2</span></td>
+<td class="chart-column"><img src="//dj9okeyxktdvd.cloudfront.net/script/Ratings/Images/pollcol.gif" width="20pxpx" height="2px" border="0px" alt="1 vote, 10.0%" title="1 vote, 10.0%" /><br /><span title="1 vote">3</span></td>
+<td class="chart-column"><img src="//dj9okeyxktdvd.cloudfront.net/script/Ratings/Images/pollcol.gif" width="20pxpx" height="5px" border="0px" alt="2 votes, 20.0%" title="2 votes, 20.0%" /><br /><span title="2 votes">4</span></td>
+<td class="chart-column"><img src="//dj9okeyxktdvd.cloudfront.net/script/Ratings/Images/pollcol.gif" width="20pxpx" height="20px" border="0px" alt="7 votes, 70.0%" title="7 votes, 70.0%" /><br /><span title="7 votes">5</span></td>
+</tr></table><div class="small-text align-center">4.56/5 - 13 votes</div><div class="small-text align-center subdue">μ 4.56, σ<sub>a</sub> 1.22 [<a href="/KB/FAQs/RatingReputationFAQ.aspx#noisefilter">?</a>]</div>
+</div>
+								            </div>
+								            <div class="speech-bubble-pointer-up">
+									            <div class="speech-bubble-pointer-up-inner"></div>
+								            </div>
+							            </div>
+						            </div>
+                                </div>
+					        </div>
+
+                            
+						    
+						    	
+
+						    	
+                            <div class="float-right" style="margin-right:10px">
+						        
+                            </div>                    
+						    	
+                        </div>
+
+   					    
+                        <div id="ctl00_description" class="summary">A template container which implements set/multiset functionality using a vector</div>			
+
+                    </div>
+                    
+					
+					
+
+
+					
+					
+
+					
+					
+					
+
+						
+					
+
+					
+
+						
+						<div id="contentdiv" class="text" itemprop="articleBody">
+						
+
+
+
+<ul class="download">
+<li><a href="/KB/stl/sorted_vector/sorted_vector_src.zip">Download source files - 7 Kb</a></li>
+</ul>
+
+
+<h2>Introduction</h2>
+
+<p><code>sorted_vector</code> adapts a <code>std::vector</code> to the interface required by
+<code>std::set/std::multiset</code>, thereby providing set/multiset and vector
+functionality (random access) in one container.</p>
+
+<p>Tests show that <code>sorted_vector</code>'s element retrieval (find) speed  outperforms
+that of  <code>std::set/std::multiset</code> by a factor of 2 (on most machines). On the downward side is 
+the poor performance of <code>sorted_vector</code>'s insert member function, because it
+inserts an element somewhere in the middle of the sorted vector in order
+to preserve the sort order. By using <code>sorted_vector</code>'s low level interface one can
+solve this performance bottleneck by inserting a bunch of objects using a series of 
+<code>push_back</code>'s followed by a call to the member function <code>sort</code>, which restores the sort
+order. </p>
+
+<p><code>sorted_vector</code> should be preferred over <code>std::set/std::multiset</code> 
+if many small elements
+must be stored. Most STL implementations use a variant of a balanced tree to 
+implement set and multiset, which imposes a per element storage overhead of 3 pointers.
+The most important reason to use a <code>std::set/std::multiset</code> instead of 
+<code>sorted_vector</code> is
+the need to keep iterators into a set/multiset while inserting more elements into
+the set. These iterators remain valid in the case of a set/multiset, but are invalidated
+in the case of a <code>sorted_vector</code> container. </p>
+
+<h2>Namespace</h2>
+<p><code>sorted_vector</code> resides in the namespace <code>codeproject</code>.</p>
+
+<h2>Basic Usage</h2>
+
+<p>The following small table shows corresponding declarations of <code>sorted_vector</code>'s 
+and <code>set</code>'s/<code>multiset</code>'s.</p>
+
+<Table border=1>
+<TR>
+<TH>STL concept</TH>
+<TH>std library</TH>
+<TH>sorted_vector</TH>
+</TR>
+<TR>
+<TD VAlign=top>set</TD>
+<TD VAlign=top><code>set&lt;Key,Pred&gt;</code></TD>
+<TD VAlign=top><code>sorted_vector&lt;Key,<span class='cpp-keyword'>true</span>,Pred&gt;</code></TD>
+</TR>
+<TD VAlign=top>multiset</TD>
+<TD VAlign=top><code>mutliset&lt;Key,Pred&gt;</code></TD>
+<TD VAlign=top><code>sorted_vector&lt;Key,Pred&gt;</code></TD>
+</Table>
+
+<p>(<code>sorted_vector&lt;Key,Pred,<span class='cpp-keyword'>true</span>&gt;</code> means <code>sorted_vector&lt;Key,Pred,bNoDuplicates=<span class='cpp-keyword'>true</span>&gt;</code>)</p>
+
+<P>The various set/multiset <code>insert</code> and <code>erase</code> member functions as well as the
+set/multiset functions <code>count, lower_bound,upper_bound, equal_range</code> are part of 
+<code>sorted_vector</code>'s interface and behave the same as there set/multiset counterparts.
+The following code snippet shows the use of a <code>sorted_vector</code> to hold the
+set intersection of the content of two <code>std::vector</code>'s.</p>
+
+<pre><span class="code-preprocessor">#pragma</span> warning(disable:<span class="code-digit">4786</span>)
+#include <span class="code-string">"</span><span class="code-string">sorted_vector.h"</span>
+size_t             <span class="code-comment">//</span><span class="code-comment">build intersection using set interface of sorted_vector
+</span>BuildIntersection(  <span class="code-keyword">const</span> std::vector&lt;<span class="code-keyword">int</span>&gt;&amp; v0,<span class="code-keyword">const</span> std::vector&lt;<span class="code-keyword">int</span>&gt;&amp; v1,
+                    codeproject::sorted_vector&lt;<span class="code-keyword">int</span>,<span class="code-keyword">true</span>&gt;&amp; svecIntersection)
+{		
+    codeproject::sorted_vector&lt;<span class="code-keyword">int</span>,<span class="code-keyword">true</span>&gt; svec(v0.begin(),v0.end());
+    <span class="code-keyword">for</span>(<span class="code-keyword">int</span> i=0;i&lt;v1.size();i++){
+        <span class="code-keyword">if</span>( svec.find(v1[i])!=svec.end() ){
+            svecIntersection.insert(v1[i]);
+        }
+    }
+    <span class="code-keyword">return</span> svecIntersection.size();
+}
+</pre>
+
+<p>The code example shows the use of the member functions <code>find</code> and <code>insert</code>. 
+If you replace <code>codeproject::sorted_vector&lt;<span class='cpp-keyword'>int</span>,<span class='cpp-keyword'>true</span>&gt;</code> by <code>std::set&lt;<span class='cpp-keyword'>int</span>&gt;</code> you get exactly
+the same result. This piece of code can be optimized for speed by replacing the  insert calls in the loop 
+by calls to <code>push_back</code> of the base container (a vector) followed by a call 
+to the member function <code>sort</code> at the end of the loop.</p>
+
+<pre><span class="code-preprocessor">#pragma</span> warning(disable:<span class="code-digit">4786</span>)
+<span class="code-preprocessor">#include</span><span class="code-preprocessor"> <span class="code-string">"</span><span class="code-string">sorted_vector.h"</span>
+</span><span class="code-sdkkeyword">size_t</span>             <span class="code-comment">//</span><span class="code-comment">same as previous example, optimized insertions 
+</span>BuildIntersection1(  <span class="code-keyword">const</span> std::vector&lt;<span class="code-keyword">int</span>&gt;&amp; v0,<span class="code-keyword">const</span> std::vector&lt;<span class="code-keyword">int</span>&gt;&amp; v1,
+                    codeproject::sorted_vector&lt;<span class="code-keyword">int</span>,<span class="code-keyword">true</span>&gt;&amp; svecIntersection)
+{		
+    codeproject::sorted_vector&lt;<span class="code-keyword">int</span>,<span class="code-keyword">true</span>&gt; svec(v0.begin(),v0.end());
+    codeproject::sorted_vector&lt;<span class="code-keyword">int</span>,<span class="code-keyword">true</span>&gt;::Cont&amp; vInterSect 
+        = svecIntersection.get_container();
+    <span class="code-keyword">for</span>(<span class="code-keyword">int</span> i=0;i&lt;v1.size();i++){
+        <span class="code-keyword">if</span>( svec.find(v1[i])!=svec.end() ){
+            vInterSect.push_back(v1[i]);
+        }
+    }
+    svecIntersection.sort();
+    <span class="code-keyword">return</span> svecIntersection.size();
+}
+</pre>
+
+<h2>Interface of sorted_vector </h2>
+<Table border=1>
+<TR>
+<TH>
+Member
+</TH>
+<TH>
+Coming from
+</TH>
+<TH>
+Description
+</TH>
+</TR>
+<TR>
+<TD VAlign=top><code>Cont</code></TD>
+<TD VAlign=top>sorted_vector</TD>
+<TD VAlign=top>container type, the type of the container used to store the controlled sequence.</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>value_type</code></TD>
+<TD VAlign=top>vector</TD>
+<TD VAlign=top>The type of object, T, stored in the set.</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>key_type</code></TD>
+<TD VAlign=top>set/multiset</TD>
+<TD VAlign=top>The key type associated with value_type.</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>key_compare</code></TD>
+<TD VAlign=top>set/multiset</TD>
+<TD VAlign=top>Function object that compares two keys for ordering.</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>value_compare</code></TD>
+<TD VAlign=top>set/multiset</TD>
+<TD VAlign=top>Function object that compares two values for ordering.</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>pointer</code></TD>
+<TD VAlign=top>vector</TD>
+<TD VAlign=top>Pointer to T.</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>reference</code></TD>
+<TD VAlign=top>vector</TD>
+<TD VAlign=top>Reference to T</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>const_reference</code></TD>
+<TD VAlign=top>vector</TD>
+<TD VAlign=top>Const reference to T</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>size_type</code></TD>
+<TD VAlign=top>vector</TD>
+<TD VAlign=top>An unsigned integral type.</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>difference_type</code></TD>
+<TD VAlign=top>vector</TD>
+<TD VAlign=top>A signed integral type.</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>iterator</code></TD>
+<TD VAlign=top>vector</TD>
+<TD VAlign=top>Random access iterator used to iterate through a vector.</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>const_iterator</code></TD>
+<TD VAlign=top>vector</TD>
+<TD VAlign=top>Random access const iterator used to iterate through a vector</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>reverse_iterator</code></TD>
+<TD VAlign=top>vector</TD>
+<TD VAlign=top>Random access iterator used to iterate backwards through a vector.
+</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>const_reverse_iterator</code></TD>
+<TD VAlign=top>vector</TD>
+<TD VAlign=top>Random access const iterator used to iterate backwards through a vector.</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>iterator begin() <span class='cpp-keyword'>const</span></code></TD>
+<TD VAlign=top>vector</A></TD>
+<TD VAlign=top>Returns an iterator pointing to the beginning of the sorted_vector.</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>iterator end() <span class='cpp-keyword'>const</span></code></TD>
+<TD VAlign=top>vector</TD>
+<TD VAlign=top>Returns an iterator pointing to the end of the sorted_vector.</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>reverse_iterator rbegin() <span class='cpp-keyword'>const</span></code></TD>
+<TD VAlign=top>vector</TD>
+<TD VAlign=top>Returns a reverse_iterator pointing to the beginning of the reversed sorted_vector</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>reverse_iterator rend() <span class='cpp-keyword'>const</span></code></TD>
+<TD VAlign=top>vector</A></TD>
+<TD VAlign=top>Returns a reverse_iterator pointing to the end of the reversed sorted_vector.</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>size_type size() <span class='cpp-keyword'>const</span></code></TD>
+<TD VAlign=top>vector</TD>
+<TD VAlign=top>Returns the size of the sorted_vector.</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>size_type max_size() <span class='cpp-keyword'>const</span></code></TD>
+<TD VAlign=top>vector</A></TD>
+<TD VAlign=top>Returns the largest possible size of the sorted_vector.</TD>
+</TR>
+<TR>
+<TD VAlign=top><code><span class='cpp-keyword'>bool</span> empty() <span class='cpp-keyword'>const</span></code></TD>
+<TD VAlign=top>vector</TD>
+<TD VAlign=top>true if the sorted_vec's size is 0.</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>key_compare key_comp() <span class='cpp-keyword'>const</span></code></TD>
+<TD VAlign=top>set/multiset</A></TD>
+<TD VAlign=top>Returns the key_compare object used by the sorted_vector.</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>value_compare value_comp() <span class='cpp-keyword'>const</span></code></TD>
+<TD VAlign=top>set/multiset</TD>
+<TD VAlign=top>Returns the value_compare object used by the sorted_vector.</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>sorted_vector()</code></TD>
+<TD VAlign=top>set/multiset</TD>
+<TD VAlign=top>Creates an empty sorted_vector.</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>sorted_vector(<span class='cpp-keyword'>const</span> key_compare&amp; comp)</code></TD>
+<TD VAlign=top>set/multiset</TD>
+<TD VAlign=top>Creates an empty sorted_vector, using comp as the key_compare object.</TD>
+</TR>
+<TR>
+<TD VAlign=top><B>VC++7.0:<BR> </B><pre><span class="code-keyword">template</span> &lt;<span class="code-keyword">class</span> InputIterator&gt;
+sorted_vector(InputIterator f,
+ InputIterator l)</pre>
+	<BR><B>VC++6.0:<BR> </B><code>sorted_vector(const_iterator f, const_iterator l)</code> 
+</TD>
+<TD VAlign=top>set/multiset</TD>
+<TD VAlign=top>Creates a sorted_vector with a copy of a range.</TD>
+</TR>
+<TR>
+<TD VAlign=top><B>VC++7.0:<BR> </B><pre><span class="code-keyword">template</span> &lt;<span class="code-keyword">class</span> InputIterator&gt;
+sorted_vector(InputIterator f,
+InputIterator l,<span class="code-keyword">const</span> key_compare&amp; comp)</pre>
+	<BR><B>VC++6.0:<BR> </B><code>sorted_vector(const_iterator f, const_iterator l,<span class='cpp-keyword'>const</span> key_compare&amp; comp)</code> 
+</TD>
+<TD VAlign=top>set/multiset</TD>
+<TD VAlign=top>Creates a sorted_vector with a copy of a range, using comp as the key_compare object.</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>sorted_vector(<span class='cpp-keyword'>const</span> sorted_vector&amp;)</code></TD>
+<TD VAlign=top>set/multiset</TD>
+<TD VAlign=top>The copy constructor.</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>sorted_vector&amp; <span class='cpp-keyword'>operator</span>=(<span class='cpp-keyword'>const</span> sorted_vector&amp;)</code></TD>
+<TD VAlign=top>set/multiset</TD>
+<TD VAlign=top>The assignment operator (assigns other sorted_vector )</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>sorted_vector&amp; <span class='cpp-keyword'>operator</span>=(<span class='cpp-keyword'>const</span> Cont&amp;)</code></TD>
+<TD VAlign=top>sorted_vector</TD>
+<TD VAlign=top>The assignment operator (assigns other vector&lt;T> )</TD>
+</TR>
+<TR>
+<TD VAlign=top><code><span class='cpp-keyword'>void</span> swap(sorted_vector&amp;)</code></TD>
+<TD VAlign=top>set/multiset</TD>
+<TD VAlign=top>Swaps the contents of two sorted_vector's</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>pair&lt;iterator, <span class='cpp-keyword'>bool</span>&gt;insert(<span class='cpp-keyword'>const</span> value_type&amp; x)</code></TD>
+<TD VAlign=top>set/multiset</TD>
+<TD VAlign=top>Inserts x into the sorted_vector.</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>iterator insert(iterator pos, <span class='cpp-keyword'>const</span> value_type&amp; x)</code></TD>
+<TD VAlign=top>set/multiset</TD>
+<TD VAlign=top>Inserts x into the sorted_vector, using pos as a hint to where it will be
+   inserted.
+</TD>
+</TR>
+<TR>
+<TD VAlign=top><B>VC++7.0:<BR> </B><pre><span class="code-keyword">template</span> &lt;<span class="code-keyword">class</span> InputIterator&gt;
+<span class="code-keyword">void</span> insert(InputIterator f, InputIterator l)</pre>
+	<BR><B>VC++6.0:<BR> </B><code><span class='cpp-keyword'>void</span> insert(const_iterator first f, const_iterator l)</code>
+</TD>
+<TD VAlign=top>set/multiset</TD>
+<TD VAlign=top>Inserts a range into the sorted_vector.</TD>
+</TR>
+<TR>
+<TD VAlign=top><code><span class='cpp-keyword'>void</span> erase(iterator pos)</code></TD>
+<TD VAlign=top>vector</TD>
+<TD VAlign=top>Erases the element pointed to by pos.</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>size_type erase(<span class='cpp-keyword'>const</span> key_type&amp; k)</code></TD>
+<TD VAlign=top>set/multiset</A></TD>
+<TD VAlign=top>Erases the element whose key is k.</TD>
+</TR>
+<TR>
+<TD VAlign=top><code><span class='cpp-keyword'>void</span> erase(iterator first, iterator last)</code></TD>
+<TD VAlign=top>vector</A></TD>
+<TD VAlign=top>Erases all elements in a range.</TD>
+</TR>
+<TR>
+<TD VAlign=top><code><span class='cpp-keyword'>void</span> clear()</code></TD>
+<TD VAlign=top>vector</A></TD>
+<TD VAlign=top>Erases all of the elements.</TD>
+</TR>
+<TR>
+<TD VAlign=top><pre>iterator
+ find(<span class="code-keyword">const</span> key_type&amp; k) <span class="code-keyword">const</span></pre></TD>
+<TD VAlign=top>set/multiset</TD>
+<TD VAlign=top>Finds an element whose key is k.</TD>
+</TR>
+<TR>
+<TD VAlign=top><pre>size_type
+ count(<span class="code-keyword">const</span> key_type&amp; k) <span class="code-keyword">const</span></pre></TD>
+<TD VAlign=top>set/multiset</A></TD>
+<TD VAlign=top>Counts the number of elements whose key is k.</TD>
+</TR>
+<TR>
+<TD VAlign=top><pre>iterator
+ lower_bound(<span class="code-keyword">const</span> key_type&amp; k) <span class="code-keyword">const</span></pre></TD>
+<TD VAlign=top>set/multiset</TD>
+<TD VAlign=top>Finds the first element whose key is not less than k.</TD>
+</TR>
+<TR>
+<TD VAlign=top><pre>iterator
+ upper_bound(<span class="code-keyword">const</span> key_type&amp; k) <span class="code-keyword">const</span></pre></TD>
+<TD VAlign=top>set/multiset</TD>
+<TD VAlign=top>Finds the first element whose key is greater than k.</TD>
+</TR>
+<TR>
+<TD VAlign=top><pre>pair&lt;iterator, iterator&gt;
+equal_range(<span class="code-keyword">const</span> key_type&amp; k) <span class="code-keyword">const</span></pre></TD>
+<TD VAlign=top>set/multiset</TD>
+<TD VAlign=top>Finds a range containing all elements whose key is k.</TD>
+</TR>
+<TR>
+<TD VAlign=top><code><span class='cpp-keyword'>bool</span> <span class='cpp-keyword'>operator</span>==(<span class='cpp-keyword'>const</span> sorted_vector&amp;,<span class='cpp-keyword'>const</span> sorted_vector&amp;)</code></TD>
+<TD VAlign=top>vector</TD>
+<TD VAlign=top>Tests two sorted_vector for equality.  This is a global function, not a member function.
+There is also an operator !=</TD>
+</TR>
+<TR>
+<TD VAlign=top><code><span class='cpp-keyword'>bool</span> <span class='cpp-keyword'>operator</span>&lt;(<span class='cpp-keyword'>const</span> sorted_vector&amp;, <span class='cpp-keyword'>const</span> sorted_vector&amp;)</code></TD>
+<TD VAlign=top>vector</TD>
+<TD VAlign=top>Lexicographical comparison.  This is a global function, not a member function.
+ There are also operators &lt;= &gt;= and &gt;</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>Cont& get_container()</code></TD>
+<TD VAlign=top>sorted_vector</TD>
+<TD VAlign=top>Returns a reference to the internal vector used to store the controlled sequence</TD>
+</TR>
+<TR>
+<TD VAlign=top><code><span class='cpp-keyword'>void</span> sort()</code></TD>
+<TD VAlign=top>sorted_vector</TD>
+<TD VAlign=top>Restores the sort order using key_compare </TD>
+</TR>
+<TR>
+<TD VAlign=top><code>reference at(size_type i)</code></TD>
+<TD VAlign=top>sorted_vector</TD>
+<TD VAlign=top>Returns a reference to the element at *(begin()+i) with range check</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>const_reference at(size_type i) <span class='cpp-keyword'>const</span></code></TD>
+<TD VAlign=top>sorted_vector</TD>
+<TD VAlign=top>Returns a reference to the element at *(begin()+i) with range check</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>const_reference <span class='cpp-keyword'>operator</span>[](size_type i) <span class='cpp-keyword'>const</span></code></TD>
+<TD VAlign=top>sorted_vector</TD>
+<TD VAlign=top>Returns a reference to the element at *(begin()+i)</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>reference <span class='cpp-keyword'>operator</span>[](size_type i)</code></TD>
+<TD VAlign=top>sorted_vector</TD>
+<TD VAlign=top>Returns a reference to the element at *(begin()+i)</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>const_reference front() <span class='cpp-keyword'>const</span></code></TD>
+<TD VAlign=top>sorted_vector</TD>
+<TD VAlign=top>Returns a reference to the first element</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>reference front()</code></TD>
+<TD VAlign=top>sorted_vector</TD>
+<TD VAlign=top>Returns a reference to the first element</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>reference back()</code></TD>
+<TD VAlign=top>sorted_vector</TD>
+<TD VAlign=top>Returns a reference to the last element</TD>
+</TR>
+<TR>
+<TD VAlign=top><code>const_reference back() <span class='cpp-keyword'>const</span></code></TD>
+<TD VAlign=top>sorted_vector</TD>
+<TD VAlign=top>Returns a reference to the last element</TD>
+</TR>
+<TR>
+<TD VAlign=top><code><span class='cpp-keyword'>void</span> pop_back() </code>	</TD>
+<TD VAlign=top>sorted_vector</TD>
+<TD VAlign=top>Removes the last element from the sorted_vector</TD>
+</TR>
+</table>
+
+
+
+<h2>Points of Interest</h2>
+
+<p>An interview with Alexander Stepanov (inventor of the STL) at
+<A href="http://www.stlport.org/resources/StepanovUSA.html">http://www.stlport.org/resources/StepanovUSA.html</A>
+, in which he proposed to implement
+a sorted container as an adapter of a <code>std::container</code> gave me the idea for this work.
+The real surprise to me was the unexpected good performance of <code>sorted_vector</code> compared
+to set/multiset. The outcome of my tests indicate, that the <code>std::set/std::multiset</code>
+has only one (important) advantage over a sorted vector, namely that iterators remain
+valid in a set/multiset, even when more elements are added.
+</p>
+
+<p>The implementation work itself was easy and did not require any advanced C++/STL feature.
+It can be summarized as follows:
+Most of the member functions of <code>sorted_vector</code> forward the call to the <code>vec_</code> data member,
+which is a <code>std::vector</code>. The set/multiset specific functions for inserting/erasing and
+locating elements mostly use STL algorithms to deal with the sorted sequence present
+in the <code>vec_</code> data member. The low level interface consisting of the member functions
+	<code>get_container()</code> (which returns a reference to the <code>vec_</code> data member) 
+and <code>sort</code> and <code>stable_sort</code> 
+ (which restore the sort order) are necessary to improve insertion performance (by allowing
+ a temporary violation of the sorting order).
+Only one function was unexpectedly difficult to implement: The function <code>unique</code>, which
+must be called after <code>sort</code> and <code>stable_sort</code> in the case of a set. 
+This function is part of the STL and requires a predicate as third argument. This predicate must return true,
+if the passed elements are equal. But the class <code>sorted_vector</code> only has access to a predicate
+which evaluates the < relation. In theory, it should be possible, to transform a predicate
+evaluating the &lt; relation into another predicate evaluating ==, but in practice this is only
+possible, when the &lt; predicate  is implemented as object derived from <code>std::binary_function</code>.
+Ultimately, I had to implement <code>unique</code> myself because of that. </p>
+
+<h2>History</h2>
+<ul><li>1.0: November 19th, 2002; Initial release. </li>
+<li>1.1: November 28th, 2002; Documentation and code Update
+	<ul><li>changed namespace from <code>std</code> to <code>codeproject</code></li>
+            <li>supports member templates for constructing/inserting from iterator range in case of VC++7.0</li>
+	</ul>
+</li>
+</ul>
+
+
+						</div>
+						
+
+						<div class="float-right" style="margin:20px 0 0 0;border:1px solid #ccc">
+						
+						</div>
+                        
+                        
+						
+						<h2>License</h2>
+						<div id="LicenseTerms"><p>This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.</p><p>A list of licenses authors might use can be found <a href="/info/Licenses.aspx">here</a></p></div>
+						
+
+                        
+						<h2>Share</h2>
+				        <div style="margin-bottom:40px;width:385px">
+					        
+				        </div> 
+    			        
+
+
+						
+						<h2 id="ctl00_AboutHeading">About the Author</h2>
+						
+
+<div class="container">
+<div style="width:210px;overflow:hidden;float:left;text-align:center">
+	<img id="ctl00_AboutAuthorRptr_ctl00_AboutAuthor_memberPhoto" class="profile-pic" src="//dj9okeyxktdvd.cloudfront.net/script/Membership/Images/member_unknown.gif" border="0" style="transform:rotate(-3deg);" />
+</div>
+<div class="container-member float-left" style="margin-top:35px;">
+	<b><a id="ctl00_AboutAuthorRptr_ctl00_AboutAuthor_memberProfileLink" class="author" href="/Members/Martin-Holzherr">Martin Holzherr</a></b>
+	<div class="company">
+		<span id="ctl00_AboutAuthorRptr_ctl00_AboutAuthor_memberJobTitle"></span>
+		<span id="ctl00_AboutAuthorRptr_ctl00_AboutAuthor_memberCompany"></span> 
+		<br /><span id="ctl00_AboutAuthorRptr_ctl00_AboutAuthor_memberLocation">Switzerland <img src="/script/Geo/Images/CH.gif" alt="Switzerland" width="16px" height="11px" /></span>
+	</div>
+</div>
+	
+<div class="padded-top float-left clearfix">
+	No Biography provided
+
+	
+
+	
+</div>
+</div><br />
+						
+						
+
+						<div class="clearfix"></div>
+
+						<div style="padding-top:8px">
+							
+						</div>
+
+						
+						<div style="margin:auto;height:90px;margin-top:10px;Widt:730px"> 
+							
+						</div>
+						
+					
+
+				    
+					</form>
+
+				</div>
+
+				
+				
+
+					<h2>Comments and Discussions</h2>
+					
+					<p><img alt="Comment" src="/script/forums/images/NewComment.gif" width="12px" height="16px" />
+					<b>20 messages</b> have been posted for this article 
+					Visit <b><a id="ctl00_ArticleLink" href="/Articles/3217/An-STL-compliant-sorted-vector">http://www.codeproject.com/Articles/3217/An-STL-compliant-sorted-vector</a></b> to post and view comments on 
+					this article, or click <b><a id="ctl00_PrintWithMessage" href="/Articles/3217/An-STL-compliant-sorted-vector?display=PrintAll">here</a></b> 
+					to get a print view with messages.</p>
+					
+				
+
+			</div>
+			
+		</td>
+		<td width="170px">
+			
+		</td>
+		</tr></table>
+
+		
+		<div class="theme1-background" style="height:2px" id="stickyStop"></div>
+
+		<div class="extended tiny-text">
+			<div class="row">
+				<div class="float-left">
+					<a id="ctl00_PermaLink" itemprop="url" href="/Articles/3217/An-STL-compliant-sorted-vector">Permalink</a> | 
+					<a id="ctl00_AdvertiseLink" href="http://developermedia.com/">Advertise </a> |
+					<a id="ctl00_PrivacyLink" href="/info/privacy.aspx">Privacy</a> |
+					<a id="ctl00_Mobile" rel="nofollow" href="/Articles/3217/An-STL-compliant-sorted-vector?display=Mobile">Mobile</a>
+					<br />
+								
+					
+					Web02 |
+					2.8.140814.1 |
+					Last Updated 29 Nov 2002								
+				</div>
+				<div class="float-right align-right">
+					Article Copyright 2002 by Martin Holzherr<br />Everything else
+					Copyright &copy; <a href="mailto:webmaster@codeproject.com">CodeProject</a>, 1999-2014 <br />
+					<a id="ctl00_TermsOfUseLink" href="/info/TermsOfUse.aspx">Terms of Service</a>
+				</div>
+
+				
+
+			</div>
+		</div>
+		
+
+		<br clear="all" />
+		
+			
+
+	</div> 
+	</div>
+</div>
+
+
+<div style="display:none;" id="dm_AdTable">
+	
+</div>
+
+
+
+
+
+
+<script type="text/javascript" language="Javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.6.2/jquery.min.js"></script><script type='text/javascript'>//<![CDATA[
+if (typeof jQuery == 'undefined') {
+    document.write(unescape("%3Cscript src='/script/JS/jquery-1.6.2.min.js' type='text/javascript' %3E%3C/script%3E"));
+}//]]></script>
+<script type="text/javascript" language="Javascript">//<![CDATA[
+$(document).ready(function() { anchorAnimate();
+$('#ctl00_RightSideBar').sticky($('#stickyStop'));
+$('#ctl00_Nav').sticky($('#stickyStop'));
+});
+
+//]]>
+</script>
+
+
+</body>
+</html>
\ No newline at end of file
diff --git a/sorted_vector_src.zip b/sorted_vector_src.zip
new file mode 100644
index 0000000..3354137
Binary files /dev/null and b/sorted_vector_src.zip differ