if( (z - y) * (*y - *x) < (*z - *y) * (y - x) ) { ... }

++count_vec[очередноёзначениё % count_vec.size()];

— Отгадай, что такое: черное, волосатое, на дне моря лежит?
— ???
— Подводная лодка.
— ??????
— Бородой накрылась.*

А>>if (m_itSelectedItem != m_pServer->ItemsEnd())
А>>{
А>>  m_pServer->ReleaseItem(m_itSelectedItem);
А>>  m_itSelectedItem = m_pServer->ItemsEnd();
А>>}
А>>

А>>if (m_itSelectedItem != NULL) // NULL-итератор
А>>{
А>>  m_pServer->ReleaseItem(m_itSelectedItem);
А>>  m_itSelectedItem = NULL; // NULL-итератор
А>>}
А>>

      void Client::ReleaseRecentItem()
      {

004014F0   push        esi
004014F1   mov         esi,ecx

        if (m_itRecentItem != m_pServer->ItemsEnd())

004014F3   mov         ecx,dword ptr [esi]
004014F5   mov         eax,dword ptr [esi+4]
004014F8   cmp         eax,dword ptr [ecx+4]
004014FB   je          Client::ReleaseRecentItem+1Dh (0040150d)

        {
          m_pServer->ReleaseItem(m_itRecentItem);

004014FD   mov         edx,eax
004014FF   push        edx
00401500   call        Server::ReleaseItem (004040c0)

          m_itRecentItem = m_pServer->ItemsEnd();

00401505   mov         eax,dword ptr [esi]
00401507   mov         ecx,dword ptr [eax+4]
0040150A   mov         dword ptr [esi+4],ecx
0040150D   pop         esi

        }
      }

0040150E   ret

--- No source file  ------------------------------------------------------------

0040150F   nop

      void Client::ReleaseRecentItem()
      {

004014F0   push        esi
004014F1   mov         esi,ecx

        if (m_itRecentItem != NULL)

004014F3   mov         eax,dword ptr [esi+4]
004014F6   test        eax,eax
004014F8   je          Client::ReleaseRecentItem+19h (00401509)

        {
          m_pServer->ReleaseItem(m_itRecentItem);

004014FA   mov         ecx,dword ptr [esi]
004014FC   push        eax
004014FD   call        Server::ReleaseItem (004040c0)

          m_itRecentItem = NULL;

00401502   mov         dword ptr [esi+4],0
00401509   pop         esi

        }
      }

0040150A   ret

--- No source file  ------------------------------------------------------------

0040150B   nop

• Возможность инициализировать итератор без доступа к контейнеру. Неинициализированный итератор опасен. Если его случайно использовать, то есть риск тихо испортить память.
  
• Улучшение читаемости кода.

template<typename TElem, ...>
class list
{
  ...
  struct Node
  {
    Node* pPrev;
    Node* pNext;
    TElem Elem;
  };
  ...
  class iterator
  {
    Node* m_pNode;

  public:
    iterator()
    {
    }

    // NULL-итератор
    iterator(int NullTag)
    {
      assert(NullTag == 0);
      m_pNode = NULL;
    }

    TElem& operator*() const
    {
      return m_pNode->Elem;
    }

    TElem* operator->() const
    {
      return &m_pNode->Elem;
    }

    iterator& operator--()
    {
      m_pNode = m_pNode->pPrev;
      return *this;
    }

    iterator& operator++()
    {
      m_pNode = m_pNode->pNext;
      return *this;
    }

    iterator operator--(int PostfixTag)
    {
      iterator it = *this;
      operator--();
      return it;
    }

    iterator operator++(int PostfixTag)
    {
      iterator it = *this;
      operator++();
      return it;
    }

    friend bool operator==(iterator it1, iterator it2)
    {
      return it1.m_pNode == it2.m_pNode;
    }

    friend bool operator!=(iterator it1, iterator it2)
    {
      return it1.m_pNode != it2.m_pNode;
    }
  };
  ...
};

list<int>::iterator it1 = NULL; // итератор list-а - класс
assert(it1 == NULL);
assert(!(it1 != NULL));

map<int, int>::iterator it2 = NULL; // итератор map-а - класс
assert(it2 == NULL);
assert(!(it2 != NULL));

• Для vector-а это не нужно (realloc аннулирует указатель на элемент), но можно сделать уже сейчас:
  

  int Index = pElem - &Vec[0];
  vector<...>::iterator itElem = Vec.begin() + Index;
  assert(&*itElem == pElem);

  
  Для vector<bool> нельзя получить указатель на элемент.
  
