Library 3

container & iterator.hpp

librerie/exercise3/queue/lst/queuelst.cpp

@@ -1,10 +1,73 @@
 
 namespace lasd {
 
-/* ************************************************************************** */
+template <typename Data>
+QueueLst<Data>::QueueLst(const LinearContainer<Data>& linear)
+  : List<Data>(linear) {}
 
-// ...
+template <typename Data>
+QueueLst<Data>::QueueLst(const QueueLst& copyFrom)
+  : List<Data>(copyFrom) {}
 
-/* ************************************************************************** */
+template <typename Data>
+QueueLst<Data>::QueueLst(QueueLst&& moveFrom) noexcept
+  : List<Data>(std::move(moveFrom)) {}
+
+template <typename Data>
+QueueLst<Data>::~QueueLst(){
+  Clear();
+}
+
+template <typename Data>
+QueueLst<Data>& QueueLst<Data>::operator=(const QueueLst& toCopy){
+  List<Data>::operator=(toCopy);
+  return *this;
+}
+
+template <typename Data>
+QueueLst<Data>& QueueLst<Data>::operator=(QueueLst&& toMove) noexcept{
+  List<Data>::operator=(std::move(toMove));
+  return *this;
+}
+
+template <typename Data>
+bool QueueLst<Data>::operator==(const QueueLst& queuelist) const noexcept{
+    return List<Data>::operator==(queuelist);
+  }
+
+template <typename Data>
+bool QueueLst<Data>::operator!=(const QueueLst& queuelist) const noexcept{
+    return List<Data>::operator!=(queuelist);
+  }
+
+template <typename Data>
+  void QueueLst<Data>::Enqueue(const Data& data){
+    List<Data>::InsertAtBack(data);
+  }
+
+template <typename Data>
+void QueueLst<Data>::Enqueue(Data&& data){
+    List<Data>::InsertAtBack(std::move(data));
+  }
+
+template <typename Data>
+Data& QueueLst<Data>::Head() const{
+    return List<Data>::Front();
+}
+
+template <typename Data>
+void QueueLst<Data>::Dequeue(){
+    List<Data>::RemoveFromFront();
+}
+
+template <typename Data>
+Data QueueLst<Data>::HeadNDequeue(){
+  return List<Data>::FrontNRemove();
+}
+
+template <typename Data>
+void QueueLst<Data>::Clear(){
+  List<Data>::Clear();
+}
 
 }

librerie/exercise3/queue/lst/queuelst.hpp

