Deque implementation using Arrays in C++

Question

I have written code for the basic implementation of a Deque in C++ using Array(pointer). Please review my code and suggest ways to make it simpler, compact, and efficient. Also would appreciate feedback on any aspect of my code.

#include <iostream>
#include <cstdlib>
class queue
{
private:
 int size = 0, front = -1, rear = -1;
 float *arr;
public:
 queue(int inputSize)
 {
 size = inputSize;
 arr = (float *)malloc(size * sizeof(float));
 }
 int isEmpty(queue *q)
 {
 if (q->front == q->rear)
 {
 return 1;
 }
 return 0;
 }
 int isFull(queue *q)
 {
 if (q->rear == q->size - 1)
 {
 return 1;
 }
 return 0;
 }
 void enqueueR(queue *q, int data)
 {
 if (isFull(q))
 {
 std::cout << data << " cannot be entered as Queue is Full\n";
 }
 else
 {
 q->rear++;
 q->arr[q->rear] = data;
 }
 }
 void enqueueF(queue *q, int data)
 {
 if (isFull(q))
 {
 std::cout << data << " cannot be entered as Queue is Full\n";
 }
 else
 {
 for (int i = front + 1; i < size; i++)
 {
 q->arr[i + 1] = q->arr[i];
 }
 q->arr[q->front + 1] = data;
 q->rear++;
 }
 }
 void dequeueF(queue *q)
 {
 if (isEmpty(q))
 {
 std::cout << "Queue is Empty\n";
 }
 else
 {
 q->front++;
 std::cout << "The removed value is: " << q->arr[q->front] << "\n";
 }
 }
 void dequeueR(queue *q)
 {
 if (isEmpty(q))
 {
 std::cout << "Queue is Empty\n";
 }
 else
 {
 std::cout << "The removed value is: " << q->arr[q->rear] << "\n";
 q->rear--;
 }
 }
 void queueTraversal(queue *q)
 {
 std::cout << "The queue is as follows:\n";
 for (int i = front + 1; i <= rear; i++)
 {
 std::cout << q->arr[i] << " ";
 }
 std::cout << std::endl;
 }
};

Answer 1

Advice 1

queue stores a queue of float values. Why not to rename to float_queue?

Advice 2

arr = (float *)malloc(size * sizeof(float));

You can write:

arr = new float[size];

Advice 3

Your class misses the destructor, which should call delete[] arr; on the queue. Thus, you leak RAM.

Advice 4

int size = 0, front = -1, rear = -1;

int supports some negative values, but they are meaningless in this context; change to size_t, which is concieved as the type for counting/indexing stuff.

Advice 5

int isEmpty(queue *q)
{
 if (q->front == q->rear)
 {
 return 1;
 }
 return 0;
}

Why do you ask for queue* q argument when you can simply refer to the members of the class? Same observation applies to other relevant methods.

Advice 6

if (isFull(q))
{
 std::cout << data << " cannot be entered as Queue is Full\n";
}

This is a no-no in the professional data structure development; throw an exception instead.

Advice 7

queueTraversal(queue *q)

This is asking for iterators.

Suggestion 1

I suggest you consult a professional C++-developer (obviously not me), whether it makes sense to implement:

1. copy constructor
2. copy assignment
3. move constructor
4. move assignment

All in all

I had this implementation in mind:

#include <algorithm>
#include <stdexcept>
using std::copy;
using std::logic_error;
class float_queue
{
private:
 size_t size;
 size_t max_capacity;
 size_t front_index;
 float* storage_array;
public:
 float_queue(size_t _max_capacity) : size(0),
 max_capacity(_max_capacity), 
 front_index(0), 
 storage_array(new float[_max_capacity]) {}
 float_queue(const float_queue& other) : 
 size(other.size),
 max_capacity(other.max_capacity),
 front_index(other.front_index) {
 storage_array = new float[other.max_capacity];
 copy(other.storage_array,
 other.storage_array + other.max_capacity, 
 storage_array);
 }
 float_queue(float_queue&& other) :
 size(other.size),
 max_capacity(other.max_capacity),
 front_index(other.front_index),
 storage_array(other.storage_array) {
 other.size = 0;
 other.max_capacity = 0;
 other.front_index = 0;
 other.storage_array = nullptr;
 }
 float_queue& operator=(const float_queue& other) {
 if (this != &other) {
 float* new_array = new float[other.max_capacity];
 copy(other.storage_array, 
 other.storage_array + other.max_capacity, 
 new_array);
 delete[] storage_array;
 storage_array = new_array;
 max_capacity = other.max_capacity;
 size = other.size;
 front_index = other.front_index;
 }
 return *this;
 }
 float_queue& operator=(float_queue&& other) {
 if (&other != this) {
 size = other.size;
 front_index = other.front_index;
 max_capacity = other.max_capacity;
 storage_array = other.storage_array;
 other.size = 0;
 other.front_index = 0;
 other.max_capacity = 0;
 other.storage_array = nullptr;
 }
 return *this;
 }
 ~float_queue() {
 size = 0;
 max_capacity = 0;
 front_index = 0;
 delete[] storage_array;
 }
 bool isEmpty()
 {
 return size == 0;
 }
 int isFull()
 {
 return size == max_capacity;
 }
 void prepend(float f) {
 if (isFull()) {
 throw logic_error{"Prepending while full."};
 }
 size_t new_front_index;
 if (front_index == 0) {
 new_front_index = max_capacity - 1;
 }
 else {
 new_front_index = front_index - 1;
 }
 size++;
 storage_array[new_front_index] = f;
 front_index = new_front_index;
 }
 
 void append(float f) {
 if (isFull()) {
 throw logic_error{"Appending while full."};
 }
 size_t append_index = (front_index + size) % max_capacity;
 size++;
 storage_array[append_index] = f;
 }
 float removeHead() {
 if (isEmpty()) {
 throw logic_error{"Removing a head from empty queue."};
 }
 float rv = storage_array[front_index];
 front_index = (front_index + 1) % max_capacity;
 size--;
 return rv;
 }
 float removeTail() {
 if (isEmpty()) {
 throw logic_error{"Removing a tail from empty queue."};
 }
 float rv = storage_array[(front_index + size - 1) % max_capacity];
 size--;
 return rv;
 }
};

Note that the above code snippet is not tested for bugs/design errors; it's only for my semi-professional reference. Good luck!