error: expected declaration before } token (when trying to compile) - c++

Question

I'm having a problem. I have the template and implementation for a stack in files stack.h and stack.hpp. Then I have an in2out.cpp file that converts infix expressions to outfix expressions and evaluates them. At the beginning of in2out.cpp I "#include stack.h". And inside stack.h (which is my interface) I "#include stack.hpp" (stack.hpp is my implementation). I know this is weird but it's the way I'm required to do it.
Anyways, my problem is, when I'm trying to compile these 3 files together. I get only 1 error which is in stack.h (my interface, listed below). The error is:
In file included from in2post.cpp:7:
stack.h:49: error: expected declaration before â}â token
Line 49 is near the bottom. here is my stack.h file.
#ifndef STACK_H
#define STACK_H
#include <iostream>
#include <vector>
namespace cop4530 {
template<typename T>
class Stack {
private:
std::vector<T> v;
public:
Stack();
~Stack();
Stack (const Stack<T>&);
//Stack (Stack<T>&& );
Stack<T>& operator= (const Stack <T>&);
//Stack<T> & operator=(Stack<T> &&);
bool empty() const;
void clear();
void push(const T& x);
//void push(T && x);
void pop();
T& top();
const T& top() const;
int size() const;
void print(std::ostream& os, char ofc = ' ') const;
};
template<typename T>
std::ostream& operator<< (std::ostream& os, const Stack<T>& a);
template<typename T>
bool operator== (const Stack<T>& a, const Stack <T>& b);
template<typename T>
bool operator!= (const Stack<T>& a, const Stack <T>& b);
template<typename T>
bool operator< (const Stack<T>& a, const Stack <T>& b);
#include "stack.hpp"
} //this is line 49
#endif
Here's my makefile:
CC = g++
FLAGS = -Wall -pedantic
DDD = -g
in2post.x: in2post.cpp stack.h stack.hpp
$(CC) $(FLAGS) $(DDD) -o in2post.x in2post.cpp
EDIT: Here's the beginning of Stack.hpp: (tell me if I should change or add something)
EDIT2: I just decided to include the whole Stack.hpp. Some functions are blanked out cause I didn't need them or couldn't figure them out
#include <iostream>
#include <vector>
template<typename T>
Stack<T>::Stack(){}
template<typename T>
Stack<T>::~Stack(){
v.clear();
}
template<typename T>
Stack<T>::Stack(const Stack<T> & S){
v = S.v;
}
/*
template<typename T>
Stack<T>::Stack(Stack<T> &&){
}
*/
template<typename T>
Stack<T> & Stack<T>::operator=(const Stack<T> & S){
v = S.v;
return *this;
}
/*
template<typename T>
Stack<T>::Stack<T> & Stack<T>::operator=(Stack<T> &&){
}
*/
template<typename T>
bool Stack<T>::empty() const {
return v.empty();
}
template<typename T>
void Stack<T>::clear(){
while (!v.empty())
v.clear();
}
template<typename T>
void Stack<T>::push(const T& x){
v.push_back(x);
}
/*
template<typename T>
void Stack<T>::push(T && x){
}
*/
template<typename T>
void Stack<T>::pop(){
v.pop_back();
}
template<typename T>
T& Stack<T>::top(){
return v[v.size()-1];
}
template<typename T>
const T & Stack<T>::top() const{
return v[0];
}
template<typename T>
int Stack<T>::size() const {
return v.size();
}
template<typename T>
void Stack<T>::print(std::ostream & os, char ofc) const {
for(int i = 0; i < v.size(); i++)
os << v[i] << ofc;
}
/*------------------NON-MEMBER GLOBAL FUNCTIONS-----------------*/
template<typename T>
std::ostream & operator<<(std::ostream & os, const Stack<T> & a) {
a.print(os);
return os;
}
template <typename T>
bool operator==(const Stack<T> & a, const Stack<T> & b) {
if(a.size() != b.size())
return false;
else {
Stack<T> c = a;
Stack<T> d = b;
bool retVal = true;
while(!c.empty()) {
if(c.top() == d.top()) {
c.pop();
d.pop();
}
else {
retVal = false;
break;
}
}
return retVal;
}
}
template <typename T>
bool operator!=(const Stack<T> & a, const Stack<T> & b) {
return !(a == b);
}
template <typename T>
bool operator<(const Stack<T> & a, const Stack<T> & b) {
Stack<T> c = a;
Stack<T> d = b;
bool retVal = true;
while(!c.empty()) {
if(!(c.top() < d.top())) {
retVal = false;
break;
}
else {
c.pop();
d.pop();
}
}
return retVal;
}

Answer 1

Your operator< in stack.hpp has an extra closing curly brace which is closing the namespace early.