for(vector<int>::iterator it = array.begin();it!=array.end();++it)
{
 //
}

for(int i=0;i<N;++i)
{
   array[i] = i;
 //
}

template<class U>
 iterator find(const U&);

template<class U>
 bool erase(const U&);

M>for(vector<int>::iterator it = array.begin();it!=array.end();++it)
M>{
M> //
M>}
M>

M>for(int i=0;i<N;++i)
M>{
M>   array[i] = i;
M> //
M>}
M>

for(int i=0; i!=array.size(); ++i)
{
 //
}

size_type size() const
{    // return length of sequence
    return (_Myfirst == 0 ? 0 : _Mylast - _Myfirst);
}

For many containers, such as vector and deque, size is O(1)

_>принимаются только ответы с аргументацией

class File
{
  // неявное копирование запрещено
  File(const File& s);
  File& operator=(const File& s);
public:
  struct Params
  {
    string Path;
    int ShareMode;
  };
  explicit File(const Params& p);
private:
  ...
};

class FileList
{
  // неявное копирование запрещено
  FileList(const FileList& s);
  FileList& operator=(const FileList& s);
public:
  void AddFile(const string& Path, int ShareMode);
private:
  list<File> m_Files;
};

void FileList::AddFile(const string& Path, int ShareMode)
{
  File::Params p;
  p.Path = Path;
  p.ShareMode = ShareMode;
  m_Files.push_back(p);
}

void PrintItems(const list<string>& Items)
{
  for (list<string>::const_iterator it = Items.begin(); it != Items.end(); ++it)
  {
    cout << *it << '\n';
  }
}

class POINT3D
{
private:
   double getxyz(int i);
   void   setxyz(int i,double v);
protected:

public:
    double x,y,z;
   POINT3D():x(0),y(0),z(0){};
   __property double xyz[int] = { read = getxyz , write = setxyz };
};
typedef std ::vector<POINT3D,std::allocator<POINT3D> >LINE;
typedef std ::vector<LINE,std::allocator<LINE> >SURF;
...
 void __fastcall TMyPanel::Mesh    (SURF matr)
{
     for (int i = 0; i<int(matr.size()); i++)
        {
         for (int j = 1; j<int(matr[i].size()); j++)
          {
         glBegin(GL_LINES);
         glVertex3d(matr[i][j-1].x,matr[i][j-1].y,matr[i][j-1].z);
         glVertex3d(matr[i][j].x,matr[i][j].y,matr[i][j].z);
         glEnd();
          }
        }
}

class CObject
{
  ...
  // Disable the copy constructor and assignment by default so you will get
  //   compiler errors instead of unexpected behaviour if you pass objects
  //   by value or assign objects.
protected:
  CObject();
private:
  CObject(const CObject& objectSrc);              // no implementation
  void operator=(const CObject& objectSrc);       // no implementation
  ...
};

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-итератор
}

• Быстрее читается.
  
• Быстрее пишется.
  
• Быстрее работает.
  
• Порождает меньше машинных инструкций.

template<typename TElem, ...>
class vector
{
  ...
  typedef TElem* iterator;
  ...
};

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

// abstract iteration position
struct __POSITION { };
typedef __POSITION* POSITION;

pCmdUI->Enable(pFrame->m_UndoRedo.GetPos() < pFrame->mUndoRedo.buffer.GetSize() - 1);

pCmdUI->Enable(pFrame->m_UndoRedo.GetPos() < (int) pFrame->mUndoRedo.buffer.size() - 1);

template<...>
void hash_map::resize(size_type s)
{
  ...
  if (no_of_erased) {
    for (size_type i = v.size() - 1; 0 <= i; i--)
      if (v[i].erased) {
        v.erase(&v[i]);
        if (--no_of_erased == 0) break;
      }
  }
  ...
}

Типы unsigned (без знака) идеально подходят для задач, в которых память интерпретируется как массив битов. Использование unsigned вместо int с целью заработать лишний бит для представления положительных целых почти всегда оказывается неудачным решением. Использование же объявления unsigned для гарантии того, что целое будет неотрицательным, почти никогда не сработает из-за правил неявного преобразования типов (§ В.6.1, § В.6.2.1).