• Для node-based контейнеров (list, map) итератор — это обёртка над Node*. Адреса pNodе и pElem различаются на константу (смещение Elem в структре Node). Поэтому можно сделать быстрый iterator_from_pointer.
  
• Для deque нельзя получить итератор по указателю на элемент за константное время. deque — это не node-based контейнер, а массив указателей на массивы.
  
• Для hash_map зависит от того, как он сделан. Обычно hash_map содержит массив "вёдер" (bucket). В каждом ведре — список элементов, чьё hash-значение равно индексу ведра. Поэтому индекс ведра можно восстановить по элементу (вычислив hash-значение). Например, в SGI STL (файл stl_hashtable.h):
  

  template <class _Val>
  struct _Hashtable_node
  {
    _Hashtable_node* _M_next;
    _Val _M_val;
  };

  _M_val — это элемент hash-таблицы (для hash_map — pair(const key, data)). _M_next — это указатель на следующий node в ведре. Там же, далее:
  

  template <class _Val, ...>
  struct _Hashtable_iterator {
    typedef hashtable<_Val, ...> _Hashtable;
    typedef _Hashtable_iterator<_Val, ...> iterator;
    ...
    typedef _Hashtable_node<_Val> _Node;
    ...
    typedef _Val& reference;
    ...
    _Node* _M_cur;
    _Hashtable* _M_ht;
    ...
    reference operator*() const { return _M_cur->_M_val; }
    ...
    iterator& operator++();
    ...
  };

  Итератор содержит указатель на hash-таблицу (_M_ht) и указатель на node (_M_cur). Других значений нет. После последнего node-а в ведре нужно перейти к следующему ведру. Итератор восстанавливает индекс ведра по элементу (вычисляя hash-значение):
  

  template <class _Val, ...>
  _Hashtable_iterator<_Val, ...>& _Hashtable_iterator<_Val, ...>::operator++()
  {
    const _Node* __old = _M_cur;
    _M_cur = _M_cur->_M_next;
    if (!_M_cur) {
      size_type __bucket = _M_ht->_M_bkt_num(__old->_M_val);
      while (!_M_cur && ++__bucket < _M_ht->_M_buckets.size())
        _M_cur = _M_ht->_M_buckets[__bucket];
    }
    return *this;
  }

  При переходе к следующему ведру итератор использует некоторые члены hash-таблицы. _M_buckets — это vector<_Node*, ...> (массив вёдер). _M_bkt_num — это функция, вычисляющая hash-значение (обёртка над функциональным объектом _M_hash). Для такой реализации можно сделать быстрый iterator_from_pointer:
  

  template<class _Val, ...>
  class hashtable
  {
    ...
    typedef _Hashtable_node<_Val> _Node;
    ...
    typedef _Hashtable_iterator<_Val, ...> iterator;
    ...
    iterator iterator_from_pointer(_Val* pVal)
    {
      iterator it;
      it._M_ht = this;
      it._M_cur = reinterpret_cast<_Node*>(reinterpret_cast<Byte*>(pVal) - offsetof(_Node, _M_val));
      assert(&it._M_cur->_M_val == pVal);
      return it;
    }
  };

  
  Здесь не нужно восстанавливать индекс ведра, потому что итератор его не хранит (возможно, чтобы при resize-е hash-таблицы существующие итераторы остались в силе). Если бы итератор хранил индекс ведра, я бы добавил строчку:
  

  it._M_bucket = _M_bkt_num(*pVal); // вычислить hash-значение

  
  С натяжкой можно сказать, что это работает за константное время (по крайней мере не зависит от количества элементов в hash-таблице).
  В STLport 4.5.3 то же самое (она основана на SGI STL). Там есть одна интересная деталь: hash-таблица использует что-то вроде vector<void*> для массива вёдер, чтобы уменьшить разбухание (ассемблерного) кода (code bloat).
  Можно не вычислять hash-значение при переходе к следующему ведру, а хранить hash-значения в node-ах. Так делает CMap в MFC 4.2:
  

  template<class KEY, class ARG_KEY, class VALUE, class ARG_VALUE>
  class CMap : public CObject
  {
  protected:
    // Association
    struct CAssoc
    {
      CAssoc* pNext;
      UINT nHashValue;  // needed for efficient iteration
      KEY key;
      VALUE value;
    };
    ...
  };

template <...>
class list ... {
  ...
  size_type size() const {
    size_type __result = distance(begin(), end());
    return __result;
  }
  ...
};

template<...>
void CList<...>::AddHead(CList* pNewList)
{
  ...
  // add a list of same elements to head (maintain order)
  POSITION pos = pNewList->GetTailPosition();
  while (pos != NULL)
    AddHead(pNewList->GetPrev(pos));
}

