Return to Revisions

I've implemented a simple C++ STL like queue. (I've tried to follow @LokiAstari stack implementation code fashion)

#ifndef QUEUE_H
#define QUEUE_H
#include <iostream>
#include <stdexcept>
using std::cout;
template <typename T>
class queue {
public:
 struct node {
 T data;
 node *next;
 node()
 : data(0)
 , next(nullptr) {
 }
 node(T const& data, node* next)
 : data(data)
 , next(next) {
 }
 node(T&& data, node* next)
 : data(std::move(data))
 , next(next) {
 }
 };
 ~queue();
 bool empty() const;
 size_t size() const;
 T front() const;
 void push(T const& data);
 void push(T&& data);
 //void emplace (T&&... args);
 // void swap (queue& x);
 void pop();
private:
 size_t elements = 0;
 node *head = nullptr;
 node *tail = nullptr;
};
template <typename T>
queue<T>::~queue() {
 node *curr = new node();
 while(head) {
 curr = head;
 head = head->next;
 delete curr;
 }
 delete tail;
}
template <typename T>
bool queue<T>::empty() const {
 return elements == 0;
// return head == nullptr;
}
template <typename T>
size_t queue<T>::size() const {
 return elements;
}
template <typename T>
T queue<T>::front() const {
 if(elements == 0)
 throw std::runtime_error("Invalid Action");
 return head->data;
}
template <typename T>
void queue<T>::push(T const& data) {
 node *newNode = new node(data, nullptr);
 if(!elements) head = newNode;
 else tail->next = newNode;
 tail = newNode;
 ++elements;
}
template <typename T>
void queue<T>::push(T&& data) {
 node *newNode = new node(std::move(data), nullptr);
 if(!elements) head = newNode;
 else tail->next = newNode;
 tail = newNode;
 ++elements;
}
template <typename T>
void queue<T>::pop() {
 if(elements == 0)
 throw std::runtime_error("Invalid Action");
 node *tmp = new node();
 if(elements != 0) tmp = head;
 head = head->next;
 --elements;
 delete tmp;
}
#endif // QUEUE_H

I would appreciate all criticism relevant to code, style, flow, camelCase vs underscore, and so forth.