[18] Избегайте беззнаковой арифметики; § 4.4.
[19] С подозрением относитесь к преобразованиям из signed в unsigned и из unsigned в signed; § В.6.2.6.

• Указать allocator с size_type = int.
  
• Сделать обёртку над контейнером:
  

  template<typename TElem>
  class MyList : public list<TElem>
  {
  public:
    int size() const { return list<TElem>::size(); }
  };

  
  
• Всё время оборачивать "Container.size()" приведением к int.

template<...>
class CArray : public CObject
{
  ...
  int GetSize() const;
  ...
  // overloaded operator helpers
  TYPE operator[](int nIndex) const;
  TYPE& operator[](int nIndex);
  ...
};

template<...>
class CList : public CObject
{
  ...
  // count of elements
  int GetCount() const;
  ...
};

template<...>
class CMap : public CObject
{
  ...
  // number of elements
  int GetCount() const;
  ...
};

class CString
{
  ...
  // get data length
  int GetLength() const;
  ...
  // return single character at zero-based index
  TCHAR operator[](int nIndex) const;
  ...
};

class Item
{
public:
  void AddRef();
  void Release();
  string Name() const;
private:
  friend class ItemManager;
  ItemManager* m_pManager;
  int m_Refs;
  string m_Name;
  Item(ItemManager* pManager, const string& Name);
};

class ItemManager
{
public:
  Item* AddItem(const string& Name);
private:
  friend class Item;
  list<Item> m_Items;
  void RemoveItem(Item* pItem);
};

Item* ItemManager::AddItem(const string& Name)
{
  m_Items.push_back(Item(this, Name));
  return &m_Items.back();
}

void ItemManager::RemoveItem(Item* pItem)
{
  // получить итератор по указателю на элемент списка
  list<Item>::iterator it = m_Items.begin();
  while (&*it != pItem)
  {
    ++it;
  }
  m_Items.erase(it);
}

Item::Item(ItemManager* pManager, const string& Name) :
  m_pManager(pManager),
  m_Refs(1),
  m_Name(Name)
{
}

void Item::AddRef()
{
  m_Refs++;
}

void Item::Release()
{
  m_Refs--;
  if (m_Refs == 0)
  {
    m_pManager->RemoveItem(this);
  }
}

template<typename TElem, ...>
class vector
{
  ...
  typedef TElem* iterator;
  ...
  static iterator iterator_from_pointer(TElem* pElem)
  {
    return pElem;
  }
  ...
};

template<typename TElem, ...>
class list
{
  ...
  struct Node
  {
    Node* pPrev;
    Node* pNext;
    TElem Elem;
  };
  ...
  class iterator
  {
    Node* m_pNode;
    ...
  };
  ...
  static iterator iterator_from_pointer(TElem* pElem)
  {
    iterator it;
    it.m_pNode = reinterpret_cast<Node*>(reinterpret_cast<Byte*>(pElem) - offsetof(Node, Elem));
    assert(&it.m_pNode->Elem == pElem);
    return it;
  }
  ...
};

template<typename TElem>
class MyList : public list<TElem>
{
public:
  bool has_elems() const { return !empty(); }
};

Одобрен также класс динамического массива dynarray [Stal, 1993], шаблон класса bits<N> для битовых множеств фиксированного размера, класс bitstring для битовых множеств с изменяемым размером. Кроме того, комитет принял классы комплексных чисел (предшественник — первоначальный класс complex, см. раздел 3.3), обсуждается вопрос, следует ли принять класс вектора для поддержки численных расчётов и научных приложений. О наборе стандартных классов, их спецификациях и даже названиях всё ещё ведутся оживлённые споры.

...
Разумеется, STL содержит классы для отображений и списков и включает в качестве частных случаев вышеупомянутые классы dynarray, bits и bitstring. Кроме того, комитет одобрил классы векторов для поддержки численных и научных расчётов, приняв за основу предложение Кена Баджа из Sandia Labs.

int main(int argc, char* argv[])
{
  ...
}

