C / C++ / MFC

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

Richard MacCutchan wrote:

You should use the OnInitDialog method of CDialog Class | Microsoft Docs[^] to set the focus.

SendMessageToDescendants(WM_INITIALUPDATE, 0, 0, TRUE, TRUE);