Setting up queue in linked list implementation.

Author: jwasham

queue_array/main.cc

@@ -4,16 +4,9 @@
 #include "src/queue_array.h"
 #include "src/queue_array.cc"
 
-// for stdlib experiments:
-#include <queue>
-#include <stack>
-
-//void stdlib_forward_list_experiment();
-//void stdlib_doubly_linked_list_experiment();
-
 int main(int argc, char *argv[]) {
 
-  std::cout << "Here we go." << std::endl;
+  std::cout << "Nothing to see here. Look in tests directory." << std::endl;
 
   return EXIT_SUCCESS;
 }

queue_linked_list/CMakeLists.txt

@@ -0,0 +1,17 @@
+cmake_minimum_required(VERSION 3.5)
+project(queue_llist_proj)
+
+add_definitions(-std=c++11)
+add_definitions(-Werror) # stop compile on warning
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_GLIBCXX_DEBUG")
+
+set(SOURCE_FILES main.cc)
+add_executable(queue_llist_run ${SOURCE_FILES})
+
+include_directories(src)
+
+add_subdirectory(src)
+add_subdirectory(tests)
+
+target_link_libraries(queue_llist_run queue_llist_lib)

queue_linked_list/main.cc

@@ -0,0 +1,19 @@
+#include <cstdlib>
+#include <iostream>
+
+#include "src/queue_linked_list.h"
+#include "src/queue_linked_list.cc"
+
+// for stdlib experiments:
+#include <queue>
+#include <stack>
+
+//void stdlib_forward_list_experiment();
+//void stdlib_doubly_linked_list_experiment();
+
+int main(int argc, char *argv[]) {
+
+  std::cout << "Here we go." << std::endl;
+
+  return EXIT_SUCCESS;
+}

queue_linked_list/src/CMakeLists.txt

@@ -0,0 +1,12 @@
+cmake_minimum_required(VERSION 3.5)
+project(queue_llist_lib)
+
+add_definitions(-std=c++11)
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -D_GLIBCXX_DEBUG")
+
+set(HEADER_FILES queue_linked_list.h)
+
+set(SOURCE_FILES queue_linked_list.cc)
+
+add_library(queue_llist_lib STATIC ${SOURCE_FILES} ${HEADER_FILES})

queue_linked_list/src/queue_linked_list.cc

@@ -0,0 +1,40 @@
+#include "queue_linked_list.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_linked_list/src/queue_linked_list.h

@@ -0,0 +1,35 @@
+#include <iostream>
+
+#ifndef PROJECT_QUEUE_ARRAY_H
+#define 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_linked_list/tests/CMakeLists.txt

@@ -0,0 +1,5 @@
+project(queue_array_tests)
+
+add_executable(queue_array_tests queue_array_tests.cc)
+
+target_link_libraries(queue_array_tests queue_array_lib)

queue_linked_list/tests/queue_array_tests.cc

@@ -0,0 +1,65 @@
+#include <assert.h>
+#include <iostream>
+#include <string>
+#include "queue_array.cc"
+#include "queue_array.h"
+
+void run_all_tests();
+void test_empty();
+void test_full();
+void test_dequeue();
+
+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());
+}