template<class TYPE, class ARG_TYPE>
AFX_INLINE int CList<TYPE, ARG_TYPE>::GetCount() const
  { return m_nCount; }

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;
  }
};

  // add before head or after tail
  POSITION AddHead(ARG_TYPE newElement);
  POSITION AddTail(ARG_TYPE newElement);

class ImmutString : public string
{
public:
  ImmutString(const char s[]) :
    string(s)
  {
  }

  ImmutString(const char s[], int L) :
    string(s, L)
  {
  }

  const_iterator begin() const
  {
    return string::begin();
  }

  const_iterator end() const
  {
    return string::end();
  }

  const_reverse_iterator rbegin() const
  {
    return string::rbegin();
  }

  const_reverse_iterator rend() const
  {
    return string::rend();
  }

  char operator[](int Index) const
  {
    return string::operator[](Index);
  }

  char at(int Index) const
  {
    return string::at(Index);
  }
};

class CString
{
  ...
  // return single character at zero-based index
  TCHAR operator[](int nIndex) const;
  // set a single character at zero-based index
  void SetAt(int nIndex, TCHAR ch);  
  ...
};

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

bool IsValidMethodName_CStyle(const char pText[])
{
  int p = 0;
  // Имя1 не может начинаться с цифры
  if (IsLetterOrUnderscore(pText[p])) p++; else return false;
  while (IsLetterOrUnderscoreOrDigit(pText[p])) p++;
  if (pText[p] == ':') p++; else return false;
  if (pText[p] == ':') p++; else return false;
  // Имя2 не может начинаться с цифры
  if (IsLetterOrUnderscore(pText[p])) p++; else return false;
  while (IsLetterOrUnderscoreOrDigit(pText[p])) p++;
  return pText[p] == '\0';
}

bool IsValidMethodName_STL(const string& Text)
{
  int p = 0;
  // Имя1 не может начинаться с цифры
  if ((p < Text.length()) && IsLetterOrUnderscore(Text[p])) p++; else return false;
  while ((p < Text.length()) && IsLetterOrUnderscoreOrDigit(Text[p])) p++;
  if ((p < Text.length()) && (Text[p] == ':')) p++; else return false;
  if ((p < Text.length()) && (Text[p] == ':')) p++; else return false;
  // Имя2 не может начинаться с цифры
  if ((p < Text.length()) && IsLetterOrUnderscore(Text[p])) p++; else return false;
  while ((p < Text.length()) && IsLetterOrUnderscoreOrDigit(Text[p])) p++;
  return p == Text.length();
}

_AFX_INLINE TCHAR CString::operator[](int nIndex) const
{
  // same as GetAt
  ASSERT(nIndex >= 0);
  ASSERT(nIndex < GetData()->nDataLength);
  return m_pchData[nIndex];
}

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)
{
  Text.resize(Len);
  ::GetWindowText(hEditControl, const_cast<char*>(Text.c_str()), 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);
}

//#define GENERIC_STL_IMPL
//#define REALISTIC_STL_IMPL

class StringBuf
{
  // неявное копирование запрещено
  StringBuf(const StringBuf& s);
  StringBuf& operator=(const StringBuf& s);
public:
  StringBuf(string* pTarget, int Len);
  char* Chars();
  void Commit();
private:
#ifdef GENERIC_STL_IMPL
  string* m_pTarget;
  vector<char> m_Buf;
#endif
#ifdef REALISTIC_STL_IMPL
  string* m_pTarget;
#endif
};

#ifdef GENERIC_STL_IMPL

StringBuf::StringBuf(string* pTarget, int Len)
{
  assert(pTarget != NULL);
  assert(pTarget->empty()); // строим string с нуля
  assert(Len > 0);
  m_pTarget = pTarget;
  m_Buf.resize(Len + 1); // может понадобиться место для завершающего '\0'
}

char* StringBuf::Chars()
{
  assert(m_pTarget != NULL); // ещё не было Commit
  return &m_Buf[0];
}

void StringBuf::Commit()
{
  assert(m_pTarget != NULL); // ещё не было Commit
  m_pTarget->assign(&m_Buf[0], m_Buf.size() - 1); // без завершающего '\0'
  m_pTarget = NULL;
  m_Buf.clear(); // досрочно освободить память
}

#endif // GENERIC_STL_IMPL

