class A
{
  MType m;
  public:
    typedef map<int, float> MType;
    float GetVal(int key) const
    {
       MType::const_iterator itr = m.find(key);
       if(itr == m.end())
         throw MErr(string("Нет элемента с номером ") + lexical_cast<string>(key));
       return itr->second;
    }
}

M>class A
M>{
M>  MType m;
M>  public:
M>    typedef map<int, float> MType;
M>    float GetVal(int key) const
M>    {
M>       MType::const_iterator itr = m.find(key);
M>       if(itr == m.end())
M>         throw MErr(string("Нет элемента с номером ") + lexical_cast<string>(key));
M>       return itr->second;
M>    }
M>}

M>

MType::range r = m.find(key);
if(r.empty())
  throw MErr(string("Нет элемента с номером ") + lexical_cast<string>(key));
return r.front().second;

CTypedPtrList<CObList, CPerson*> myList;

myList.AddHead(new CPerson());
POSITION pos = myList.GetHeadPosition();
while(pos != NULL)
{
   CPerson* thePerson = myList.GetNext(pos);
   thePerson->AssertValid();
}

CMap<CString, LPCTSTR, CPerson*, CPerson*> myMap;
CPerson myPerson;

myMap.SetAt(_T("Bill"), &myPerson);
POSITION pos = myMap.GetStartPosition();
while(pos != NULL)
{
   CPerson* pPerson;
   CString string;
   // Get key (string) and value (pPerson)
   myMap.GetNextAssoc(pos, string, pPerson);
   // Use string and pPerson
}

typedef map<string, Item> Items;

Item* FindItem(string name)
{
    Items::iterator it = items.find(name);

    if (!it)
        return NULL;

    return it->second;
}

void EnumerateItems()
{
    for (Items::iterator it = items.begin(); it; ++it)
    {
        //...
    }
}

struct test {
   slist_node<test> asc;
   slist_node<test> desc;

   typedef typename list_iterator< slist_node<test>, &test::asc >::type asc_iterator;
   typedef typename list_iterator< slist_node<test>, &test::asc >::type desc_iterator;

   int data;
};

slist< test, test::asc_iterator > asc_list;
slist< test, test::desc_iterator > desc_list;

template< typename Range >
void print ( Range const & r ) {
   for( Range::iterator it = begin( r ); it != end( r ); increment( it ) ) {
      std::cout << it->data << std::endl;
   }
}

template <class T> class ZuPtr
{
    mutable T *_t;
public:
    ZuPtr(T *t):_t(t) {}
    ZuPtr(const ZuPtr &z):_t(z._t) {z._t = 0;}
    ZuPtr &operator =(const ZuPtr &z){_t = z._t; z._t = 0; return *this;}
    ~ZuPtr() {delete _t;}
    T* operator ->(){return _t;}
};

struct Foo
{
    Foo(){printf("[0x%x] Foo\n", this);}
    ~Foo(){printf("[0x%x]~Foo\n", this);}
};

typedef ZuPtr<Foo> FooPtr;

typedef std::vector<FooPtr> FooV; 
typedef std::list<FooPtr> FooL;

O>template <class T> class ZuPtr
O>{
O>    mutable T *_t;
O>public:
O>    ZuPtr(T *t):_t(t) {}
O>    ZuPtr(const ZuPtr &z):_t(z._t) {z._t = 0;}
O>    ZuPtr &operator =(const ZuPtr &z){_t = z._t; z._t = 0; return *this;}
O>    ~ZuPtr() {delete _t;}
O>    T* operator ->(){return _t;}
O>};

O>struct Foo
O>{
O>    Foo(){printf("[0x%x] Foo\n", this);}
O>    ~Foo(){printf("[0x%x]~Foo\n", this);}
O>};

O>typedef ZuPtr<Foo> FooPtr;

O>typedef std::vector<FooPtr> FooV; 
O>typedef std::list<FooPtr> FooL;

UINT CXXXUIntSet::operator []( int nIndex )
{
    ASSERT( nIndex < GetSize() );
    std::set<UINT>* pSet1 = (std::set<UINT>*)m_pData;

    UINT retData = 0;

    if ( m_nNextIndex < 0 )
    {
        *(std::set<UINT>::iterator*)m_pNextPosition = pSet1->begin();
        m_nNextIndex = 0;
    }

    if ( nIndex == m_nNextIndex )
    {
        retData = **(std::set<UINT>::iterator*)m_pNextPosition;
        (*(std::set<UINT>::iterator*)m_pNextPosition)++;
        *(std::set<UINT>::iterator*)m_pNextPosition != pSet1->end() ? m_nNextIndex++ : m_nNextIndex = -1;
    }
    else
    {
        *(std::set<UINT>::iterator*)m_pNextPosition = pSet1->begin();
        m_nNextIndex = 0;
        while ( nIndex >= m_nNextIndex )
        {
            retData = **(std::set<UINT>::iterator*)m_pNextPosition;
            (*(std::set<UINT>::iterator*)m_pNextPosition)++;
            m_nNextIndex++;
        }
    }

    return retData;
}

vector<T> u, v;
....
// переносим задний элемент из u в v

// копированием (дорого)
v.push_back(u.back());
u.pop_back();

// обменом
v.push_back(T());
swap(u.back(), v.back();
u.pop_back();

O>    ZuPtr(const ZuPtr &z):_t(z._t) {z._t = 0;}
O>    ZuPtr &operator =(const ZuPtr &z){_t = z._t; z._t = 0; return *this;}

vector<FooPtr> v;
v.push_back( new Foo () );
{
   FooPtr tmp = v[0]; // захватываем память
} // здесь мы освобождаем память 
v[0]; // здесь имеем v[0] == 0;

Z>>Это мой контейнер, я возложил на него столько обязанностей сколько мне необходимо, это раз

class CXXXUIntSet
{
public:
    CXXXUIntSet();
    CXXXUIntSet( const CXXXUIntSet &set );
    virtual ~CXXXUIntSet();

public:
    CXXXUIntSet& operator =( const CXXXUIntSet &set );
    BOOL operator!=( const CXXXUIntSet &set );
    BOOL operator==( const CXXXUIntSet &set );

public:
    BOOL Add( UINT nElem );
    BOOL Remove( UINT nElem );
    BOOL IsPresent( UINT nElem );
    void RemoveAll();

public:
    int GetCount() const;
    int GetSize() const;

public:
    UINT operator[]( int nIndex );
    CXXXUIntSet Intersection( CXXXUIntSet& set );
    CXXXUIntSet Union( CXXXUIntSet& set );
    CXXXUIntSet Difference( CXXXUIntSet& set );
    CXXXUIntSet SymmetricDifference( CXXXUIntSet& set );

private:
    void* m_pData;
    void* m_pNextPosition;
    int m_nNextIndex;
};