@@ -14,70 +14,70 @@ namespace lasd {
 /* ************************************************************************** */
 
 template <typename Data>
-class QueueLst { // Must extend Queue<Data> and List<Data>
+class QueueLst :  virtual public Queue<Data>,
+                  virtual protected List<Data>{ // Must extend Queue<Data> and List<Data>
 
 private:
 
-  // ...
-
 protected:
 
-  // using List<Data>::???;
-
-  // ...
+  using List<Data>::head;
+  using List<Data>::tail;
+  using List<Data>::size;
+  using typename List<Data>::Node;
 
 public:
 
   // Default constructor
-  // QueueLst() specifier;
+  QueueLst() = default;
 
   /* ************************************************************************ */
 
   // Specific constructor
-  // QueueLst(argument) specifiers; // A queue obtained from a LinearContainer
+  QueueLst(const LinearContainer<Data>&); // A queue obtained from a LinearContainer
 
   /* ************************************************************************ */
 
   // Copy constructor
-  // QueueLst(argument);
+  QueueLst(const QueueLst&);
 
   // Move constructor
-  // QueueLst(argument);
+  QueueLst(QueueLst&&) noexcept;
 
   /* ************************************************************************ */
 
   // Destructor
-  // ~QueueLst() specifier;
+  ~QueueLst();
 
   /* ************************************************************************ */
 
   // Copy assignment
-  // type operator=(argument);
+  QueueLst& operator=(const QueueLst&);
 
   // Move assignment
-  // type operator=(argument);
+  QueueLst& operator=(QueueLst&&) noexcept;
 
   /* ************************************************************************ */
 
   // Comparison operators
-  // type operator==(argument) specifiers;
-  // type operator!=(argument) specifiers;
+  bool operator==(const QueueLst&) const noexcept;
+  bool operator!=(const QueueLst&) const noexcept;
 
   /* ************************************************************************ */
 
   // Specific member functions (inherited from Queue)
 
-  // type Enqueue(argument) specifiers; // Override Queue member (copy of the value)
-  // type Enqueue(argument) specifiers; // Override Queue member (move of the value)
-  // type Head() specifiers; // Override Queue member (must throw std::length_error when empty)
-  // type Dequeue() specifiers; // Override Queue member (must throw std::length_error when empty)
-  // type HeadNDequeue() specifiers; // Override Queue member (must throw std::length_error when empty)
+  void Enqueue(const Data&) override; // Override Queue member (copy of the value)
+  void Enqueue(Data&&) override; // Override Queue member (move of the value)
+  Data& Head() const override; // Override Queue member (must throw std::length_error when empty)
+  void Dequeue() override; // Override Queue member (must throw std::length_error when empty)
+  Data HeadNDequeue() override; // Override Queue member (must throw std::length_error when empty)
 
   /* ************************************************************************ */
 
   // Specific member functions (inherited from Container)
 
-  // type Clear() specifiers; // Override Container member
+  void Clear() override; // Override Container member
 
 };
 

librerie/exercise3/queue/queue.hpp

@@ -13,44 +13,40 @@ namespace lasd {
 /* ************************************************************************** */
 
 template <typename Data>
-class Queue { // Must extend Container
+class Queue : virtual public Container{ // Must extend Container
 
 private:
 
-  // ...
-
 protected:
 
-  // ...
-
 public:
 
   // Destructor
-  // ~Queue() specifiers
+  ~Queue() = default;
 
   /* ************************************************************************ */
 
   // Copy assignment
-  // type operator=(argument); // Copy assignment of abstract types should not be possible.
+  Queue& operator=(const Queue&) = delete; // Copy assignment of abstract types should not be possible.
 
   // Move assignment
-  // type operator=(argument); // Move assignment of abstract types should not be possible.
+  Queue& operator=(Queue&&) = delete; // Move assignment of abstract types should not be possible.
 
   /* ************************************************************************ */
 
   // Comparison operators
-  // type operator==(argument) specifiers; // Comparison of abstract types might not be possible.
-  // type operator!=(argument) specifiers; // Comparison of abstract types might not be possible.
+  bool operator==(const Queue&) const noexcept = delete; // Comparison of abstract types might not be possible.
+  bool operator!=(const Queue&) const noexcept = delete; // Comparison of abstract types might not be possible.
 
   /* ************************************************************************ */
 
   // Specific member functions
 
-  // type Enqueue(argument) specifiers; // Copy of the value
-  // type Enqueue(argument) specifiers; // Move of the value
-  // type Head() specifiers; // (concrete function must throw std::length_error when empty)
-  // type Dequeue() specifiers; // (concrete function must throw std::length_error when empty)
-  // type HeadNDequeue() specifiers; // (concrete function must throw std::length_error when empty)
+  virtual void Enqueue(const Data&) = 0; // Copy of the value
+  virtual void Enqueue(Data&&) = 0; // Move of the value
+  virtual Data& Head() const = 0; // (concrete function must throw std::length_error when empty)
+  virtual void Dequeue() = 0; // (concrete function must throw std::length_error when empty)
+  virtual Data HeadNDequeue() = 0; // (concrete function must throw std::length_error when empty)
 
 };
 

librerie/exercise3/queue/vec/queuevec.cpp

@@ -1,10 +1,192 @@
 
 namespace lasd {
 
-/* ************************************************************************** */
+template <typename Data>
+QueueVec<Data>::QueueVec(){
+  size = 4;
+  rear = 0;
+  front = 0;
+  Elements = new Data[size];
+}
 
-// ...
+template <typename Data>
+QueueVec<Data>::QueueVec(const LinearContainer<Data>& linear){
+  size = linear.Size()+1; // 1 free cell
+  Elements = new Data[size]; //forse da espandere
+  for(ulong i=0 ; i<linear.Size() ; ++i){
+    Elements[i] = linear[i];
+  }
+  front = 0;
+  rear = size-1; // the vector will be full
+}
 
-/* ************************************************************************** */
+template <typename Data>
+QueueVec<Data>::QueueVec(const QueueVec& toCopy){
+  size = toCopy.size;
+  ulong index_of_the_element = toCopy.front , i=0;
+  Elements = new Data[size];
+
+  while(index_of_the_element != toCopy.rear){
+    Elements[i] = toCopy[index_of_the_element];
+    ++i;
+    index_of_the_element = (index_of_the_element+1)%size;
+  }
+  front = 0;
+  rear = i;
+}
+
+template <typename Data>
+QueueVec<Data>::QueueVec(QueueVec&& toMove) noexcept{
+    Clear();
+    std::swap(Elements, toMove.Elements);
+    std::swap(rear, toMove.rear);
+    std::swap(front, toMove.front);
+    std::swap(size, toMove.size);
+}
+
+template <typename Data>
+QueueVec<Data>::~QueueVec(){
+  //vector destructor will be automatically called I hope
+}
+
+template <typename Data>
+QueueVec<Data>& QueueVec<Data>::operator=(const QueueVec& toCopy){
+  QueueVec<Data>* tmpQueue = new QueueVec<Data>(toCopy);
+  std::swap(*tmpQueue, *this);
+  delete tmpQueue;
+  return *this;
+}
+
+template <typename Data>
+QueueVec<Data>& QueueVec<Data>::operator=(QueueVec&& toMove) noexcept{
+  std::swap(Elements, toMove.Elements);
+  std::swap(size, toMove.size);
+  std::swap(rear, toMove.rear);
+  std::swap(front, toMove.front);
+  return *this;
+}
+
+template <typename Data>
+bool QueueVec<Data>::operator==(const QueueVec& toCompare) const noexcept{
+  if(Size() == toCompare.Size()){
+    ulong indexToCompare = toCompare.front;
+    ulong index = front;
+    while(indexToCompare != toCompare.rear){
+      if(Elements[index]!=toCompare[indexToCompare]){
+        return false;
+      }
+      index = (index+1)%size;
+      indexToCompare = (indexToCompare+1)%size;
+    }
+    return true;
+  }else{
+    return false;
+  }
+}
+
+template <typename Data>
+bool QueueVec<Data>::operator!=(const QueueVec& toCompare) const noexcept{
+  return !(*this == toCompare);
+}
+
+template <typename Data>
+void QueueVec<Data>::Enqueue(const Data& data){
+  if((rear+1)%size == front){
+    Expand();
+  }
+  Elements[rear] = data;
+  rear = (rear + 1) % size;
+}
+
+template <typename Data>
+void QueueVec<Data>::Enqueue(Data&& data){
+  if((rear+1)%size == front){
+    Expand();
+  }
+  std::swap(Elements[rear],data);
+  rear = (rear + 1) % size;
+}
+
+template <typename Data>
+Data& QueueVec<Data>::Head() const{
+  if(Size()<=0){
+    throw std::length_error("Queue is empty!");
+  }
+  return Elements[front];
+}
+
+template <typename Data>
+void QueueVec<Data>::Dequeue(){
+  if(Size() <= 0){
+    throw std::length_error("Queue is empty!");
+  }
+  front = (front + 1) % size;
+  if(Size() < size/4){
+    Reduce();
+  }
+}
+
+template <typename Data>
+Data QueueVec<Data>::HeadNDequeue(){
+  Data tmp = Head();
+  Dequeue();
+  return tmp;
+}
+
+template <typename Data>
+bool QueueVec<Data>::Empty() const noexcept{
+  return (front == rear);
+}
+
+template <typename Data>
+ulong QueueVec<Data>::Size() const noexcept{
+  //if(size == 0) return 0; // this won't ever get executed, it's here just in case  
+  return ((rear + size) - front) % size;
+}
+
+template <typename Data>
+void QueueVec<Data>::Clear(){
+  if(size!=4){
+    delete[] Elements;
+    Elements = new Data[4];
+    size = 4;
+  }
+  front = 0;
+  rear = 0;
+}
+
+template <typename Data>
+void QueueVec<Data>::Expand(){
+  Data* tmp = new Data[size * 2];
+  ulong current_index = front , i=0;
+  while(current_index != rear){
+    tmp[i] = Elements[current_index];
+    current_index = (current_index+1)%size;
+    ++i;
+  }
+  delete[] Elements;
+  Elements = tmp;
+  front = 0;
+  rear = i;
+  size *= 2;
+}
+
+template <typename Data>
+void QueueVec<Data>::Reduce(){
+  if(size<=4) return; // we are not going to have vectors with less than 4 Elements
+  ulong newsize = (ulong)size/2;
+  Data* tmp = new Data[newsize];
+  ulong current_index = front , i=0;
+  while(current_index != rear){
+    tmp[i] = Elements[current_index];
+    current_index = (current_index+1)%size;
+    ++i;
+  }
+  delete[] Elements;
+  Elements = tmp;
+  front = 0;
+  rear = i;
+  size = newsize;
+}
 
 }

librerie/exercise3/queue/vec/queuevec.hpp

@@ -14,82 +14,83 @@ namespace lasd {
 /* ************************************************************************** */
 
 template <typename Data>
-class QueueVec { // Must extend Queue<Data> and Vector<Data>
+class QueueVec :  virtual public Queue<Data>,
+                  virtual protected Vector<Data>{ // Must extend Queue<Data> and Vector<Data>
 
 private:
 
-  // ...
-
 protected:
 
-  // using Vector<Data>::???;
-
-  // ...
+  using Vector<Data>::Elements;
+  using Vector<Data>::size; // dimension of the array
+  ulong front = 0;
+  ulong rear = 0;
 
 public:
 
   // Default constructor
-  // QueueVec() specifier;
+  QueueVec();
 
   /* ************************************************************************ */
 
   // Specific constructor
-  // QueueVec(argument) specifiers; // A queue obtained from a LinearContainer
+  QueueVec(const LinearContainer<Data>&); // A queue obtained from a LinearContainer
 
   /* ************************************************************************ */
 
   // Copy constructor
-  // QueueVec(argument);
+  QueueVec(const QueueVec&);
 
   // Move constructor
-  // QueueVec(argument);
+  QueueVec(QueueVec&&) noexcept;
 
   /* ************************************************************************ */
 
   // Destructor
-  // ~QueueVec() specifier;
+  virtual ~QueueVec();
 
   /* ************************************************************************ */
 
   // Copy assignment
-  // type operator=(argument);
+  QueueVec& operator=(const QueueVec&);
 
   // Move assignment
-  // type operator=(argument);
+  QueueVec& operator=(QueueVec&&) noexcept;
 
   /* ************************************************************************ */
 
   // Comparison operators
-  // type operator==(argument) specifiers;
-  // type operator!=(argument) specifiers;
+  bool operator==(const QueueVec&) const noexcept;
+  bool operator!=(const QueueVec&) const noexcept;
 
   /* ************************************************************************ */
 
   // Specific member functions (inherited from Queue)
 
-  // type Enqueue(argument) specifiers; // Override Queue member (copy of the value)
-  // type Enqueue(argument) specifiers; // Override Queue member (move of the value)
-  // type Head() specifiers; // Override Queue member (must throw std::length_error when empty)
-  // type Dequeue() specifiers; // Override Queue member (must throw std::length_error when empty)
-  // type HeadNDequeue() specifiers; // Override Queue member (must throw std::length_error when empty)
+  void Enqueue(const Data&) override; // Override Queue member (copy of the value)
+  void Enqueue(Data&&) override; // Override Queue member (move of the value)
+  Data& Head() const override; // Override Queue member (must throw std::length_error when empty)
+  void Dequeue() override; // Override Queue member (must throw std::length_error when empty)
+  Data HeadNDequeue() override; // Override Queue member (must throw std::length_error when empty)
 
   /* ************************************************************************ */
 
   // Specific member functions (inherited from Container)
 
-  // type Empty() specifiers; // Override Container member
+  bool Empty() const noexcept override; // Override Container member
 
-  // type Size() specifiers; // Override Container member
+  ulong Size() const noexcept override; // Override Container member
 
-  // type Clear() specifiers; // Override Container member
+  void Clear() override; // Override Container member
 
 protected:
 
   // Auxiliary member functions
 
-  // type Expand() specifiers;
-  // type Reduce() specifiers;
-  // type SwapVectors(arguments) specifiers;
+  void Expand();
+  void Reduce();
+
+  //void SwapVectors(arguments) specifiers;
 
 };