#ifdef REALISTIC_STL_IMPL

StringBuf::StringBuf(string* pTarget, int Len)
{
  assert(pTarget != NULL);
  assert(pTarget->empty()); // строим string с нуля
  assert(Len > 0);
  m_pTarget = pTarget;
  m_pTarget->resize(Len);
}

char* StringBuf::Chars()
{
  assert(m_pTarget != NULL); // ещё не было Commit
  return const_cast<char*>(m_pTarget->c_str());
}

void StringBuf::Commit()
{
  assert(m_pTarget != NULL); // ещё не было Commit
  m_pTarget = NULL;
}

#endif // REALISTIC_STL_IMPL

string Text;
int Len = ::GetWindowTextLength(hEditControl);
if (Len != 0)
{
  StringBuf Buf(&Text, Len);
  ::GetWindowText(hEditControl, Buf.Chars(), Len + 1);
  Buf.Commit();
}

CString Text;
int Len = ::GetWindowTextLength(hEditControl);
if (Len != 0)
{
  char* pBuf = Text.GetBufferSetLength(Len);
  ::GetWindowText(hEditControl, pBuf, Len + 1);
  Text.ReleaseBuffer();
}

struct ConcatString
{
  const char* pChars;
  int Len;

  ConcatString(const string& s)
  {
    pChars = s.c_str();
    Len = s.length();
  }

  // для строковых литералов
  ConcatString(const char s[])
  {
    pChars = s;
    Len = strlen(s);
  }
};

string DoConcat(const ConcatString pStrings[], int NumStrings)
{
  assert(NumStrings > 0);
  int TotalLen = 0;
  for (int i = 0; i < NumStrings; i++)
  {
    assert(pStrings[i].Len >= 0);
    TotalLen += pStrings[i].Len;
  }
  string Total;
  if (TotalLen != 0)
  {
    StringBuf Buf(&Total, TotalLen);
    char* pTotIter = Buf.Chars();
    for (int i = 0; i < NumStrings; i++)
    {
      ConcatString s = pStrings[i];
      if (s.Len != 0)
      {
        memcpy(pTotIter, s.pChars, s.Len * sizeof(char));
        pTotIter += s.Len;
      }
    }
    Buf.Commit();
  }
  return Total;
}

string Concat(ConcatString s1, ConcatString s2)
{
  const ConcatString Strings[] = { s1, s2 };
  return DoConcat(Strings, 2);
}

string Concat(ConcatString s1, ConcatString s2, ConcatString s3)
{
  const ConcatString Strings[] = { s1, s2, s3 };
  return DoConcat(Strings, 3);
}

// и так далее

string DirPath = "C:\\Projects";
string FileName = "Notes.txt";
string FilePath = Concat(DirPath, "\\", FileName);

for(i = 0, j = vec.size()-1; i < j; i++)
{
  // перебираем элементы парами, например для вычисления расстояния м-ду соседними
    vec[i]; vec[i+1];
}

typedef std::vector<X> Cont;
Cont cont;
Cont::const_iterator i = cont.end(); // decltype(i) = X*? Вполне возможно... или уже нет?
assert(i == std::null_iter);
--i; // и как?
++i; // и как?
assert(i == std::null_iter);

int index = getIndex();
X& ref = vec[index % vec.size()]; // oops!

bool IsValidMethodName_STL(const string& Text)
{
  int p = 0;
  ... ++p ... p++ ... if(2 * 2 == 5) p += 14; ...
  return p == Text.length();
}

template <class II>
bool IsValidMethodName_RealStlStyle(II first, II last)
{
  II p = first;
  ... ++p ... p++ ... if(2 * 2 == 5) p += 14; ...
  return p == last;
}

Cont cont = makeContainer();
Cont::const_iterator iter = chooseSomeElement(cont); // chooseSomeElement берёт на вход const Cont&, что логично, и 
может вернуть только const_iterator
Cont::iterator nonconst_iter = cont.make_nonconst(iter);// Вот такое хочу!
cont.erase(nonconst_iter);// иначе, например, такое не сделать. :(

А>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-итератор
А>}
А>

А>
• Быстрее читается.

