Stack Gotoxy

[zayx]

i cant compile with gotoxy, its show me windows.h as an error

stack.h

#ifndef STACK_H_INCLUDED
#define STACK_H_INCLUDED

#include <exception>
#include<string>


class StackException:
public std::exception
{
    private:
    std::string msg;
    public:
        explicit StackException(const char* message): msg(message){}
        explicit StackException(const std::string& message) : msg(message){}
        virtual ~StackException() throw (){}
        virtual const char* what() const throw(){
            return msg.c_str();
        }
};

///DEFINITION
template <class T, int ARRAYSIZE = 1024>
class Stack{
private:
    T data[ARRAYSIZE];
    int top;

    void copyAll(const Stack<T, ARRAYSIZE>&);

public:
    Stack(); ///constructor base
    Stack(const Stack<T, ARRAYSIZE>&); ///constructor copy
    void initialize();

    bool isEmpty();
    bool isFull();

    void push(const T&);
    void showStack();

    T pop();

    T getTop();
    void gotoxy(int,int);

   Stack<T, ARRAYSIZE>& operator = (const Stack<T, ARRAYSIZE>&); ///OPERATOR ASIGNED
};


///IMPLEMENTATION
using namespace std;

template <class T, int ARRAYSIZE>
Stack<T,ARRAYSIZE>::Stack():top(-1){ }

template <class T, int ARRAYSIZE>
void Stack<T, ARRAYSIZE>::copyAll(const Stack<T, ARRAYSIZE>& s)
{
	int i(0);
	while (i <= s.top)
	{
		this->data[i] = s.data[i];
		i++;
	}
	this->top = s.top;
}
template <class T, int ARRAYSIZE>
Stack<T,ARRAYSIZE>::Stack(const Stack<T,ARRAYSIZE>& s){
    copyAll(s);
}

template <class T, int ARRAYSIZE>
bool Stack<T, ARRAYSIZE>::isEmpty(){
    return top == -1;
}

template <class T, int ARRAYSIZE>
bool Stack<T, ARRAYSIZE>::isFull(){
    return top == ARRAYSIZE -1;
}

template <class T, int ARRAYSIZE>
void Stack<T, ARRAYSIZE>::push(const T& e){
    if(isFull()){
        throw StackException("DATA OVERLOAD, PUSH");
    }
    data[++top]= e;
}

template <class T, int ARRAYSIZE>
T Stack<T, ARRAYSIZE>::pop(){
    if(isEmpty()){
        throw StackException("DATA INSUFFICIENCY, POP");
        }
    return data[top--];
}

template <class T, int ARRAYSIZE>
T Stack<T, ARRAYSIZE>::getTop(){
    if(isEmpty()){
        throw StackException("DATA INSUFFICIENCY, getTop");
    }
    return data[top];
}

template <class T, int ARRAYSIZE>  ///& reference
Stack<T, ARRAYSIZE>& Stack<T, ARRAYSIZE>::operator = (const Stack<T, ARRAYSIZE>& s){
    copyAll(s);

    return *this;
}

template <class T, int ARRAYSIZE>
void Stack<T, ARRAYSIZE>::showStack(){
	int ayuda,i;
	if(!isEmpty()){
		system("cls");
	   	printf("\n\n\t\t%c%c%c%c%c  \n",201,205,205,205,187);
	    for(i=top;i>=0;i--){
		     printf("\t\t%c%c ",186,205);
		    cout<<data[i]; printf(" %c\n",186);
		    printf("\t\t%c%c%c%c%c\n",204,205,205,205,185);

		}
			//system("pause");
	}
  }

template <class T, int ARRAYSIZE>
void Stack<T, ARRAYSIZE>::gotoxy(int x,int y){
      HANDLE hcon;
      hcon = GetStdHandle(STD_OUTPUT_HANDLE);
      COORD dwPos;
      dwPos.X = x;
      dwPos.Y= y;
      SetConsoleCursorPosition(hcon,dwPos);
}

#endif // STACK_H_INCLUDED 

mainStack.cpp

#include <iostream>
#include <stdlib.h>
#include <windows.h>
#include <stdio.h>
#include <cstdio>
#include <string.h>

#include "stack.h"

using namespace std;

bool esNumeric(string);

int main()
{
    Stack<string,10> myStack;
	int opt,number;
	bool repeat = true;
	string line_;

		do{
            do{
                system("cls");
                myStack.showStack();
                cout<<"\n\n---STACK---";
                cout<<"\n 1) ENTER NUMBER\n 2) DELETE TOP\n 3) SHOW TOP \n 4) EXIT"<<endl;
                cout<<"\tOPTION: ";
                getline(cin,line_);
                if (esNumeric(line_)) {
                    repeat = false;
                }
            } while(repeat);
            opt = atoi(line_.c_str());
			switch(opt){
				case 1:{
                        do {
                            system("cls");
                            cout<<"ENTER NUMBER: ";
                            getline(cin,line_);
                            if (esNumeric(line_)) {
                                    if(myStack.isFull()){
                                        cout<<"\nIT IS FULL"<<endl<<endl;
                                    }
                                    else{
                                         myStack.push(line_);
                                    }
                                repeat = false;
                            }
                        } while (repeat);
                        system("pause");
                        system("cls");
                        break;
				}

				case 2:{
                        if(myStack.isEmpty()){
                            cout<<"\nEMPTY STACK"<<endl<<endl;
                        }
                        else{
                            myStack.pop();
                        }
                        system("pause");
                        system("cls");
                        break;
				}
				case 3:{
                        system("cls");
                        if(myStack.isEmpty()){
                            cout<<"EMPTY STACK";
                        }
                        else{
                        cout<<"\nTOP: "<< myStack.getTop()<<endl;
                        }
                        system("pause");
                        break;
				}
				case 4:{
				    cout<<" ";
				    break;
				}
				default:{
				    cout<<"\nOUT OF RANGE."<<endl;
				    system("pause");
				    system("cls");
				}
            }
		}while(opt!=4);
		cout<<"\n\nEND OF THE PROGRAMF\n";
		system("pause");
		return EXIT_SUCCESS;
}

bool esNumeric(string line_)
{
   bool b = true;
   int length = line_.size();

   if (length == 0) { // When user push ENTER
      b = false;
   } else if (length == 1 && !isdigit(line_[0])) {
      b = false;
   } else {
      int i;
      if (line_[0] == '+' || line_[0] == '-')
         i = 1;
      else
         i = 0;

      while (i < length) {
         if (!isdigit(line_[i])) {
            b = false;
            break;
         }
         i++;
      }
   }

   return b;
}

OUTPUT ERROR:

In file included from main.cpp:8:
./stack.h:132:7: error: unknown type name 'HANDLE'
HANDLE hcon;
^
./stack.h:133:27: error: use of undeclared identifier
'STD_OUTPUT_HANDLE'
hcon = GetStdHandle(STD_OUTPUT_HANDLE);
^
./stack.h:134:7: error: unknown type name 'COORD'
COORD dwPos;
^
3 errors generated.

https://repl.it/@ZayxHex/Stack-Validation-Gotoxy-Object-Oriented

[Duthomhas]

#include <exception>
#include<string>
#include <windows.h> 

[salem c]

> class StackException:
> public std::exception
> {
> private:
> std::string msg;
Having an exception class that can itself cause exceptions seems like a bad idea.
https://stackoverflow.com/questions/8152720/correct-way-to-inherit-from-stdexception