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

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

А теперь немного об STL
"Any road followed precisely to it's end leads precisely nowhere"

Dune, Bene Gesserit saying

Не так давно я узнал, когда именно г-ну Степанову пришла идея библиотеки STL — когда он находился в отделении интенсивной терапии (после отравления рыбой) в, как он сам написал, "delirium state", по-просту — в состоянии БРЕДА.

Этот малеьнкий фактик очень удачно вписался в мои собственные представления об STL и самом языка С++. В предельно короткой форме: STL — это просто болезненный бред.

Бред относится к авторам библиотеки, а болезненный — это состояние ее пользователей.

Уже с самого начала STL производит впечатление чего-то монстроидального и совершенно непонятного. Это нагромождение template'd классов (яязык не поворачивается называть их объектами, это просто АТД-переростки) с огромным количество параметров и морем методов с весьма непонятными названиями.
.................................

template<int standardBufferSize>
class CAutoBuffer {
public:
    CAutoBuffer( int startBufferSize = 0 ) : ptr( buffer ), size( 0 ), allocSize( standardBufferSize ) 
        { Reserv( startBufferSize, false ); }
    ~CAutoBuffer() { freeBuffer( ptr ); ptr = buffer; allocSize = standardBufferSize; size = 0; } 
    
    void* GetBuffer() { return ptr; }
    void* Reserve( int bufferSize, bool keepContent = false )
    {
       assert( bufferSize >= 0 );
       if( bufferSize <= allocSize ) {
           size = bufferSize;
           return ptr;
       }
       int realNewSize = max( correctSize( bufferSize ), correctSize( allocSize * 3 / 2 ), granula ); 
       char* newBuffer = new char[realNewSize];
       if( keepContent ) 
            memcpy( newBuffer, ptr, size );
       freeBuffer( ptr );
       ptr = newBuffer;
       allocSize = realNewSize;
       size = bufferSize;
       return ptr;
    }
    int GetBufferSize() { return size; }
    
private:
    char* ptr;
    int size;
    int allocSize; 
    char buffer[standardBufferSize];
    enum { granula = 16 };
    
    void freeBuffer( char* p ) 
    {
        if( p != buffer )
             delete[] p;
    }
    static int correctSize( int newSize ) { return ( newSize + granula - 1 ) / granula * granula; }
};

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

for_each(container.begin(), container.end(), clear_func);
container.clear();

container.clear(clear_func);

Elem *p, *last; // если p == last делаем полный круг
for (bool ok = true; ok; p = next(p)) 
{
   ok = p != last;
   // .....
}

struct Point
 {
  int x,y; // здесь вряд ли беззнаковый тип уместен
 };

T>D:\Lang\test>g++ -o din_arr din_arr.cpp
T>D:\Lang\test>din_arr.exe 10
T>0, 1, 2, 3, 4, 5, 6, 7, 8, 9
T>

MS VC++ 8
Error 1 error C2057: expected constant expression f:\porno\zoofilia\hard\test\test\test.cpp 15

В STL фактически существует только одна функция-метод, о которой в стандарте явным образом сказано, что она должна генерировать исключение [1-23.1/13]. Речь идет о функции at(), реализующей надежный доступ к элементу вектора или дека. Функция должна генерировать стандартное исключение out_of_range, если аргумент превышает size(). В остальных случаях стандарт требует лишь стандартных исключений вроде bad_alloc при нехватке памяти, или исключений, возникающих при пользовательских операциях. Стандартная библиотека обеспечивает базовую гарантию безопасности исключений: возникновение исключений в стандартной библиотеке не приводит к утечке ресурсов и нарушению контейнерных инвариантов. Более того, многие операции с контейнерами либо вовсе не генерируют исключений, либо обеспечивают транзакционную безопасность: если во время выполнения операции возникнет исключение, то произойдет откат — возврат к состоянию контейнера до начала выполнения операции.
Большинство операций с контейнерами в отношении надежности выполнения можно разделить на 4 класса:

• не генерирует исключений;
  
• либо завершается успешно, либо не вносит изменений;
  
• не генерирует исключений, если они не генерируются при копировании или присваивании элементов (аналогично — при сравнении);
  
• либо завершается успешно, либо не вносит изменений, если при копировании или присваивании не генерируется исключений.

Таким образом, если пользователь будет аккуратно программировать свои классы, уделяя внимание проблемам возникновения исключений, то стандартная библиотека практически гарантирует безопасность обработки элементов в контейнере.
Если с точки зрения безопасности рассматривать контейнеры, то библиотека гарантирует две вещи:

1. для списка, множества (мультимножества), отображения (мультиотображения) гарантируется транзакционная безопасность: удаление элемента никогда не завершается неудачей; неудачная попытка вставки оставляет контейнер в прежнем состоянии;
2. для вектора и дека гарантируется транзакционная безопасность операций на концах контейнера; если конструктор копирования и операция присваивания элемента не генерируют исключений, то любые операции с этими элементами либо завершаются успешно, либо не вносят изменений.

Множество и отображения гарантируют только одноэлементную транзакционную безопасность вставки (то есть, либо завершается успешно, либо не вносит изменений), а вот список обеспечивает откат неудачной вставки нескольких элементов. Более того, любые операции (кроме remove(), remove_if(), sort(), merge() и unique()) либо выполняются успешно, либо не вносят изменений. Таким образом, если вам требуется надежный контейнер, используйте список.

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

kan>"if(cont.size())", "если обладает размером"

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

// не меняет Elements
Cont::iterator chooseSomeElement(Cont& Elements)
{
  // вся работа здесь
  ...
}

// обёртка над не-const chooseSomeElement
Cont::const_iterator chooseSomeElement(const Cont& Elements)
{
  // временно убрать константность
  return chooseSomeElement(const_cast<Cont&>(Elements));
  // iterator неявно преобразуется в const_iterator
}

void SomeClass::BigFunc()
{
  ...
  for (примерно 1000 раз)
  {
    ...
    SmallFunc();
    ...
  }
  ...
}

void SomeClass::SmallFunc()
{
  ...
  какой-то указатель = alloca(примерно 1000 байт);
  ...
}

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

std::copy(
    boost::counting_iterator<int>(0), boost::counting_iterator<int>(N),
    std::back_inserter(array));

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

    char buffer[standardBufferSize];

    CAutoBuffer<CommonCaseBufferSize> bufferHolder;
    void* const buffer = bufferHolder.Reserve( currentCaseBufferSize );
    //  Тут используем буфер, как нам надо...

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)