А>
• Быстрее пишется.

А>
• Быстрее работает.
  А>
• Порождает меньше машинных инструкций.

А>template<typename TElem, ...>
А>class vector
А>{
А>  ...
А>  typedef TElem* iterator;
А>  ...
А>};

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

А>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 A { int n; };

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

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

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

RO>typedef std::vector<X> Cont;
RO>Cont cont;
RO>Cont::const_iterator i = cont.end(); // decltype(i) = X*? Вполне возможно... или уже нет?
RO>assert(i == std::null_iter);
RO>--i; // и как?
RO>++i; // и как?
RO>assert(i == std::null_iter);
RO>

• end-итератор используется в паре с begin-итератором, чтобы указать алгоритму входную последовательность. Алгоритм работает с полу-интервалом [begin, end).
  
• NULL-итератор используется, чтобы ссылаться "в никуда" (как и NULL-указатель). Его нельзя разыменовывать (*, ->), нельзя продвигать на предыдущий/следующий элемент (--/++); можно только сравнивать с другими итераторами (==, !=).

RO>int index = getIndex();
RO>X& ref = vec[index % vec.size()]; // oops!
RO>

RO>Я бы посмотрел на реализацию сего для unordered_map Без грязных хаков не обойтись, ты и сам привел примеры. И для чего это? Кому надо, выдаст наружу итераторы (typedef Cont::iterator ObjId; ObjId getSomeObject() {})

class Item
{
public:
  string Name() const;
private:
  friend class ItemManager;
  int m_Refs;
  string m_Name;
  explicit Item(const string& Name);
};

class ItemManager
{
public:
  typedef list<Item>::iterator ItemHandle; // Вы назвали 'ObjId'
  ItemHandle AddItem(const string& Name); // Вы назвали 'getSomeObject'
  void AddRefItem(ItemHandle hItem);
  void ReleaseItem(ItemHandle hItem);
private:
  list<Item> m_Items;
};

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

void ItemManager::AddRefItem(ItemHandle hItem)
{
  hItem->m_Refs++;
}

void ItemManager::ReleaseItem(ItemHandle hItem)
{
  hItem->m_Refs--;
  if (hItem->m_Refs == 0)
  {
    m_Items.erase(hItem);
  }
}

Item::Item(const string& Name) :
  m_Refs(1),
  m_Name(Name)
{
}

class Item
{
  // неявное копирование запрещено
  Item(const Item& s);
  Item& operator=(const Item& s);
public:
  void AddRef();
  void Release();
  string Name() const;
private:
  friend class ItemManager;
  ItemManager* m_pManager;
  Item* m_pPrev;
  Item* m_pNext;
  int m_Refs;
  string m_Name;
  Item(ItemManager* pManager, const string& Name);
};

class ItemManager
{
  // неявное копирование запрещено
  ItemManager(const ItemManager& s);
  ItemManager& operator=(const ItemManager& s);
public:
  ItemManager();
  ~ItemManager();
  Item* AddItem(const string& Name);
private:
  friend class Item;
  Item* m_pItemsHead;
  Item* m_pItemsTail;
  void RemoveItem(Item* pItem);
};

ItemManager::ItemManager() :
  m_pItemsHead(NULL),
  m_pItemsTail(NULL)
{
}

ItemManager::~ItemManager()
{
  Item* pPrev;
  for (Item* i = m_pItemsTail; i != NULL; i = pPrev)
  {
    pPrev = i->m_pPrev;
    delete i;
  }
}

Item* ItemManager::AddItem(const string& Name)
{
  Item* pItem = new Item(this, Name);
  // добавить *pItem в конец списка
  pItem->m_pPrev = m_pItemsTail;
  pItem->m_pNext = NULL;
  if (m_pItemsTail != NULL)
  {
    assert(m_pItemsTail->m_pNext == NULL);
    m_pItemsTail->m_pNext = pItem;
  }
  else
  {
    assert(m_pItemsHead == NULL);
    m_pItemsHead = pItem;
  }
  m_pItemsTail = pItem;
  return pItem;
}

