FInished C++ implementation of a queue using an array.

Author: jwasham

queue_array/main.cc

@@ -1,35 +1,18 @@
 #include <cstdlib>
 #include <iostream>
 
-#include "queue_array.h"
-#include "queue_array.cc"
+#include "src/queue_array.h"
+#include "src/queue_array.cc"
 
 // for stdlib experiments:
-//#include <forward_list>
-//#include <list>
+#include <queue>
+#include <stack>
 
 //void stdlib_forward_list_experiment();
 //void stdlib_doubly_linked_list_experiment();
 
 int main(int argc, char *argv[]) {
 
-//  jw::LinkedList<int> ilist{};
-//  ilist.PushFront(4);
-//  ilist.PushFront(9);
-//
-//  std::cout << "Size of int list is: " << ilist.Size() << std::endl;
-//
-//  jw::LinkedList<std::string> strlist{};
-//  strlist.PushFront("string 1");
-//  strlist.PushFront("another");
-//  strlist.PushFront("and another");
-//  std::cout << "Size of string list is: " << strlist.Size() << std::endl;
-//
-//  std::cout << "Hello friends - look in tests directory." << std::endl;
-//
-//  stdlib_forward_list_experiment();
-//  stdlib_doubly_linked_list_experiment();
-
   std::cout << "Here we go." << std::endl;
 
   return EXIT_SUCCESS;

queue_array/src/queue_array.cc

@@ -0,0 +1,40 @@
+#include "queue_array.h"
+
+namespace jw {
+
+template <class T>
+void Queue<T>::Enqueue(T value) {
+  if (Full()) {
+    std::cerr << "Queue is full. Unable to enqueue." << std::endl;
+    exit(EXIT_FAILURE);
+  }
+
+  data_[insert_] = value;
+  insert_++;
+}
+
+template <class T>
+const T Queue<T>::Dequeue() {
+  if (Empty()) {
+    std::cerr << "Queue is empty. Cannot dequeue." << std::endl;
+    exit(EXIT_FAILURE);
+  }
+
+  T value = data_[pop_];
+  data_[pop_] = 0;
+  pop_++;
+
+  return value;
+}
+
+template <class T>
+bool Queue<T>::Empty() const {
+  return insert_ == pop_;
+}
+
+template <class T>
+bool Queue<T>::Full() const {
+  return pop_ == (insert_ + 1) % kQueuePositions;
+}
+
+}  // namespace jw

queue_array/src/queue_array.h

@@ -1,4 +1,35 @@
+#include <iostream>
+
 #ifndef PROJECT_QUEUE_ARRAY_H
 #define PROJECT_QUEUE_ARRAY_H
 
-#endif //PROJECT_QUEUE_ARRAY_H
+namespace jw {
+
+template <class T>
+class Queue {
+  static const int kQueueCapacity = 5;
+  static const int kQueuePositions = kQueueCapacity + 1;
+
+ public:
+  explicit Queue() : insert_(0), pop_(0) {}
+  ~Queue() = default;
+  Queue(const Queue &) = delete;
+  Queue &operator=(const Queue &) = delete;
+  // Adds value to queue.
+  void Enqueue(T value);
+  // Removes least recently added item from queue, returning its value.
+  const T Dequeue();
+  // Returns true if queue is empty.
+  bool Empty() const;
+  // Returns true if queue cannot accept another enqueue.
+  bool Full() const;
+
+ private:
+  int insert_;
+  int pop_;
+  T data_[kQueuePositions];
+};
+
+}  // namespace jw
+
+#endif  // PROJECT_QUEUE_ARRAY_H

queue_array/tests/queue_array_tests.cc

@@ -1,11 +1,65 @@
-#include <string>
+#include <assert.h>
 #include <iostream>
+#include <string>
 #include "queue_array.cc"
 #include "queue_array.h"
 
-int main(int argc, char *argv[]) {
+void run_all_tests();
+void test_empty();
+void test_full();
+void test_dequeue();
 
-  std::cout << "out" << std::endl;
+int main(int argc, char *argv[]) {
+  run_all_tests();
 
   return EXIT_SUCCESS;
+}
+
+void run_all_tests() {
+  test_empty();
+  test_full();
+  test_dequeue();
+}
+
+void test_empty() {
+  jw::Queue<int> q;
+
+  assert(q.Empty());
+
+  q.Enqueue(3);
+
+  assert(!q.Empty());
+}
+
+void test_full() {
+  jw::Queue<double> q;
+
+  q.Enqueue(12.3);
+  q.Enqueue(4.235);
+  q.Enqueue(5.4);
+  q.Enqueue(7.0);
+  q.Enqueue(885314.32214);
+
+  assert(q.Full());
+}
+
+void test_dequeue() {
+  jw::Queue<int> q;
+
+  q.Enqueue(100);
+  q.Enqueue(200);
+  assert(q.Dequeue() == 100);
+  q.Enqueue(300);
+  assert(q.Dequeue() == 200);
+  q.Enqueue(400);
+  q.Enqueue(500);
+  q.Enqueue(600);
+  q.Enqueue(700);
+  assert(q.Dequeue() == 300);
+  assert(q.Dequeue() == 400);
+  assert(q.Dequeue() == 500);
+  assert(q.Dequeue() == 600);
+  assert(q.Dequeue() == 700);
+
+  assert(q.Empty());
 }