Создан стек

/*----------------------------------------------------------------------------*/
/*                                 6y6yka Engine                              */
/*----------------------------------------------------------------------------*/
#ifndef _B_STACK_H_
#define _B_STACK_H_
/*----------------------------------------------------------------------------*/
#include <cstring>
#include <cassert>
/*----------------------------------------------------------------------------*/
/* класс bStack                                                               */
/* описание:                                                                  */
/*     реализация структуры типа стек                                         */
/* методы:                                                                    */
/*     Push    помещает данные в стек                                         */
/*     Pop     извлекает данные из стека                                      */
/*     Leangth возвращает количество элементов                                */
/*     Size    возвращает объем занимаемой памяти                             */
/*     Resize  изменяет объем занимаемой памяти                               */
/*----------------------------------------------------------------------------*/
template <typename bStackType>
class bStack
{
private:
  bStackType *data;
  int         leangth;
  int         alloced;
  static const int default_size = 1;     // начальное количество элементов

  bStack(const bStack &);                // запрещаем копирование
  bStack &operator =(const bStack &);
public:
  bStack();
  ~bStack();

  void        Push(const bStackType &item);
  bStackType &Pop();

  int         Leangth() const;
  int         Size()    const;
  int         Resize(const int new_size);
};
/*----------------------------------------------------------------------------*/
/* bStack<bStackType>::bStack                                                 */
/*----------------------------------------------------------------------------*/
template <typename bStackType>
inline bStack<bStackType>::bStack()
{
  data = 0;
  leangth = alloced = 0;
}
/*----------------------------------------------------------------------------*/
/* bStack<bStackType>::~bStack                                                 */
/*----------------------------------------------------------------------------*/
template <typename bStackType>
inline bStack<bStackType>::~bStack()
{
  delete[] data;
}
/*----------------------------------------------------------------------------*/
/* bStack<bStackType>::Push                                                   */
/* описание:                                                                  */
/*     помещает новый элемент в стек                                          */
/* аргументы:                                                                 */
/*     item    ссылка на новый элемент                                        */
/*----------------------------------------------------------------------------*/
template <typename bStackType>
inline void bStack<bStackType>::Push(const bStackType &item)
{
  if(!(alloced - leangth))
    if(data)
      Resize(alloced * 2);
    else
      data = new bStackType[alloced = default_size];
  
  data[leangth++] = item;
}
/*----------------------------------------------------------------------------*/
/* bStack<bStackType>::Pop                                                    */
/* описание:                                                                  */
/*     извлекает элемент с верхушки стека                                     */
/* возвращает:                                                                */
/*     ссылку на извлеченный элемент                                          */
/*----------------------------------------------------------------------------*/
template <typename bStackType>
inline bStackType &bStack<bStackType>::Pop()
{
  assert(leangth);           // нельзя лазать ниже дна
  return data[--leangth];
}
/*----------------------------------------------------------------------------*/
/* bStack<bStackType>::Leangth                                                */
/* описание:                                                                  */
/*     возвращает количество элементов в стеке                                */
/*----------------------------------------------------------------------------*/
template <typename bStackType>
inline int bStack<bStackType>::Leangth() const
{
  return leangth;
}
/*----------------------------------------------------------------------------*/
/* bStack<bStackType>::Size                                                   */
/* описание:                                                                  */
/*     возвращает максимальное количество элементов                           */
/*----------------------------------------------------------------------------*/
template <typename bStackType>
inline int bStack<bStackType>::Size() const
{
  return alloced;
}
/*----------------------------------------------------------------------------*/
/* bStack<bStackType>::Resize                                                 */
/* описание:                                                                  */
/*     увеличивает максимально количества элементов                           */
/* аргументы:                                                                 */
/*     new_size    новый размер в итемах. не должен быть меньше старого       */
/* возвращает:                                                                */
/*     новый размер                                                           */
/*----------------------------------------------------------------------------*/
template <typename bStackType>
inline int bStack<bStackType>::Resize(const int new_size)
{
  if(new_size < alloced) // запрет урезания памяти
    return alloced;

  if(data)
  {
    bStackType *new_data = new bStackType[new_size];
    memcpy(new_data, data, leangth * sizeof(bStackType));
    delete[] data;
    data = new_data;
  }
  else
    data = new bStackType[new_size];

  return alloced = new_size;
}
/*----------------------------------------------------------------------------*/
#endif /* _B_STACK_H_ */

class bString {
  private:
    char* m_data;
    size_t m_length;
  public:
    bString() : m_data(0),m_length(0) {}
    bString(const char* str) {
       m_length = ::strlen(str);
       m_data = new char [ m_length ];
       ::memcpy(m_data,str,m_length);  
    }
    bString(const bString& str) ....
    ~bString() { delete [] m_data;}
    
    bString& operator = (const bString& str) {
       if (&str==this) return *this;
       delete [] m_data;
       m_length = str.m_length;
       m_data = new char [ m_length ];
       ::memcpy(m_data,str.m_data,m_length);
       return *this;
    }
};