template<...>
void CList<...>::AddTail(CList* pNewList)
{
  ...
  // add a list of same elements
  POSITION pos = pNewList->GetHeadPosition();
  while (pos != NULL)
    AddTail(pNewList->GetNext(pos));
}

typedef list<Item> ItemList;
ItemList Items;

typedef list<Item, TempAllocator<Item> > ItemList;
ItemList Items;

template<typename TElem, ...>
list<TElem, ...>::~list()
{
  while (!empty())
  {
    int Index = rand() % size();
    iterator it = begin();
    advance(it, Index);
    erase(it);
  }
  // что-нибудь ещё
  ...
}

А>>template<typename TElem>
А>>class MyList : public list<TElem>
А>>{
А>>public:
А>>  typename iterator push_front(const TElem& e)
А>>  {
А>>    list<TElem>::push_front(e);
А>>    return begin();
А>>  }

А>>  typename iterator push_back(const TElem& e)
А>>  {
А>>    list<TElem>::push_back(e);
А>>    typename iterator it = end();
А>>    return --it;
А>>  }
А>>};
А>>

class Item
{
  ...
  explicit Item(const string& Name);
};

class ItemManager
{
public:
  typedef list<Item>::iterator ItemHandle; // ...
  ItemHandle AddItem(const string& Name); // ...
  ...
  list<Item> m_Items;
};

ItemManager::ItemHandle ItemManager::AddItem(const string& Name)
{
  // push_back не возвращает итератор
  return m_Items.insert(m_Items.end(), Item(Name));
}

A_A>class A { int n; };

A_A>list<A> list_of_A;
A_A>list<A>::iterator it = list_of_A.push_back (A ()); // если здесь вылетело исключение о нехватки памяти, как
A_A>                                                   // определить произошло это при вставке элемента в контейнер 
A_A>                                                   // или при копировании итератора? И в каком состоянии
A_A>                                                   // теперь находится list_of_A, был ли в него добавлен
A_A>                                                   // элемент?

A_A>

// заголовочный файл <string>
#ifdef _MT // = multi thread
// многопоточная реализация basic_string-а (не считает ссылки)
#else
// однопоточная реализация basic_string-а (считает ссылки)
#endif

• С подсчётом ссылок.
  
• Без подсчёта ссылок, vector-стиль. Реализация может использовать фиксированный буфер для коротких последовательностей, но для длинных она динамически запрашивает память. При этом неявное копирование дорого и может бросить исключение (если не хватит памяти). Это не очень хорошо, если string — элемент STL-контейнера (например, list<string>). Страуструп в книге "Язык программирования C++" (третье издание) в разделе 17.1.4 ("Требования к элементам" (STL-контейнеров)) пишет по этому поводу:
  

  Например, операция копирования, генерирующая исключения, может оставить какой-нибудь элемент лишь частично скопированным. Она может оставить даже сам контейнер в состоянии, которое потом принесёт неприятности. Такие операции копирования сами по себе являются плохо спроектированными (§ 14.4.6.1).

  То есть желательно, чтобы неявное копирование либо было запрещено, либо было дёшево. Дорогое неявное копирование подозрительно.

А>>string Text = "abc";
А>>assert(Text[3] == '\0');
А>>

A_A>Используйте правильную STL

template<typename TChar, ...>
class basic_string
{
  ...
  // можно читать завершающий '\0'
  TChar operator[](size_type Index) const
  {
    assert(Index <= length());
    ...
  }

  // нельзя писать в завершающий '\0'
  void set_at(size_type Index, TChar c)
  {
    assert(Index < length());
    ...
  }
  ...
};

А>>string Text;
А>>int Len = ::GetWindowTextLength(hEditControl);
А>>if (Len != 0)
А>>{
А>>  Text.resize(Len);
А>>  ::GetWindowText(hEditControl, &Text[0], Len + 1);
А>>}
А>>

string Text;
int Len = ::GetWindowTextLength(hEditControl);
if (Len != 0)
{
  vector<char> Buf(Len); // программист забыл '+ 1' для завершающего '\0'
  ::GetWindowText(hEditControl, &Buf[0], Len + 1);
  Text.assign(&Buf[0], Len);
}

• Собственно, сам string.
  
• ostringstream.

shared_ptr<vector<some> >

vector<shared_ptr<some> >

E>А для написания хорошего компилятора нужен довольно большой НИИ

E>Хватит?

There are only two kinds of languages: the ones people complain about and the ones nobody uses

Существует два типа языков: языки, которые все ругают, и языки, которые никто не использует