C / C++ / MFC

template<class T>
_node<T>::_node (const T& dat, _node<T>* ptr) :
  _data (dat),
  _next (ptr)
{
}

template<class T>
_node<T>::~_node ()
{
}

template<class T>
stack<T>::stack () :
  _size (0),
  _head (nullptr)
{
}


template<class T>
stack<T>::~stack ()
{
  while (_head)
  {
    _node<T>* ptr = _head->_next;
    delete _head;
    _head = ptr;
  }
}

template<class T>
size_t stack<T>::size () const
{
  return _size;
}

template<class T>
T& stack<T>::top () const
{
  if (!_size)
    throw std::exception ("empty_stack");

  return _head->_data;
}

template<class T>
void stack<T>::push (const T& data)
{
  _node<T>* node = new _node<T> (data, _head);
  _head = node;
  _size++;
}

template<class T>
void stack<T>::pop ()
{
  if (!_size)
    return;

  _node<T>* ptr = _head->_next;
  delete _head;
  _head = ptr;
  --_size;
}

template<class T>
void stack<T>::invert ()
{
  _node<T>* prev = nullptr;
  _node<T>* crt = _head;
  while (crt)
  {
    _node<T>* next = crt->_next;
    crt->_next = prev;
    prev = crt;
    crt = next;
  }
  _head = prev;
}

int main (int argc, char** argv)
{
  stack<int> the_stack;

  cout << "Empty stack has size " << the_stack.size () << endl;
  
  the_stack.push (1);
  the_stack.push (2);
  the_stack.push (3);
  the_stack.push (4);
  the_stack.push (5);
  cout << "5 elements pushes, size is " << the_stack.size () << endl;
  cout << "Top element is " << the_stack.top () << endl;

  the_stack.invert ();
  cout << "Stack inverted elements are (from top):" << endl;
  int n = the_stack.size ();
  for (int i = 0; i < n; i++)
  {
    cout << "Element " << i + 1 << " is " << the_stack.top () << endl;
    the_stack.pop ();
  }

  return 0;
}

#include <iostream>
typedef char* T; // this implementation will use simple C-style strings
#include "stack.h"

template <class t>
_node<t>::_node(const T& item, _node<t>* next)
{
    _data = item;
    _next = next;
}

template <class t>
_node<t>::~_node()
{

}


template <class t>
stack<t>::stack()
{
    _head = nullptr;
    _size = 0;
}

template <class t>
stack<t>::~stack()
{
    // empty destructor
}

template <class t>
size_t stack<t>::size() const
{
    //return the size of the stack
    return _size;
}

template <class t>
T& stack<t>::top() const
{
    //return a reference to the top value. Throw an exception if the stack is empty.
    if (_size == 0)
        throw std::exception("Stack contains no items");

    return _head->_data;
}

template <class t>
void stack<t>::push(const T& item)
{
    //push a new value onto the stack
    _node<t>* newNode = new _node<t>(item, _head);
    _head = newNode;
    _size++;
}

template <class t>
void stack<t>::pop()
{
    //remove the top value from the stack. Do nothing if the stack is empty.
    if (_size > 0)
    {
        _node<t>* popNode = _head;
        _head = popNode->_next;
        delete popNode;
        _size--;
    }
}

template <class t>
void stack<t>::invert()
{
    //reverse the order of the entire stack, so that 1,2,3,4,5 becomes 5,4,3,2,1 and so on.
    if (_size > 1)
    {
        _node<t>* current = _head;
        _node<t>* next = nullptr;
        _node<t>* temp;

        while (current)
        {
            temp = current->_next;
            current->_next = next;
            next = current;
            current = temp;
        }
        _head = next;
    }
}

void pusher(stack<T>& theStack, T* items)
{
    while (*items != 0)
    {
        theStack.push(*items);
        std::cout << "Push " << *items << " onto the stack" << std::endl;
        items++;
    }
    std::cout << "    Top item = " << theStack.top() << ", stack size = " << theStack.size() << std::endl << std::endl;
}


void popper(stack<T>& theStack)
{
    while (theStack.size() > 0)
    {
        T& foo = theStack.top();
        std::cout << "    Top item = " << foo << ", stack size = " << theStack.size() << std::endl;
        theStack.pop();
    }
    std::cout << "    stack size = " << theStack.size() << std::endl << std::endl;
}


/// <summary>
/// Main function of the console application, which runs the application.
/// </summary>
///
/// <param name="argc">Count of command line parameters</param>
/// <param name="argv">Array of command line parameters</param>
///
/// <returns>Application defined value</returns>
///
int wmain(
    int		argc,
    wchar_t** argv
)
{
    stack<T> myStack;
//    T val = myStack.top(); // check exception

    T listA[] = { "Foo", "Bar", "Poo", 0 };
    pusher(myStack, listA);
    popper(myStack);

    T listB[] = { "The", "rain", "in", "Spain", "falls", "mainly", "in", "the", "plain", 0 };
    pusher(myStack, listB);

    std::cout << std::endl << "Invert the stack" << std::endl;
    myStack.invert();
    popper(myStack);

    std::cout << std::endl << "Press <enter> to continue ... ";
    std::cin.get();
    return 0;
}

Mircea Neacsu wrote:

add a reasonable set of unit tests, with output, to main.cpp"

Mircea Neacsu wrote:

I like my variable names (prev, crt, next)

Mircea Neacsu wrote:

a bit pleonastic

Quote:

I had assumed you are Romanian, but your bio says Canadian; that makes me feel a bit better.

Mircea Neacsu wrote:

If you move your main to a different CPP file you will run into errors.

void sample()
{
    stack<T> dummy;
    dummy.push("A");
    dummy.size();
    dummy.top();
    dummy.pop();
    dummy.invert();
}

Richard MacCutchan wrote:

I don't think they are as dumb as first appears.

Mircea Neacsu wrote:

template <class t=""> struct _node

TimePoint SysTickTimer::Now() const
{
   if(available_)  // previously set based on whether high-frequency timing is available
   {
      LARGE_INTEGER now;
      QueryPerformanceCounter(&now);
      return TimePoint(now.QuadPart);  // the current time in ticks (64 bits)
   }
   else  // will only have millisecond accuracy
   {
      _timeb now;
      _ftime_s(&now);
      auto msecs = 1000LL * now.time;
      return TimePoint(msecs + now.millitm);
   }
}

LARGE_INTEGER frequency;

if(QueryPerformanceFrequency(&frequency))
{
   available_ = true;
   ticks_per_sec_ = frequency.QuadPart;
}