// работает за константное время
void ItemManager::RemoveItem(Item* pItem)
{
  Item* pPrev = pItem->m_pPrev;
  Item* pNext = pItem->m_pNext;
  if (pPrev != NULL)
  {
    assert(pPrev->m_pNext == pItem);
    pPrev->m_pNext = pNext;
  }
  else
  {
    assert(m_pItemsHead == pItem);
    m_pItemsHead = pNext;
  }
  if (pNext != NULL)
  {
    assert(pNext->m_pPrev == pItem);
    pNext->m_pPrev = pPrev;
  }
  else
  {
    assert(m_pItemsTail == pItem);
    m_pItemsTail = pPrev;
  }
  delete pItem;
}

Item::Item(ItemManager* pManager, const string& Name) :
  m_pManager(pManager),
  m_Refs(1),
  m_Name(Name)
{
}

void Item::AddRef()
{
  m_Refs++;
}

void Item::Release()
{
  m_Refs--;
  if (m_Refs == 0)
  {
    m_pManager->RemoveItem(this);
  }
}

template<typename TElem, ...>
class vector
{
  ...
  typedef TElem* iterator;
  typedef const TElem* const_iterator;
  ...
  static iterator remove_const(const_iterator cit)
  {
    return const_cast<TElem*>(cit);
  }
  ...
};

template<typename TElem, ...>
class list
{
  ...
  struct Node
  {
    Node* pPrev;
    Node* pNext;
    TElem Elem;
  };
  ...
  class const_iterator
  {
    const Node* m_pNode;
    ...
  };
  ...
  class iterator
  {
    Node* m_pNode;
    ...
  };
  ...
  static iterator remove_const(const_iterator cit)
  {
    iterator it;
    it.m_pNode = const_cast<Node*>(cit.m_pNode);
    return it;
  }
  ...
};

RO>если еще учесть std::tr1::array = boost::array, то вообще весело станет

RO>я всегда думал, что 'argument values'

The name of the variable argv stands for "argument vector".

string CommandLineParam = "-help";
bool IsSwitch = false;
if (CommandLineParam[0] == '-')
{
  IsSwitch = true;
}
string Copy = CommandLineParam; // дорогое копирование (deep)
assert(Copy.c_str() != CommandLineParam.c_str()); // разные буферы

CString CommandLineParam = "-help";
bool IsSwitch = false;
if (CommandLineParam[0] == '-')
{
  IsSwitch = true;
}
CString Copy = CommandLineParam; // дешёвое копирование (shallow)
assert(static_cast<const char*>(Copy) == static_cast<const char*>(CommandLineParam)); // общий буфер

string FilePath = "C:/Projects/Notes.txt";
string::size_type SearchBegin = 0; // да, size_t
string::size_type SlashPos; // опять size_t
while ((SlashPos = FilePath.find('/', SearchBegin)) != string::npos)
{
  FilePath[SlashPos] = '\\';
  SearchBegin = SlashPos + 1;
}
assert(FilePath == "C:\\Projects\\Notes.txt");
string Copy = FilePath; // дорогое копирование (deep)
assert(Copy.c_str() != FilePath.c_str()); // разные буферы

CString FilePath = "C:/Projects/Notes.txt";
int SearchBegin = 0;
int SlashPos;
while ((SlashPos = FilePath.Find('/', SearchBegin)) != -1)
{
  FilePath.SetAt(SlashPos, '\\');
  SearchBegin = SlashPos + 1;
}
assert(FilePath == "C:\\Projects\\Notes.txt");
CString Copy = FilePath; // дешёвое копирование (shallow)
assert(static_cast<const char*>(Copy) == static_cast<const char*>(FilePath)); // общий буфер

RO>bool IsValidMethodName_STL(const string& Text)
RO>{
RO>  int p = 0;
RO>  ... ++p ... p++ ... if(2 * 2 == 5) p += 14; ...
RO>  return p == Text.length();
RO>}
RO>

RO>template <class II>
RO>bool IsValidMethodName_RealStlStyle(II first, II last)
RO>{
RO>  II p = first;
RO>  ... ++p ... p++ ... if(2 * 2 == 5) p += 14; ...
RO>  return p == last;
RO>}
RO>

DirPath + "\\" + FileName

Concat(DirPath, "\\", FileName)