Library 4

added previous libreries

librerie/exercise4/binarytree/binarytree.cpp

@@ -1,11 +1,607 @@
 
-// #include "..."
+#include "../queue/queue.hpp"
+#include "../queue/vec/queuevec.hpp"
+#include "../queue/lst/queuelst.hpp"
+#include "../stack/stack.hpp"
+#include "../stack/lst/stacklst.hpp"
+#include "../stack/vec/stackvec.hpp"
+#include<iostream>
 
 namespace lasd {
 
-/* ************************************************************************** */
+/* ----- begin of class BinaryTree ----- */
 
-// ...
+/* ----- begin of struct Node ----- */
+
+template <typename Data>
+bool BinaryTree<Data>::Node::operator==(const Node& toEvaluate) const noexcept{
+  return EqualNodes(*this, toEvaluate);
+}
+
+template <typename Data>
+bool BinaryTree<Data>::Node::operator!=(const Node& toEvaluate) const noexcept{
+  return !(*this == toEvaluate);
+}
+
+/* given two nodes, checks if the subtree is the same */
+template <typename Data>
+bool BinaryTree<Data>::Node::EqualNodes(const Node& n1, const Node& n2) const{
+  if(n1.data == n2.data){
+
+    if( (n1.HasLeftChild() && !n2.HasLeftChild()) || (n1.HasRightChild() && !n2.HasRightChild()) ) return false;
+
+    if(n1.HasLeftChild() && n1.HasRightChild()){
+      return( EqualNodes(n1.LeftChild(),n2.LeftChild()) && EqualNodes(n1.RightChild(),n2.RightChild()));
+    }
+    else if(n1.HasLeftChild() && !n1.HasRightChild()){
+      return( EqualNodes(n1.LeftChild(),n2.LeftChild()));
+    }
+    else if(!n1.HasLeftChild() && n1.HasRightChild()){
+      return( EqualNodes(n1.RightChild(),n2.RightChild()));
+    }
+    else{ //if leaf
+      return true;
+    }
+
+  }else{
+    return false;
+  }
+}
+
+template <typename Data>
+Data& BinaryTree<Data>::Node::Element(){
+  return this->data;
+}
+
+template <typename Data>
+const Data& BinaryTree<Data>::Node::Element() const{
+  return this->data;
+}
+
+/* ----- end of struct Node ----- */
+
+template <typename Data>
+bool BinaryTree<Data>::operator==(const BinaryTree& toCompare) const noexcept{
+  if(size!=toCompare.size) return false;
+  return(Root() == toCompare.Root());
+}
+
+template <typename Data>
+bool BinaryTree<Data>::operator!=(const BinaryTree& toCompare) const noexcept{
+  return !(*this == toCompare);
+}
+
+/* ----- Map and fold functions ----- */
+
+template <typename Data>
+void BinaryTree<Data>::MapPreOrder(const typename MappableContainer<Data>::MapFunctor function, void* par){
+  if(size == 0) return;
+  MapPreOrder(function, par, &Root());
+}
+
+template <typename Data>
+void BinaryTree<Data>::MapPostOrder(const typename MappableContainer<Data>::MapFunctor function, void* par){
+  if(size == 0) return;
+  MapPostOrder(function, par, &Root());
+}
+
+template <typename Data>
+void BinaryTree<Data>::MapInOrder(const typename MappableContainer<Data>::MapFunctor function, void* par){
+  if(size == 0) return;
+  MapInOrder(function, par, &Root());
+}
+
+template <typename Data>
+void BinaryTree<Data>::MapBreadth(const typename MappableContainer<Data>::MapFunctor function, void* par){
+  if(size == 0) return;
+  MapBreadth(function, par, &Root());
+}
+
+template <typename Data>
+void BinaryTree<Data>::FoldPreOrder(const typename FoldableContainer<Data>::FoldFunctor function, const void* par, void* acc) const{
+  if(size == 0) return;
+  FoldPreOrder(function, par, acc, &Root());
+}
+
+template <typename Data>
+void BinaryTree<Data>::FoldPostOrder(const typename FoldableContainer<Data>::FoldFunctor function, const void* par, void* acc) const{
+  if(size == 0) return;
+  FoldPostOrder(function, par, acc, &Root());
+}
+
+template <typename Data>
+void BinaryTree<Data>::FoldInOrder(const typename FoldableContainer<Data>::FoldFunctor function, const void* par, void* acc) const{
+  if(size == 0) return;
+  FoldInOrder(function, par, acc, &Root());
+}
+
+template <typename Data>
+void BinaryTree<Data>::FoldBreadth(const typename FoldableContainer<Data>::FoldFunctor function, const void* par, void* acc) const{
+  if(size == 0) return;
+  FoldBreadth(function, par, acc, &Root());
+}
+
+/* ----- Auxiliary map and fold functions ----- */
+
+template <typename Data>
+void BinaryTree<Data>::MapPreOrder(const typename MappableContainer<Data>::MapFunctor function, void* par, Node* node){
+  if(node != nullptr){
+      function(node->Element(), par);
+      if(node->HasLeftChild()){
+          MapPreOrder(function, par, &(node->LeftChild()));
+      }
+      if(node->HasRightChild()){
+          MapPreOrder(function, par, &(node->RightChild()));
+      }
+  }
+}
+
+template <typename Data>
+void BinaryTree<Data>::MapPostOrder(const typename MappableContainer<Data>::MapFunctor function, void* par, Node* node){
+  if(node != nullptr){
+    if(node->HasLeftChild()){
+        MapPostOrder(function, par, &(node->LeftChild()));
+    }
+    if(node->HasRightChild()){
+        MapPostOrder(function, par, &(node->RightChild()));
+    }
+    function(node->Element(), par);
+  }
+}
+
+template <typename Data>
+void BinaryTree<Data>::MapInOrder(const typename MappableContainer<Data>::MapFunctor function, void* par, Node* node){
+  if(node != nullptr){
+    if(node->HasLeftChild()){
+      MapInOrder(function, par, &(node->LeftChild()));
+    }
+    function(node->Element(), par);
+    if(node->HasRightChild()){
+      MapInOrder(function, par, &(node->RightChild()));
+    }
+  }
+}
+
+template <typename Data>
+void BinaryTree<Data>::MapBreadth(const typename MappableContainer<Data>::MapFunctor function, void* par, Node* node){
+  QueueLst<struct Node*> toVisit;
+  if(node != nullptr){
+    toVisit.Enqueue(node);
+    while(!toVisit.Empty()){
+      function(toVisit.Head()->Element(), par);
+
+      if(toVisit.Head()->HasLeftChild()){
+        toVisit.Enqueue(&(toVisit.Head()->LeftChild()));
+      }
+      if(toVisit.Head()->HasRightChild()){
+        toVisit.Enqueue(&(toVisit.Head()->RightChild()));
+      }
+      toVisit.Dequeue();
+    }
+  }
+}
+
+template <typename Data>
+void BinaryTree<Data>::FoldPreOrder(const typename FoldableContainer<Data>::FoldFunctor function, const void* par, void* acc, const Node* node) const{
+  if(node != nullptr){
+        function(node->Element(), par, acc);
+        if(node->HasLeftChild()){
+            FoldPreOrder(function, par, acc, &(node->LeftChild()));
+        }
+        if(node->HasRightChild()){
+            FoldPreOrder(function, par, acc, &(node->RightChild()));
+        }
+  }
+}
+
+template <typename Data>
+void BinaryTree<Data>::FoldPostOrder(const typename FoldableContainer<Data>::FoldFunctor function, const void* par, void* acc, const Node* node) const{
+  if(node != nullptr){
+    if(node->HasLeftChild()){
+      FoldPostOrder(function, par, acc, &(node->LeftChild()));
+    }
+    if(node->HasRightChild()){
+      FoldPostOrder(function, par, acc, &(node->RightChild()));
+    }
+    function(node->Element(), par, acc);
+  }
+}
+
+template <typename Data>
+void BinaryTree<Data>::FoldInOrder(const typename FoldableContainer<Data>::FoldFunctor function, const void* par, void* acc, const Node* node) const{
+  if(node != nullptr){
+    if(node->HasLeftChild()){
+      FoldInOrder(function, par, acc, &(node->LeftChild()));
+    }
+    function(node->Element(), par, acc);
+    if(node->HasRightChild()){
+        FoldInOrder(function, par, acc, &(node->RightChild()));
+    }
+  }
+}
+
+template <typename Data>
+void BinaryTree<Data>::FoldBreadth(const typename FoldableContainer<Data>::FoldFunctor function, const void* par, void* acc, Node* node) const{
+  QueueLst<BinaryTree<Data>::Node*> toVisit;
+  if(node != nullptr){
+    toVisit.Enqueue(node);
+    while(!toVisit.Empty()){
+      function(toVisit.Head()->Element(), par, acc);
+
+      if(toVisit.Head()->HasLeftChild()){
+        toVisit.Enqueue(&(toVisit.Head()->LeftChild()));
+      }
+      if(toVisit.Head()->HasRightChild()){
+        toVisit.Enqueue(&(toVisit.Head()->RightChild()));
+      }
+      toVisit.Dequeue();
+    }
+  }
+}
+
+/* ----- end of class BinaryTree ----- */
+
+/* ----- begin of class BTPreOrderIterator ----- */
+
+template <typename Data>
+BTPreOrderIterator<Data>::BTPreOrderIterator(const BinaryTree<Data>& tree){
+  if(tree.Size() > 0)
+    curr = &tree.Root();
+  else
+    curr = nullptr;
+}
+
+template <typename Data>
+BTPreOrderIterator<Data>::BTPreOrderIterator(const BTPreOrderIterator& itr){
+  curr = itr.curr;
+  stack = itr.stack;
+}
+
+template <typename Data>
+BTPreOrderIterator<Data>::BTPreOrderIterator(BTPreOrderIterator&& itr) noexcept{
+  std::swap(curr, itr.curr);
+  std::swap(stack, itr.stack);
+}
+
+template <typename Data>
+BTPreOrderIterator<Data>::~BTPreOrderIterator(){
+  stack.Clear();
+  curr = nullptr;
+}
+
+template <typename Data>
+BTPreOrderIterator<Data>& BTPreOrderIterator<Data>::operator=(const BTPreOrderIterator& itr){
+  curr = itr.curr;
+  stack = itr.stack;
+  return *this;
+}
+
+template <typename Data>
+BTPreOrderIterator<Data>& BTPreOrderIterator<Data>::operator=(BTPreOrderIterator&& itr) noexcept{
+  std::swap(curr, itr.curr);
+  std::swap(stack, itr.stack);
+  return *this;
+}
+
+template <typename Data>
+bool BTPreOrderIterator<Data>::operator==(const BTPreOrderIterator& itr) const noexcept{
+  return ( curr==itr.curr && stack==itr.stack );
+}
+
+template <typename Data>
+bool BTPreOrderIterator<Data>::operator!=(const BTPreOrderIterator& itr) const noexcept{
+  return !(*this == itr);
+}
+
+template <typename Data>
+Data& BTPreOrderIterator<Data>::operator*() const{
+  if(Terminated()) throw std::out_of_range("Iterator is terminated!");
+  return curr->Element();
+}
+
+template <typename Data>
+bool BTPreOrderIterator<Data>::Terminated() const noexcept{
+  return (curr==nullptr);
+}
+
+template <typename Data>
+void BTPreOrderIterator<Data>::operator++(){
+  if(Terminated()) throw std::out_of_range("Iterator is terminated!");
+
+  if(curr->HasLeftChild()){
+
+    if( curr->HasRightChild() ){
+      stack.Push(&(curr->RightChild()));
+    }
+
+    curr = &(curr->LeftChild());
+
+  }else if(curr->HasRightChild()){
+    curr = &curr->RightChild();
+  }
+  else{ // is leaf
+    if(stack.Empty()){
+      curr = nullptr;
+    }else{
+      curr = stack.TopNPop();
+    }
+  }
+}
+
+/* ----- end of class BTPreOrderIterator ----- */
+
+/* ----- begin of class BTPostOrderIterator ----- */
+
+template <typename Data>
+struct BinaryTree<Data>::Node* BTPostOrderIterator<Data>::DeepestLeftLeaf(struct BinaryTree<Data>::Node* node){
+  if(node->HasLeftChild()){
+    stack.Push(node);
+    return DeepestLeftLeaf(&(node->LeftChild()));
+  }
+  else if(node->HasRightChild()){
+    stack.Push(node);
+    return DeepestLeftLeaf(&(node->RightChild()));
+  }
+  else
+    return node;
+}
+
+template <typename Data>
+BTPostOrderIterator<Data>::BTPostOrderIterator(const BinaryTree<Data>& tree){
+  if(tree.Size() > 0)
+    curr = DeepestLeftLeaf(&tree.Root());
+  else
+    curr = nullptr;
+}
+
+template <typename Data>
+BTPostOrderIterator<Data>::BTPostOrderIterator(const BTPostOrderIterator& itr){
+  curr = itr.curr;
+  stack = itr.stack;
+}
+
+template <typename Data>
+BTPostOrderIterator<Data>::BTPostOrderIterator(BTPostOrderIterator&& itr) noexcept{
+  std::swap(curr, itr.curr);
+  std::swap(stack, itr.stack);
+}
+
+template <typename Data>
+BTPostOrderIterator<Data>::~BTPostOrderIterator(){
+  curr = nullptr;
+  stack.Clear();
+}
+
+template <typename Data>
+BTPostOrderIterator<Data>& BTPostOrderIterator<Data>::operator=(const BTPostOrderIterator& itr){
+  curr = itr.curr;
+  stack = itr.stack;
+  return *this;
+}
+
+template <typename Data>
+BTPostOrderIterator<Data>& BTPostOrderIterator<Data>::operator=(BTPostOrderIterator&& itr) noexcept{
+  std::swap(curr, itr.curr);
+  std::swap(stack, itr.stack);
+  return *this;
+}
+
+template <typename Data>
+bool BTPostOrderIterator<Data>::operator==(const BTPostOrderIterator& itr) const noexcept{
+  return (curr == itr.curr && stack == itr.stack );
+}
+
+template <typename Data>
+bool BTPostOrderIterator<Data>::operator!=(const BTPostOrderIterator& itr) const noexcept{
+  return !(*this == itr);
+}
+
+template <typename Data>
+Data& BTPostOrderIterator<Data>::operator*() const{
+  if(Terminated()) throw std::out_of_range("Iterator is terminated!");
+  return curr->Element();
+}
+
+template <typename Data>
+bool BTPostOrderIterator<Data>::Terminated() const noexcept{
+  return (curr == nullptr);
+}
+
+template <typename Data>
+void BTPostOrderIterator<Data>::operator++(){
+  /*
+  * If we're coming from the left then we have to analyze the tree on the right
+  * (if existent). Otherwise we just top 'n' pop.
+  */
+
+  if(Terminated()) throw std::out_of_range("Iterator is terminated!");
+
+  if(stack.Empty()){
+    curr = nullptr;
+  }else{
+    if( curr == &((stack.Top())->LeftChild()) ){
+      if( (stack.Top())->HasRightChild()   ){
+        curr = DeepestLeftLeaf(&((stack.Top())->RightChild()));
+      }else{
+        curr = stack.TopNPop();
+      }
+    }else{
+      curr = stack.TopNPop();
+    }
+  }
+}
+
+/* ----- end of class BTPostOrderIterator ----- */
+
+/* ----- begin of class BTInOrderIterator ----- */
+
+template <typename Data>
+struct BinaryTree<Data>::Node* BTInOrderIterator<Data>::MostLeftNode(struct BinaryTree<Data>::Node& root){
+  if(root.HasLeftChild()){
+    stack.Push(&root);
+    return MostLeftNode(root.LeftChild());
+  }else{
+    return &root;
+  }
+}
+
+template <typename Data>
+BTInOrderIterator<Data>::BTInOrderIterator(const BinaryTree<Data>& tree){
+  if(tree.Size() > 0)
+    curr = MostLeftNode(tree.Root());
+  else
+    curr = nullptr;
+}
+
+template <typename Data>
+BTInOrderIterator<Data>::BTInOrderIterator(const BTInOrderIterator& itr){
+  curr = itr.curr;
+  stack = itr.stack;
+}
+
+template <typename Data>
+BTInOrderIterator<Data>::BTInOrderIterator(BTInOrderIterator&& toMove) noexcept{
+  std::move(curr, toMove.curr);
+  std::move(stack, toMove.stack);
+}
+
+template <typename Data>
+BTInOrderIterator<Data>::~BTInOrderIterator(){
+   stack.Clear();
+   curr = nullptr;
+ }
+
+template <typename Data>
+BTInOrderIterator<Data>& BTInOrderIterator<Data>::operator=(const BTInOrderIterator& itr){
+  curr = itr.curr;
+  stack = itr.stack;
+  return *this;
+}
+
+template <typename Data>
+BTInOrderIterator<Data>& BTInOrderIterator<Data>::operator=(BTInOrderIterator&& toMove) noexcept{
+  std::move(curr, toMove.curr);
+  std::move(stack, toMove.stack);
+  return *this;
+}
+
+template <typename Data>
+bool BTInOrderIterator<Data>::operator==(const BTInOrderIterator& itr) const noexcept{
+  return (curr == itr.curr && stack == itr.stack );
+}
+
+template <typename Data>
+bool BTInOrderIterator<Data>::operator!=(const BTInOrderIterator& itr) const noexcept{
+  return !(*this == itr);
+}
+
+template <typename Data>
+Data& BTInOrderIterator<Data>::operator*() const{
+  if(Terminated()) throw std::out_of_range("Iterator is terminated!");
+  return curr->Element();
+}
+
+template <typename Data>
+bool BTInOrderIterator<Data>::Terminated() const noexcept{
+  return (curr == nullptr);
+}
+
+template <typename Data>
+void BTInOrderIterator<Data>::operator++(){
+  if(Terminated()) throw std::out_of_range("Iterator is terminated!");
+
+  if(curr->HasRightChild()){
+    curr = MostLeftNode(curr->RightChild());
+  }else{
+    if(stack.Empty()){
+      curr = nullptr;
+    }else{
+      curr = stack.TopNPop();
+    }
+  }
+}
+
+/* ----- end of class BTInOrderIterator ----- */
+
+/* ----- begin of class BTBreadthIteratorOrderIterator ----- */
+
+template <typename Data>
+BTBreadthIterator<Data>::BTBreadthIterator(const BinaryTree<Data>& tree){
+  if(tree.Size() > 0)
+    curr = &(tree.Root());
+  else
+    curr = nullptr;
+}
+
+template <typename Data>
+BTBreadthIterator<Data>::BTBreadthIterator(const BTBreadthIterator& itr){
+  curr = itr.curr;
+  queue = itr.queue;
+}
+
+template <typename Data>
+BTBreadthIterator<Data>::BTBreadthIterator(BTBreadthIterator&& itr) noexcept{
+  std::swap(curr, itr.curr);
+  std::swap(queue, itr.queue);
+}
+
+template <typename Data>
+BTBreadthIterator<Data>::~BTBreadthIterator(){
+  curr = nullptr;
+  queue.Clear();
+}
+
+template <typename Data>
+BTBreadthIterator<Data>& BTBreadthIterator<Data>::operator=(const BTBreadthIterator& itr){
+  curr = itr.curr;
+  queue = itr.queue;
+  return *this;
+}
+
+template <typename Data>
+BTBreadthIterator<Data>& BTBreadthIterator<Data>::operator=(BTBreadthIterator&& itr) noexcept{
+  std::swap(curr, itr.curr);
+  std::swap(queue, itr.queue);
+  return *this;
+}
+
+template <typename Data>
+bool BTBreadthIterator<Data>::operator==(const BTBreadthIterator& itr) const noexcept{
+  return ( curr==itr.curr && queue==itr.queue );
+}
+
+template <typename Data>
+bool BTBreadthIterator<Data>::operator!=(const BTBreadthIterator& itr) const noexcept{
+  return !(*this == itr);
+}
+
+template <typename Data>
+Data& BTBreadthIterator<Data>::operator*() const{
+  if(Terminated()) throw std::out_of_range("Iterator is terminated!");
+  return curr->Element();
+}
+
+template <typename Data>
+bool BTBreadthIterator<Data>::Terminated() const noexcept{
+  return curr == nullptr;
+}
+
+template <typename Data>
+void BTBreadthIterator<Data>::operator++(){
+  if(Terminated()) throw std::out_of_range("Iterator is terminated!");
+
+  if(curr->HasLeftChild()){
+    queue.Enqueue(&(curr->LeftChild()));
+  }
+  if(curr->HasRightChild()){
+    queue.Enqueue(&(curr->RightChild()));
+  }
+  if(!queue.Empty()){
+    curr = queue.HeadNDequeue();
+  }else{
+    curr = nullptr;
+  }
+}
 
 /* ************************************************************************** */
 

librerie/exercise4/binarytree/binarytree.hpp

@@ -2,32 +2,25 @@
 #ifndef BINARYTREE_HPP
 #define BINARYTREE_HPP
 
-/* ************************************************************************** */
-
 #include "../container/container.hpp"
 
 #include "../iterator/iterator.hpp"
 
-// #include "..."
+#include "../queue/queue.hpp"
+#include "../queue/vec/queuevec.hpp"
+#include "../queue/lst/queuelst.hpp"
 
-/* ************************************************************************** */
+#include "../stack/stack.hpp"
+#include "../stack/lst/stacklst.hpp"
+#include "../stack/vec/stackvec.hpp"
 
 namespace lasd {
 
-/* ************************************************************************** */
-
 template <typename Data>
-class BinaryTree { // Must extend InOrder/BreadthMappableContainer<Data> and InOrder/BreadthFoldableContainer<Data>
+class BinaryTree :  virtual public InOrderMappableContainer<Data>,
-
+                    virtual public BreadthMappableContainer<Data>,
-private:
+                    virtual public InOrderFoldableContainer<Data>,
-
+                    virtual public BreadthFoldableContainer<Data>{ // Must extend InOrder/BreadthMappableContainer<Data> and InOrder/BreadthFoldableContainer<Data>
-  // ...
-
-protected:
-
-  // using InOrder/BreadthMappableContainer<Data>::???;
-
-  // ...
 
 public:
 
@@ -35,404 +28,221 @@ public:
 
   private:
 
-    // ...
-
   protected:
+    Data data;
+    // Comparison operators
+    bool operator==(const Node&) const noexcept; // Comparison of abstract types is possible, but should not be visible.
+    bool operator!=(const Node&) const noexcept; // Comparison of abstract types is possible, but should not be visible.
 
-    // ...
+    bool EqualNodes(const Node&, const Node&) const;
 
   public:
 
-    // friend class BinaryTree<Data>;
+    friend class BinaryTree<Data>;
-
-    /* ********************************************************************** */
 
     // Destructor
-    // ~Node() specifiers
+    virtual ~Node() = default;
-
-    /* ********************************************************************** */
 
     // Copy assignment
-    // type operator=(argument); // Copy assignment of abstract types should not be possible.
+    Node& operator=(const Node&) = delete; // Copy assignment of abstract types should not be possible.
 
     // Move assignment
-    // type operator=(argument); // Move assignment of abstract types should not be possible.
+    Node& operator=(Node&&) noexcept = delete; // Move assignment of abstract types should not be possible.
-
-    /* ********************************************************************** */
-
-    // Comparison operators
-    // type operator==(argument) specifiers; // Comparison of abstract types is possible, but should not be visible.
-    // type operator!=(argument) specifiers; // Comparison of abstract types is possible, but should not be visible.
-
-    /* ********************************************************************** */
 
     // Specific member functions
+    Data& Element(); // Mutable access to the element (concrete function should not throw exceptions)
+    const Data& Element() const; // Immutable access to the element (concrete function should not throw exceptions)
 
-    // type Element() specifiers; // Mutable access to the element (concrete function should not throw exceptions)
+    virtual bool IsLeaf() const noexcept = 0; // (concrete function should not throw exceptions)
-    // type Element() specifiers; // Immutable access to the element (concrete function should not throw exceptions)
+    virtual bool HasLeftChild() const noexcept = 0; // (concrete function should not throw exceptions)
+    virtual bool HasRightChild() const noexcept = 0; // (concrete function should not throw exceptions)
 
-    // type IsLeaf() specifiers; // (concrete function should not throw exceptions)
+    virtual Node& LeftChild() const = 0; // (concrete function must throw std::out_of_range when not existent)
-    // type HasLeftChild() specifiers; // (concrete function should not throw exceptions)
+    virtual Node& RightChild() const = 0; // (concrete function must throw std::out_of_range when not existent)
-    // type HasRightChild() specifiers; // (concrete function should not throw exceptions)
-
-    // type LeftChild() specifiers; // (concrete function must throw std::out_of_range when not existent)
-    // type RightChild() specifiers; // (concrete function must throw std::out_of_range when not existent)
 
   };
 
-  /* ************************************************************************ */
+  virtual ~BinaryTree() = default;
 
-  // Destructor
+  BinaryTree& operator=(const BinaryTree&) = delete; // Copy assignment of abstract types should not be possible.
-  // ~BinaryTree() specifiers
+  BinaryTree& operator=(BinaryTree&&) noexcept = delete; // Move assignment of abstract types should not be possible.
 
-  /* ************************************************************************ */
+  bool operator==(const BinaryTree&) const noexcept; // Comparison of abstract binary tree is possible.
+  bool operator!=(const BinaryTree&) const noexcept; // Comparison of abstract binary tree is possible.
 
-  // Copy assignment
+  virtual Node& Root() const = 0; // (concrete function must throw std::length_error when empty)
-  // type operator=(argument); // Copy assignment of abstract types should not be possible.
 
-  // Move assignment
+  /* ----- Map and fold functions ----- */
-  // type operator=(argument); // Move assignment of abstract types should not be possible.
 
-  /* ************************************************************************ */
+  virtual void MapPreOrder(const typename MappableContainer<Data>::MapFunctor, void*) override; // Override MappableContainer member
+  virtual void MapPostOrder(const typename MappableContainer<Data>::MapFunctor, void*) override; // Override MappableContainer member
+  virtual void MapInOrder(const typename MappableContainer<Data>::MapFunctor, void*) override; // Override InOrderMappableContainer member
+  virtual void MapBreadth(const typename MappableContainer<Data>::MapFunctor, void*) override; // Override BreadthMappableContainer member
 
-  // Comparison operators
+  virtual void FoldPreOrder(const typename FoldableContainer<Data>::FoldFunctor, const void*, void*) const override; // Override FoldableContainer member
-  // type operator==(argument) specifiers; // Comparison of abstract binary tree is possible.
+  virtual void FoldPostOrder(const typename FoldableContainer<Data>::FoldFunctor, const void*, void*) const override; // Override FoldableContainer member
-  // type operator!=(argument) specifiers; // Comparison of abstract binary tree is possible.
+  virtual void FoldInOrder(const typename FoldableContainer<Data>::FoldFunctor, const void*, void*) const override; // Override InOrderFoldableContainer member
-
+  virtual void FoldBreadth(const typename FoldableContainer<Data>::FoldFunctor, const void*, void*) const override; // Override BreadthFoldableContainer member
-  /* ************************************************************************ */
-
-  // Specific member functions
-
-  // type Root() specifiers; // (concrete function must throw std::length_error when empty)
-
-  /* ************************************************************************ */
-
-  // Specific member functions (inherited from MappableContainer)
-
-  // using typename MappableContainer<Data>::MapFunctor;
-
-  // type MapPreOrder(arguments) specifiers; // Override MappableContainer member
-  // type MapPostOrder(arguments) specifiers; // Override MappableContainer member
-
-  /* ************************************************************************ */
-
-  // Specific member functions (inherited from FoldableContainer)
-
-  // using typename FoldableContainer<Data>::FoldFunctor;
-
-  // type FoldPreOrder(arguments) specifiers; // Override FoldableContainer member
-  // type FoldPostOrder(arguments) specifiers; // Override FoldableContainer member
-
-  /* ************************************************************************ */
-
-  // Specific member functions (inherited from InOrderMappableContainer)
-
-  // type MapInOrder(arguments) specifiers; // Override InOrderMappableContainer member
-
-  /* ************************************************************************ */
-
-  // Specific member functions (inherited from InOrderFoldableContainer)
-
-  // type FoldInOrder(arguments) specifiers; // Override InOrderFoldableContainer member
-
-  /* ************************************************************************ */
-
-  // Specific member functions (inherited from BreadthMappableContainer)
-
-  // type MapBreadth(arguments) specifiers; // Override BreadthMappableContainer member
-
-  /* ************************************************************************ */
-
-  // Specific member functions (inherited from BreadthFoldableContainer)
-
-  // type FoldBreadth(arguments) specifiers; // Override BreadthFoldableContainer member
 
 protected:
 
-  // Auxiliary member functions (for MappableContainer)
+  using BreadthMappableContainer<Data>::size;
 
-  // type MapPreOrder(arguments) specifiers; // Accessory function executing from one node of the tree
+  /* ----- Auxiliary map and fold functions ----- */
-  // type MapPostOrder(arguments) specifiers; // Accessory function executing from one node of the tree
 
-  /* ************************************************************************ */
+  void MapPreOrder(const typename MappableContainer<Data>::MapFunctor, void*, Node*); // Accessory function executing from one node of the tree
+  void MapPostOrder(const typename MappableContainer<Data>::MapFunctor, void*, Node*); // Accessory function executing from one node of the tree
+  void MapInOrder(const typename MappableContainer<Data>::MapFunctor, void*, Node*); // Accessory function executing from one node of the tree
+  void MapBreadth(const typename MappableContainer<Data>::MapFunctor, void*, Node*); // Accessory function executing from one node of the tree
 
-  // Auxiliary member functions (for FoldableContainer)
+  void FoldPreOrder(const typename FoldableContainer<Data>::FoldFunctor, const void*, void*, const Node*) const; // Accessory function executing from one node of the tree
+  void FoldPostOrder(const typename FoldableContainer<Data>::FoldFunctor, const void*, void*, const Node*) const; // Accessory function executing from one node of the tree
+  void FoldInOrder(const typename FoldableContainer<Data>::FoldFunctor, const void*, void*, const Node*) const; // Accessory function executing from one node of the tree
+  void FoldBreadth(const typename FoldableContainer<Data>::FoldFunctor, const void*, void*, Node*) const; // Accessory function executing from one node of the tree
+};
 
-  // type FoldPreOrder(arguments) specifiers; // Accessory function executing from one node of the tree
-  // type FoldPostOrder(arguments) specifiers; // Accessory function executing from one node of the tree
 
-  /* ************************************************************************ */
+template <typename Data>
+class BTPreOrderIterator : virtual public ForwardIterator<Data> { // Must extend ForwardIterator<Data>
 
-  // Auxiliary member functions (for InOrderMappableContainer)
+protected:
 
-  // type MapInOrder(arguments) specifiers; // Accessory function executing from one node of the tree
+  struct BinaryTree<Data>::Node* curr = nullptr;
+  StackLst<struct BinaryTree<Data>::Node*> stack;
 
-  /* ************************************************************************ */
+public:
 
-  // Auxiliary member functions (for InOrderFoldableContainer)
+  virtual ~BTPreOrderIterator();
 
-  // type FoldInOrder(arguments) specifiers; // Accessory function executing from one node of the tree
+  BTPreOrderIterator(const BinaryTree<Data>&); // An iterator over a given binary tree
+  BTPreOrderIterator(const BTPreOrderIterator&);
+  BTPreOrderIterator(BTPreOrderIterator&&) noexcept;
 
-  /* ************************************************************************ */
+  BTPreOrderIterator& operator=(const BTPreOrderIterator&);
+  BTPreOrderIterator& operator=(BTPreOrderIterator&&) noexcept;
 
-  // Auxiliary member functions (for BreadthMappableContainer)
+  bool operator==(const BTPreOrderIterator&) const noexcept;
+  bool operator!=(const BTPreOrderIterator&) const noexcept;
 
-  // type MapBreadth(arguments) specifiers; // Accessory function executing from one node of the tree
+  // Specific member functions (inherited from Iterator)
 
-  /* ************************************************************************ */
+  Data& operator*() const; // (throw std::out_of_range when terminated)
+  bool Terminated() const noexcept; // (should not throw exceptions)
 
-  // Auxiliary member functions (for BreadthFoldableContainer)
+  // Specific member functions (inherited from ForwardIterator)
 
-  // type FoldBreadth(arguments) specifiers; // Accessory function executing from one node of the tree
+  void operator++(); // (throw std::out_of_range when terminated)
 
 };
 
 /* ************************************************************************** */
 
 template <typename Data>
-class BTPreOrderIterator { // Must extend ForwardIterator<Data>
+class BTPostOrderIterator : virtual public ForwardIterator<Data>  { // Must extend ForwardIterator<Data>
-
-private:
-
-  // ...
 
 protected:
 
-  // ...
+  struct BinaryTree<Data>::Node* curr = nullptr;
+  StackLst<struct BinaryTree<Data>::Node*> stack;
+
+  struct BinaryTree<Data>::Node* DeepestLeftLeaf(struct BinaryTree<Data>::Node*);
 
 public:
 
-  // Specific constructors
+  BTPostOrderIterator(const BinaryTree<Data>&); // An iterator over a given binary tree
-  // BTPreOrderIterator(argument) specifiers; // An iterator over a given binary tree
+  BTPostOrderIterator(const BTPostOrderIterator&);
+  BTPostOrderIterator(BTPostOrderIterator&&) noexcept;
 
-  /* ************************************************************************ */
+  virtual ~BTPostOrderIterator();
 
-  // Copy constructor
-  // BTPreOrderIterator(argument) specifiers;
 
-  // Move constructor
+  BTPostOrderIterator& operator=(const BTPostOrderIterator&);
-  // BTPreOrderIterator(argument) specifiers;
+  BTPostOrderIterator& operator=(BTPostOrderIterator&&) noexcept;
 
-  /* ************************************************************************ */
+  bool operator==(const BTPostOrderIterator&) const noexcept;
-
+  bool operator!=(const BTPostOrderIterator&) const noexcept;
-  // Destructor
-  // ~BTPreOrderIterator() specifiers;
-
-  /* ************************************************************************ */
-
-  // Copy assignment
-  // type operator=(argument) specifiers;
-
-  // Move assignment
-  // type operator=(argument) specifiers;
-
-  /* ************************************************************************ */
-
-  // Comparison operators
-  // type operator==(argument) specifiers;
-  // type operator!=(argument) specifiers;
-
-  /* ************************************************************************ */
 
   // Specific member functions (inherited from Iterator)
 
-  // type operator*() specifiers; // (throw std::out_of_range when terminated)
+  Data& operator*() const; // (throw std::out_of_range when terminated)
-
+  bool Terminated() const noexcept; // (should not throw exceptions)
-  // type Terminated() specifiers; // (should not throw exceptions)
-
-  /* ************************************************************************ */
 
   // Specific member functions (inherited from ForwardIterator)
 
-  // type operator++() specifiers; // (throw std::out_of_range when terminated)
+  void operator++(); // (throw std::out_of_range when terminated)
 
 };
 
 /* ************************************************************************** */
 
 template <typename Data>
-class BTPostOrderIterator { // Must extend ForwardIterator<Data>
+class BTInOrderIterator : virtual public ForwardIterator<Data> { // Must extend ForwardIterator<Data>
-
-private:
-
-  // ...
 
 protected:
 
-  // ...
+  struct BinaryTree<Data>::Node* curr = nullptr;
+  StackLst<struct BinaryTree<Data>::Node*> stack;
+
+  struct BinaryTree<Data>::Node* MostLeftNode(struct BinaryTree<Data>::Node&);
 
 public:
 
-  // Specific constructors
+  BTInOrderIterator(const BinaryTree<Data>&); // An iterator over a given binary tree
-  // BTPostOrderIterator(argument) specifiers; // An iterator over a given binary tree
+  BTInOrderIterator(const BTInOrderIterator&);
+  BTInOrderIterator(BTInOrderIterator&&) noexcept;
 
-  /* ************************************************************************ */
+  virtual ~BTInOrderIterator();
 
-  // Copy constructor
+  BTInOrderIterator& operator=(const BTInOrderIterator&);
-  // BTPostOrderIterator(argument) specifiers;
+  BTInOrderIterator& operator=(BTInOrderIterator&&) noexcept;
 
-  // Move constructor
+  bool operator==(const BTInOrderIterator&) const noexcept;
-  // BTPostOrderIterator(argument) specifiers;
+  bool operator!=(const BTInOrderIterator&) const noexcept;
-
-  /* ************************************************************************ */
-
-  // Destructor
-  // ~BTPostOrderIterator() specifiers;
-
-  /* ************************************************************************ */
-
-  // Copy assignment
-  // type operator=(argument) specifiers;
-
-  // Move assignment
-  // type operator=(argument) specifiers;
-
-  /* ************************************************************************ */
-
-  // Comparison operators
-  // type operator==(argument) specifiers;
-  // type operator!=(argument) specifiers;
-
-  /* ************************************************************************ */
 
   // Specific member functions (inherited from Iterator)
 
-  // type operator*() specifiers; // (throw std::out_of_range when terminated)
+  Data& operator*() const; // (throw std::out_of_range when terminated)
-
+  bool Terminated() const noexcept; // (should not throw exceptions)
-  // type Terminated() specifiers; // (should not throw exceptions)
-
-  /* ************************************************************************ */
 
   // Specific member functions (inherited from ForwardIterator)
 
-  // type operator++() specifiers; // (throw std::out_of_range when terminated)
+  void operator++(); // (throw std::out_of_range when terminated)
 
 };
 
-/* ************************************************************************** */
-
 template <typename Data>
-class BTInOrderIterator { // Must extend ForwardIterator<Data>
+class BTBreadthIterator : virtual public ForwardIterator<Data>{ // Must extend ForwardIterator<Data>
-
-private:
-
-  // ...
 
 protected:
 
-  // ...
+  struct BinaryTree<Data>::Node* curr = nullptr;
+  QueueVec<struct BinaryTree<Data>::Node*> queue;
 
 public:
 
-  // Specific constructors
+  BTBreadthIterator(const BinaryTree<Data>&); // An iterator over a given binary tree
-  // BTInOrderIterator(argument) specifiers; // An iterator over a given binary tree
+  BTBreadthIterator(const BTBreadthIterator&);
+  BTBreadthIterator(BTBreadthIterator&&) noexcept;
 
-  /* ************************************************************************ */
+  virtual ~BTBreadthIterator();
 
-  // Copy constructor
+  BTBreadthIterator& operator=(const BTBreadthIterator&);
-  // BTInOrderIterator(argument) specifiers;
+  BTBreadthIterator& operator=(BTBreadthIterator&&) noexcept;
 
-  // Move constructor
+  bool operator==(const BTBreadthIterator&) const noexcept;
-  // BTInOrderIterator(argument) specifiers;
+  bool operator!=(const BTBreadthIterator&) const noexcept;
-
-  /* ************************************************************************ */
-
-  // Destructor
-  // ~BTInOrderIterator() specifiers;
-
-  /* ************************************************************************ */
-
-  // Copy assignment
-  // type operator=(argument) specifiers;
-
-  // Move assignment
-  // type operator=(argument) specifiers;
-
-  /* ************************************************************************ */
-
-  // Comparison operators
-  // type operator==(argument) specifiers;
-  // type operator!=(argument) specifiers;
-
-  /* ************************************************************************ */
 
   // Specific member functions (inherited from Iterator)
 
-  // type operator*() specifiers; // (throw std::out_of_range when terminated)
+  Data& operator*() const; // (throw std::out_of_range when terminated)
-
+  bool Terminated() const noexcept; // (should not throw exceptions)
-  // type Terminated() specifiers; // (should not throw exceptions)
-
-  /* ************************************************************************ */
 
   // Specific member functions (inherited from ForwardIterator)
 
-  // type operator++() specifiers; // (throw std::out_of_range when terminated)
+  void operator++(); // (throw std::out_of_range when terminated)
 
 };
 
-/* ************************************************************************** */
-
-template <typename Data>
-class BTBreadthIterator { // Must extend ForwardIterator<Data>
-
-private:
-
-  // ...
-
-protected:
-
-  // ...
-
-public:
-
-  // Specific constructors
-  // BTBreadthIterator(argument) specifiers; // An iterator over a given binary tree
-
-  /* ************************************************************************ */
-
-  // Copy constructor
-  // BTBreadthIterator(argument) specifiers;
-
-  // Move constructor
-  // BTBreadthIterator(argument) specifiers;
-
-  /* ************************************************************************ */
-
-  // Destructor
-  // ~BTBreadthIterator() specifiers;
-
-  /* ************************************************************************ */
-
-  // Copy assignment
-  // type operator=(argument) specifiers;
-
-  // Move assignment
-  // type operator=(argument) specifiers;
-
-  /* ************************************************************************ */
-
-  // Comparison operators
-  // type operator==(argument) specifiers;
-  // type operator!=(argument) specifiers;
-
-  /* ************************************************************************ */
-
-  // Specific member functions (inherited from Iterator)
-
-  // type operator*() specifiers; // (throw std::out_of_range when terminated)
-
-  // type Terminated() specifiers; // (should not throw exceptions)
-
-  /* ************************************************************************ */
-
-  // Specific member functions (inherited from ForwardIterator)
-
-  // type operator++() specifiers; // (throw std::out_of_range when terminated)
-
-};
-
-/* ************************************************************************** */
-
 }
 
 #include "binarytree.cpp"

librerie/exercise4/binarytree/lnk/binarytreelnk.cpp

@@ -1,10 +1,170 @@
 
 namespace lasd {
 
-/* ************************************************************************** */
+/* ----- begin of struct NodeLnk ----- */
 
-// ...
+template <typename Data>
+struct BinaryTreeLnk<Data>::NodeLnk& BinaryTreeLnk<Data>::NodeLnk::operator=(const BinaryTreeLnk<Data>::NodeLnk& node){
+  data = node.data;
+  left = node.left;
+  right = node.right;
+  return *this;
+}
 
-/* ************************************************************************** */
+template <typename Data>
+struct BinaryTreeLnk<Data>::NodeLnk& BinaryTreeLnk<Data>::NodeLnk::operator=(NodeLnk&& node) noexcept{
+  std::swap(data, node.data);
+  std::swap(left, node.left);
+  std::swap(right, node.right);
+  return *this;
+}
+
+template <typename Data>
+bool BinaryTreeLnk<Data>::NodeLnk::IsLeaf() const noexcept{
+  return (left==nullptr && right==nullptr);
+}
+
+template <typename Data>
+bool BinaryTreeLnk<Data>::NodeLnk::HasLeftChild() const noexcept{
+  return (left!=nullptr);
+}
+
+template <typename Data>
+bool BinaryTreeLnk<Data>::NodeLnk::HasRightChild() const noexcept{
+  return (right!=nullptr);
+}
+
+template <typename Data>
+struct BinaryTreeLnk<Data>::NodeLnk& BinaryTreeLnk<Data>::NodeLnk::LeftChild() const{
+  return *left;
+}
+
+template <typename Data>
+struct BinaryTreeLnk<Data>::NodeLnk& BinaryTreeLnk<Data>::NodeLnk::RightChild() const{
+  return *right;
+}
+
+/* ----- end of struct NodeLnk ----- */
+
+/* ----- begin of class BinaryTreeLnk ----- */
+
+// creates a tree from a linear container in breadth
+template <typename Data>
+BinaryTreeLnk<Data>::BinaryTreeLnk(const LinearContainer<Data>& lc){
+  root = CreateTreeFromLinearContainerInBreadth(lc,0);
+  size = lc.Size();
+}
+
+template <typename Data>
+struct BinaryTreeLnk<Data>::NodeLnk*  BinaryTreeLnk<Data>::CreateTreeFromLinearContainerInBreadth(const LinearContainer<Data>& lc, ulong position){
+  if(position >= lc.Size()) return nullptr;
+
+  struct BinaryTreeLnk<Data>::NodeLnk* tmp = CreateNode(lc[position]);
+
+  tmp->left = CreateTreeFromLinearContainerInBreadth(lc, (2*position)+1);
+  tmp->right = CreateTreeFromLinearContainerInBreadth(lc, (2*position)+2);
+
+  return tmp;
+
+}
+
+template <typename Data>
+struct BinaryTreeLnk<Data>::NodeLnk* BinaryTreeLnk<Data>::CreateNode(const Data& data){
+    struct BinaryTreeLnk<Data>::NodeLnk* newNode = new struct BinaryTreeLnk<Data>::NodeLnk();
+    newNode->data = data;
+    newNode->left = nullptr;
+    newNode->right = nullptr;
+    return newNode;
+}
+
+template <typename Data>
+BinaryTreeLnk<Data>::BinaryTreeLnk(const BinaryTreeLnk<Data>& tree){
+  if(tree.root == nullptr) return;
+  size = tree.size;
+  root = CopyTree(&tree.Root());
+}
+
+template <typename Data>
+struct BinaryTreeLnk<Data>::NodeLnk* BinaryTreeLnk<Data>::CopyTree(struct BinaryTreeLnk<Data>::Node* nodeToCopy){
+  if(nodeToCopy==nullptr) return nullptr;
+
+  struct BinaryTreeLnk<Data>::NodeLnk* tmp = CreateNode(nodeToCopy->Element());
+
+  if(nodeToCopy->HasLeftChild())
+    tmp->left = CopyTree(&(nodeToCopy->LeftChild()));
+  else
+    tmp->left = nullptr;
+
+  if(nodeToCopy->HasRightChild())
+    tmp->right = CopyTree(&(nodeToCopy->RightChild()));
+  else
+    tmp->right = nullptr;
+
+  return tmp;
+}
+
+template <typename Data>
+BinaryTreeLnk<Data>::BinaryTreeLnk(BinaryTreeLnk<Data>&& tree) noexcept{
+  std::swap(size, tree.size);
+  std::swap(root, tree.root);
+}
+
+template <typename Data>
+BinaryTreeLnk<Data>::~BinaryTreeLnk(){
+  Clear();
+}
+
+template <typename Data>
+void BinaryTreeLnk<Data>::DeleteTree(BinaryTreeLnk<Data>::NodeLnk* node){
+  if(node == nullptr) return;
+  DeleteTree(node->left);
+  DeleteTree(node->right);
+  delete node;
+}
+
+template <typename Data>
+BinaryTreeLnk<Data>& BinaryTreeLnk<Data>::operator=(const BinaryTreeLnk<Data>& tree){
+  Clear();
+  size = tree.size;
+  if(tree.root != nullptr)
+    root = CopyTree(&tree.Root());
+  return *this;
+
+}
+
+template <typename Data>
+BinaryTreeLnk<Data>& BinaryTreeLnk<Data>::operator=(BinaryTreeLnk<Data>&& tree) noexcept{
+  Clear();
+  std::swap(size, tree.size);
+  std::swap(root, tree.root);
+  return *this;
+}
+
+template <typename Data>
+bool BinaryTreeLnk<Data>::operator==(const BinaryTreeLnk<Data>& tree) const noexcept{
+  if(size == tree.size){
+    return (Root() == tree.Root());
+  }else{
+    return false;
+  }
+}
+
+template <typename Data>
+bool BinaryTreeLnk<Data>::operator!=(const BinaryTreeLnk<Data>& tree) const noexcept{
+  return !(*this == tree);
+}
+
+template <typename Data>
+struct BinaryTreeLnk<Data>::NodeLnk& BinaryTreeLnk<Data>::Root() const{
+  if(size==0) throw std::length_error("Empty tree!");
+  return *root;
+}
+
+template <typename Data>
+void BinaryTreeLnk<Data>::Clear(){
+  DeleteTree(root);
+  root = nullptr;
+  size = 0;
+}
 
 }

librerie/exercise4/binarytree/lnk/binarytreelnk.hpp

@@ -1,99 +1,74 @@
-
 #ifndef BINARYTREELNK_HPP
 #define BINARYTREELNK_HPP
 
-/* ************************************************************************** */
-
 #include "../binarytree.hpp"
 
-/* ************************************************************************** */
-
 namespace lasd {
 
-/* ************************************************************************** */
-
 template <typename Data>
-class BinaryTreeLnk { // Must extend BinaryTree<Data>
+class BinaryTreeLnk : virtual public BinaryTree<Data>{ // Must extend BinaryTree<Data>
-
-private:
-
-  // ...
 
 protected:
 
-  // using BinaryTree<Data>::???;
+  struct NodeLnk : virtual public BinaryTree<Data>::Node { // Must extend Node
-
-  // ...
-
-  struct NodeLnk { // Must extend Node
-
-  private:
-
-    // ...
 
   protected:
 
-    // ...
+    using BinaryTree<Data>::Node::data;
+    struct NodeLnk* left = nullptr;
+    struct NodeLnk* right = nullptr;
 
   public:
+    struct NodeLnk& operator=(const NodeLnk&); // Copy assignment of abstract types should not be possible.
+    struct NodeLnk& operator=(NodeLnk&&) noexcept; // Move assignment of abstract types should not be possible.
+    bool IsLeaf() const noexcept override; // (concrete function should not throw exceptions)
+    bool HasLeftChild() const noexcept override; // (concrete function should not throw exceptions)
+    bool HasRightChild() const noexcept override; // (concrete function should not throw exceptions)
 
-    // ...
+    struct NodeLnk& LeftChild() const override; // (concrete function must throw std::out_of_range when not existent)
+    struct NodeLnk& RightChild() const override; // (concrete function must throw std::out_of_range when not existent)
+
+    friend class BinaryTreeLnk<Data>;
 
   };
 
+protected:
+    using BinaryTree<Data>::size;
+
+    struct BinaryTreeLnk<Data>::NodeLnk* root = nullptr;
+    struct BinaryTreeLnk<Data>::NodeLnk* CreateNode(const Data& data);
+
 public:
 
   // Default constructor
-  // BinaryTreeLnk() specifiers;
+  BinaryTreeLnk() = default;
+  BinaryTreeLnk(const LinearContainer<Data>&); // A binary tree obtained from a LinearContainer
+  BinaryTreeLnk(const BinaryTreeLnk<Data>&);
+  BinaryTreeLnk(BinaryTreeLnk<Data>&&) noexcept;
 
-  /* ************************************************************************ */
+  virtual ~BinaryTreeLnk();
 
-  // Specific constructors
+  BinaryTreeLnk& operator=(const BinaryTreeLnk<Data>&);
-  // BinaryTreeLnk(argument) specifiers; // A binary tree obtained from a LinearContainer
+  BinaryTreeLnk& operator=(BinaryTreeLnk<Data>&&) noexcept;
 
-  /* ************************************************************************ */
+  bool operator==(const BinaryTreeLnk<Data>&) const noexcept;
-
+  bool operator!=(const BinaryTreeLnk<Data>&) const noexcept;
-  // Copy constructor
-  // BinaryTreeLnk(argument) specifiers;
-
-  // Move constructor
-  // BinaryTreeLnk(argument) specifiers;
-
-  /* ************************************************************************ */
-
-  // Destructor
-  // ~BinaryTreeLnk() specifiers;
-
-  /* ************************************************************************ */
-
-  // Copy assignment
-  // type operator=(argument) specifiers;
-
-  // Move assignment
-  // type operator=(argument) specifiers;
-
-  /* ************************************************************************ */
-
-  // Comparison operators
-  // type operator==(argument) specifiers;
-  // type operator!=(argument) specifiers;
-
-  /* ************************************************************************ */
 
   // Specific member functions (inherited from BinaryTree)
 
-  // type Root() specifiers; // Override BinaryTree member (throw std::length_error when empty)
+  NodeLnk& Root() const override; // Override BinaryTree member (throw std::length_error when empty)
-
-  /* ************************************************************************ */
 
   // Specific member functions (inherited from Container)
 
-  // type Clear() specifiers; // Override Container member
+  void Clear() override; // Override Container member
 
+  // Specific functions
+
+  struct BinaryTreeLnk<Data>::NodeLnk* CreateTreeFromLinearContainerInBreadth(const LinearContainer<Data>&,ulong);
+  struct BinaryTreeLnk<Data>::NodeLnk* CopyTree(struct BinaryTreeLnk<Data>::Node*);
+  void DeleteTree(BinaryTreeLnk<Data>::NodeLnk* node);
 };
 
-/* ************************************************************************** */
-
 }
 
 #include "binarytreelnk.cpp"

librerie/exercise4/binarytree/vec/binarytreevec.cpp

@@ -1,9 +1,175 @@
 
 namespace lasd {
 
-/* ************************************************************************** */
+/* ----- begin of struct NodeVec ----- */
 
-// ...
+template <typename Data>
+BinaryTreeVec<Data>::NodeVec::NodeVec(Data& dat, ulong idx, BinaryTreeVec<Data>* ref){
+  data = dat;
+  index = idx;
+  ReferenceToTree = ref;
+}
+
+template <typename Data>
+struct BinaryTreeVec<Data>::NodeVec& BinaryTreeVec<Data>::NodeVec::operator=(const BinaryTreeVec<Data>::NodeVec& node){
+  ReferenceToTree = node.ReferenceToTree;
+  data = node.data;
+  index = node.index;
+  return *this;
+}
+
+template <typename Data>
+struct BinaryTreeVec<Data>::NodeVec& BinaryTreeVec<Data>::NodeVec::operator=(BinaryTreeVec<Data>::NodeVec&& node) noexcept{
+  std::swap(data, node.data);
+  std::swap(index, node.index);
+  std::swap(ReferenceToTree, node.ReferenceToTree);
+  return *this;
+}
+
+template <typename Data>
+bool BinaryTreeVec<Data>::NodeVec::IsLeaf() const noexcept{
+  return (!HasLeftChild() && !HasRightChild());
+}
+
+template <typename Data>
+bool BinaryTreeVec<Data>::NodeVec::HasLeftChild() const noexcept{
+  if( (index*2)+1 < ReferenceToTree->size){
+    return true;
+  }else{
+    return false;
+  }
+}
+
+template <typename Data>
+bool BinaryTreeVec<Data>::NodeVec::HasRightChild() const noexcept{
+  if((index*2)+2 < ReferenceToTree->size){
+    return true;
+  }else{
+    return false;
+  }
+}
+
+template <typename Data>
+struct BinaryTreeVec<Data>::NodeVec& BinaryTreeVec<Data>::NodeVec::LeftChild() const{
+  if(index*2+1 < ReferenceToTree->size)
+    return *((ReferenceToTree->tree)[index*2+1]);
+  else
+    throw std::out_of_range("Left child does not exist!");
+}
+
+template <typename Data>
+struct BinaryTreeVec<Data>::NodeVec& BinaryTreeVec<Data>::NodeVec::RightChild() const{
+  if(index*2+2 < ReferenceToTree->size)
+    return *((ReferenceToTree->tree)[index*2+2]);
+  else
+    throw std::out_of_range("Right child does not exist!");
+}
+
+/* ----- end of struct NodeVec ----- */
+
+/* ----- begin of class BinaryTreeVec ----- */
+
+template <typename Data>
+BinaryTreeVec<Data>::BinaryTreeVec(const LinearContainer<Data>& lc){
+  tree.Resize(lc.Size());
+  size = lc.Size();
+  for(ulong i=0 ; i<size ; ++i){
+    struct BinaryTreeVec<Data>::NodeVec* tmp = new BinaryTreeVec<Data>::NodeVec(lc[i], i, this);
+    tree[i] = tmp;
+  }
+}
+
+template <typename Data>
+BinaryTreeVec<Data>::BinaryTreeVec(const BinaryTreeVec<Data>& bt){
+  size = bt.size;
+  tree.Resize(size);
+  for(ulong i=0 ; i<size ; ++i){
+    struct BinaryTreeVec<Data>::NodeVec* tmp = new BinaryTreeVec<Data>::NodeVec( (bt.tree[i])->data , i, this);
+    tree[i] = tmp;
+  }
+}
+
+template <typename Data>
+BinaryTreeVec<Data>::BinaryTreeVec(BinaryTreeVec<Data>&& bt) noexcept{
+  std::swap(size,bt.size);
+  std::swap(tree,bt.tree);
+  for(ulong i=0 ; i<size ; ++i){
+    tree[i]->ReferenceToTree = this;
+  }
+}
+
+template <typename Data>
+BinaryTreeVec<Data>::~BinaryTreeVec(){
+  Clear();
+}
+
+template <typename Data>
+BinaryTreeVec<Data>& BinaryTreeVec<Data>::operator=(const BinaryTreeVec<Data>& bt){
+  Clear();
+  size = bt.size;
+  tree.Resize(size);
+  for(ulong i=0 ; i<size ; ++i){
+    struct NodeVec* tmp = new BinaryTreeVec<Data>::NodeVec((bt.tree[i])->data,i,this);
+    tree[i] = tmp;
+  }
+  return *this;
+}
+
+template <typename Data>
+BinaryTreeVec<Data>& BinaryTreeVec<Data>::operator=(BinaryTreeVec<Data>&& bt) noexcept{
+  Clear();
+  std::swap(size, bt.size);
+  std::swap(tree, bt.tree);
+  for(ulong i=0 ; i<size ; ++i){
+    tree[i]->ReferenceToTree = this;
+  }
+  return *this;
+}
+
+template <typename Data>
+bool BinaryTreeVec<Data>::operator==(const BinaryTreeVec& bt) const noexcept{
+  if(size==bt.size){
+    for(ulong i=0 ; i<size ; ++i){
+      if( tree[i]->data != (bt.tree[i])->data ) return false;
+    }
+    return true;
+  }
+  return false;
+}
+
+template <typename Data>
+bool BinaryTreeVec<Data>::operator!=(const BinaryTreeVec& bt) const noexcept{
+  return !(*this == bt);
+}
+
+template <typename Data>
+struct BinaryTreeVec<Data>::NodeVec& BinaryTreeVec<Data>::Root() const{
+  if(size==0) throw std::length_error("Empty tree!");
+  return *(tree.Front());
+}
+
+template <typename Data>
+void BinaryTreeVec<Data>::Clear(){
+  for(ulong i=0 ; i<size ; ++i){
+    delete tree[i];
+    tree[i] = nullptr;
+  }
+  size = 0;
+}
+
+template <typename Data>
+void BinaryTreeVec<Data>::MapBreadth(const MapFunctor func, void* par){
+  for(ulong i=0 ; i<size ; ++i){
+    func( (tree[i])->data, par);
+  }
+}
+
+template <typename Data>
+void BinaryTreeVec<Data>::FoldBreadth(const FoldFunctor func, const void* par, void* acc) const{
+  for(ulong i=0 ; i<size ; ++i){
+    func( (tree[i])->data, par, acc);
+  }
+}
 
 /* ************************************************************************** */
 

librerie/exercise4/binarytree/vec/binarytreevec.hpp

@@ -2,111 +2,73 @@
 #ifndef BINARYTREEVEC_HPP
 #define BINARYTREEVEC_HPP
 
-/* ************************************************************************** */
-
 #include "../binarytree.hpp"
 #include "../../vector/vector.hpp"
 
-/* ************************************************************************** */
-
 namespace lasd {
 
-/* ************************************************************************** */
-
 template <typename Data>
-class BinaryTreeVec { // Must extend BinaryTree<Data>
+class BinaryTreeVec : virtual public BinaryTree<Data>{ // Must extend BinaryTree<Data>
-
-private:
-
-  // ...
 
 protected:
 
-  // using BinaryTree<Data>::???;
+  struct NodeVec : virtual public BinaryTree<Data>::Node { // Must extend Node
-
-  // ...
-
-  struct NodeVec { // Must extend Node
-
-  private:
-
-    // ...
 
   protected:
-
+    using BinaryTree<Data>::Node::data;
-    // ...
+    ulong index;
+    BinaryTreeVec<Data>* ReferenceToTree = nullptr;
 
   public:
+    NodeVec(Data&, ulong, BinaryTreeVec<Data>*);
+    struct NodeVec& operator=(const NodeVec&); // Copy assignment of abstract types should not be possible.
+    struct NodeVec& operator=(NodeVec&&) noexcept; // Move assignment of abstract types should not be possible.
+    bool IsLeaf() const noexcept override; // (concrete function should not throw exceptions)
+    bool HasLeftChild() const noexcept override; // (concrete function should not throw exceptions)
+    bool HasRightChild() const noexcept override; // (concrete function should not throw exceptions)
+    struct NodeVec& LeftChild() const override; // (concrete function must throw std::out_of_range when not existent)
+    struct NodeVec& RightChild() const override; // (concrete function must throw std::out_of_range when not existent)
 
-    // ...
+    friend class BinaryTreeVec<Data>;
-
   };
 
+protected:
+
+  using BinaryTree<Data>::size;
+  Vector<struct BinaryTreeVec<Data>::NodeVec*> tree;
+
 public:
 
-  // Default constructor
+  BinaryTreeVec() = default;
-  // BinaryTreeVec() specifiers;
+  BinaryTreeVec(const LinearContainer<Data>&); // A binary tree obtained from a LinearContainer
+  BinaryTreeVec(const BinaryTreeVec<Data>&);
+  BinaryTreeVec(BinaryTreeVec<Data>&&) noexcept;
 
-  /* ************************************************************************ */
+  virtual ~BinaryTreeVec();
 
-  // Specific constructors
+  BinaryTreeVec& operator=(const BinaryTreeVec<Data>&);
-  // BinaryTreeVec(argument) specifiers; // A binary tree obtained from a LinearContainer
+  BinaryTreeVec& operator=(BinaryTreeVec<Data>&&) noexcept;
 
-  /* ************************************************************************ */
+  bool operator==(const BinaryTreeVec&) const noexcept;
-
+  bool operator!=(const BinaryTreeVec&) const noexcept;
-  // Copy constructor
-  // BinaryTreeVec(argument) specifiers;
-
-  // Move constructor
-  // BinaryTreeVec(argument) specifiers;
-
-  /* ************************************************************************ */
-
-  // Destructor
-  // ~BinaryTreeVec() specifiers;
-
-  /* ************************************************************************ */
-
-  // Copy assignment
-  // type operator=(argument) specifiers;
-
-  // Move assignment
-  // type operator=(argument) specifiers;
-
-  /* ************************************************************************ */
-
-  // Comparison operators
-  // type operator==(argument) specifiers;
-  // type operator!=(argument) specifiers;
-
-  /* ************************************************************************ */
 
   // Specific member functions (inherited from BinaryTree)
 
-  // type Root() specifiers; // Override BinaryTree member (throw std::length_error when empty)
+  NodeVec& Root() const override; // Override BinaryTree member (throw std::length_error when empty)
-
-  /* ************************************************************************ */
 
   // Specific member functions (inherited from Container)
 
-  // type Clear() specifiers; // Override Container member
+  void Clear() override; // Override Container member
 
-  /* ************************************************************************ */
+  /* ----- override of map and fold in breadth ----- */
 
-  // Specific member functions (inherited from BreadthMappableContainer)
+  using typename BinaryTree<Data>::MapFunctor;
-
+  using typename BinaryTree<Data>::FoldFunctor;
-  // type MapBreadth(arguments) specifiers; // Override BreadthMappableContainer member
+  void MapBreadth(const MapFunctor, void*) override;
-
+  void FoldBreadth(const FoldFunctor, const void*, void*) const override;
-  /* ************************************************************************ */
-
-  // Specific member functions (inherited from BreadthFoldableContainer)
-
-  // type FoldBreadth(arguments) specifiers; // Override BreadthFoldableContainer member
 
 };
 
-/* ************************************************************************** */
-
 }
 
 #include "binarytreevec.cpp"

librerie/exercise4/container/container.cpp

@@ -1,10 +1,18 @@
 
 namespace lasd {
 
-/* ************************************************************************** */
+template <typename Data>
+void AuxFoldExists(const Data& dat, const void* val, void* exists){
+  if(dat == *((Data*)val)){
+    *((bool*)exists) = true;
+  }
+}
 
-// ...
+template <typename Data>
-
+bool FoldableContainer<Data>::Exists(const Data& dat) const noexcept{
-/* ************************************************************************** */
+  bool exists = false;
+  FoldPreOrder(&AuxFoldExists<Data>, &dat, &exists);
+  return exists;
+}
 
 }

librerie/exercise4/container/container.hpp

@@ -14,382 +14,306 @@ namespace lasd {
 /* ************************************************************************** */
 
 class Container {
-
 private:
 
-  // ...
-
 protected:
 
-  // ...
+  ulong size = 0;
 
 public:
 
   // Destructor
-  // ~Container() specifiers
+  virtual ~Container() = default;
-
-  /* ************************************************************************ */
 
   // Copy assignment
-  // type operator=(argument); // Copy assignment of abstract types should not be possible.
+  Container& operator=(const Container&) = delete; // Copy assignment of abstract types should not be possible.
 
   // Move assignment
-  // type operator=(argument); // Move assignment of abstract types should not be possible.
+  Container& operator=(Container&&) noexcept = delete;; // Move assignment of abstract types should not be possible.
-
-  /* ************************************************************************ */
 
   // Comparison operators
-  // type operator==(argument) specifiers; // Comparison of abstract types might not be possible.
+   bool operator==(const Container&) const noexcept = delete; // Comparison of abstract types might not be possible.
-  // type operator!=(argument) specifiers; // Comparison of abstract types might not be possible.
+   bool operator!=(const Container&&) const noexcept = delete; // Comparison of abstract types might not be possible.
+
+  // Specific member functions
+   virtual bool Empty() const noexcept {
+     return (size == 0);
+   } // (concrete function should not throw exceptions)
+
+   virtual ulong Size() const noexcept {
+     return size;
+   } // (concrete function should not throw exceptions)
+
+   virtual void Clear() = 0;
+};
+
+template <typename Data>
+class LinearContainer : virtual public Container{ // Must extend Container
+
+private:
+
+protected:
+
+public:
+
+  // Destructor
+  virtual ~LinearContainer() = default;
+
+  // Copy assignment
+  LinearContainer& operator=(const LinearContainer&) = delete; // Copy assignment of abstract types should not be possible.
+
+  // Move assignment
+  LinearContainer& operator=(LinearContainer&&) noexcept = delete; // Move assignment of abstract types should not be possible.
+
+  // Comparison operators
+  bool operator==(const LinearContainer&) const noexcept = delete; // Comparison of abstract types might not be possible.
+  bool operator!=(const LinearContainer&) const noexcept = delete; // Comparison of abstract types might not be possible.
 
   /* ************************************************************************ */
 
   // Specific member functions
+  virtual Data& Front() const = 0; // (concrete function must throw std::length_error when empty)
+  virtual Data& Back() const = 0; // (concrete function must throw std::length_error when empty)
 
-  // type Empty() specifiers; // (concrete function should not throw exceptions)
+  virtual Data& operator[](const ulong) const = 0; // (concrete function must throw std::out_of_range when out of range)
 
-  // type Size() specifiers; // (concrete function should not throw exceptions)
+};
 
-  // type Clear() specifiers;
+template <typename Data>
+class TestableContainer : virtual public Container{ // Must extend Container
+
+private:
+
+protected:
+
+public:
+
+  // Destructor
+  virtual ~TestableContainer() = default;
+
+  // Copy assignment
+  TestableContainer& operator=(const TestableContainer&) = delete; // Copy assignment of abstract types should not be possible.
+
+  // Move assignment
+  TestableContainer& operator=(TestableContainer&&) noexcept = delete; // Move assignment of abstract types should not be possible.
+
+  // Comparison operators
+  bool operator==(const TestableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible.
+  bool operator!=(const TestableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible.
+
+  /* ************************************************************************ */
+
+  // Specific member functions
+  virtual bool Exists(const Data&) const noexcept = 0; // (concrete function should not throw exceptions)
+
+};
+
+template <typename Data>
+class MappableContainer : virtual public Container { // Must extend Container
+
+private:
+
+protected:
+
+public:
+
+  // Destructor
+  virtual ~MappableContainer() = default;
+
+  // Copy assignment
+   MappableContainer& operator=(const MappableContainer&) = delete; // Copy assignment of abstract types should not be possible.
+
+  // Move assignment
+  MappableContainer& operator=(MappableContainer&&) noexcept = delete; // Move assignment of abstract types should not be possible.
+
+  // Comparison operators
+  bool operator==(const MappableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible.
+  bool operator!=(const MappableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible.
+
+  // Specific member functions
+
+  typedef std::function<void(Data&, void*)> MapFunctor;
+
+  virtual void MapPreOrder(const MapFunctor, void*) = 0;
+  virtual void MapPostOrder(const MapFunctor, void*) = 0;
+
+};
+
+template <typename Data>
+class FoldableContainer : virtual public TestableContainer<Data>{ // Must extend TestableContainer
+
+private:
+
+protected:
+
+public:
+
+  // Destructor
+  virtual ~FoldableContainer() = default;
+
+  // Copy assignment
+  FoldableContainer& operator=(const FoldableContainer&) = delete; // Copy assignment of abstract types should not be possible.
+
+  // Move assignment
+  FoldableContainer& operator=(FoldableContainer&&) noexcept = delete; // Move assignment of abstract types should not be possible.
+
+  // Comparison operators
+  bool operator==(FoldableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible.
+  bool operator!=(FoldableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible.
+
+  // Specific member functions
+
+   typedef std::function<void(const Data&, const void*, void*) noexcept> FoldFunctor;
+
+  virtual void FoldPreOrder(const FoldFunctor, const void*, void*) const = 0;
+  virtual void FoldPostOrder(const FoldFunctor, const void*, void*) const = 0;
+
+  virtual bool Exists(const Data&) const noexcept override; // Override TestableContainer member
 
 };
 
 /* ************************************************************************** */
 
 template <typename Data>
-class LinearContainer { // Must extend Container
+class InOrderMappableContainer : virtual public MappableContainer<Data> { // Must extend MappableContainer
 
 private:
 
-  // ...
-
 protected:
 
-  // ...
-
 public:
 
   // Destructor
-  // ~LinearContainer() specifiers
+  virtual ~InOrderMappableContainer() = default;
 
   /* ************************************************************************ */
 
   // Copy assignment
-  // type operator=(argument); // Copy assignment of abstract types should not be possible.
+  InOrderMappableContainer& operator=(const InOrderMappableContainer&) = delete; // Copy assignment of abstract types should not be possible.
 
   // Move assignment
-  // type operator=(argument); // Move assignment of abstract types should not be possible.
+  InOrderMappableContainer& operator=(InOrderMappableContainer&&) noexcept = delete; // Move assignment of abstract types should not be possible.
 
   /* ************************************************************************ */
 
   // Comparison operators
-  // type operator==(argument) specifiers; // Comparison of abstract types is possible.
+  bool operator==(const InOrderMappableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible.
-  // type operator!=(argument) specifiers; // Comparison of abstract types is possible.
+  bool operator!=(const InOrderMappableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible.
 
   /* ************************************************************************ */
 
   // Specific member functions
-
+  virtual void MapInOrder(const typename MappableContainer<Data>::MapFunctor, void*) = 0;
-  // type Front() specifiers; // (concrete function must throw std::length_error when empty)
-  // type Back() specifiers; // (concrete function must throw std::length_error when empty)
-
-  // type operator[](argument) specifiers; // (concrete function must throw std::out_of_range when out of range)
 
 };
 
 /* ************************************************************************** */
 
 template <typename Data>
-class TestableContainer { // Must extend Container
+class InOrderFoldableContainer : public virtual FoldableContainer<Data> { // Must extend FoldableContainer
 
 private:
 
-  // ...
-
 protected:
 
-  // ...
-
 public:
 
   // Destructor
-  // ~TestableContainer() specifiers
+  virtual ~InOrderFoldableContainer() = default;
 
   /* ************************************************************************ */
 
   // Copy assignment
-  // type operator=(argument); // Copy assignment of abstract types should not be possible.
+  InOrderFoldableContainer& operator=(const InOrderFoldableContainer&) = delete; // Copy assignment of abstract types should not be possible.
 
   // Move assignment
-  // type operator=(argument); // Move assignment of abstract types should not be possible.
+  InOrderFoldableContainer& operator=(InOrderFoldableContainer&&) noexcept = delete; // Move assignment of abstract types should not be possible.
 
   /* ************************************************************************ */
 
   // Comparison operators
-  // type operator==(argument) specifiers; // Comparison of abstract types might not be possible.
+  bool operator==(const InOrderFoldableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible.
-  // type operator!=(argument) specifiers; // Comparison of abstract types might not be possible.
+  bool operator!=(const InOrderFoldableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible.
 
   /* ************************************************************************ */
 
   // Specific member functions
 
-  // type Exists(argument) specifiers; // (concrete function should not throw exceptions)
+  virtual void FoldInOrder(const typename FoldableContainer<Data>::FoldFunctor, const void*, void*) const = 0;
 
 };
 
 /* ************************************************************************** */
 
 template <typename Data>
-class MappableContainer { // Must extend Container
+class BreadthMappableContainer : virtual public MappableContainer<Data> { // Must extend MappableContainer
 
 private:
 
-  // ...
-
 protected:
 
-  // ...
-
 public:
 
   // Destructor
-  // ~MappableContainer() specifiers
+   ~BreadthMappableContainer() = default;
 
   /* ************************************************************************ */
 
   // Copy assignment
-  // type operator=(argument); // Copy assignment of abstract types should not be possible.
+  BreadthMappableContainer& operator=(const BreadthMappableContainer&) = delete; // Copy assignment of abstract types should not be possible.
 
   // Move assignment
-  // type operator=(argument); // Move assignment of abstract types should not be possible.
+  BreadthMappableContainer& operator=(BreadthMappableContainer&&) noexcept = delete; // Move assignment of abstract types should not be possible.
 
   /* ************************************************************************ */
 
   // Comparison operators
-  // type operator==(argument) specifiers; // Comparison of abstract types might not be possible.
+  bool operator==(const BreadthMappableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible.
-  // type operator!=(argument) specifiers; // Comparison of abstract types might not be possible.
+  bool operator!=(const BreadthMappableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible.
 
   /* ************************************************************************ */
 
   // Specific member functions
 
-  // typedef std::function<void(Data&, void*)> MapFunctor;
+  virtual void MapBreadth(const typename MappableContainer<Data>::MapFunctor, void*) = 0;
-
-  // type MapPreOrder(arguments) specifiers;
-  // type MapPostOrder(arguments) specifiers;
 
 };
 
 /* ************************************************************************** */
 
 template <typename Data>
-class FoldableContainer { // Must extend TestableContainer
+class BreadthFoldableContainer : virtual public FoldableContainer<Data> { // Must extend FoldableContainer
 
 private:
 
-  // ...
-
 protected:
 
-  // ...
-
 public:
 
   // Destructor
-  // ~FoldableContainer() specifiers
+  virtual ~BreadthFoldableContainer() = default;
 
   /* ************************************************************************ */
 
   // Copy assignment
-  // type operator=(argument); // Copy assignment of abstract types should not be possible.
+  BreadthFoldableContainer& operator=(const BreadthFoldableContainer&) = delete; // Copy assignment of abstract types should not be possible.
 
   // Move assignment
-  // type operator=(argument); // Move assignment of abstract types should not be possible.
+  BreadthFoldableContainer& operator=(BreadthFoldableContainer&&) noexcept = delete; // Move assignment of abstract types should not be possible.
 
   /* ************************************************************************ */
 
   // Comparison operators
-  // type operator==(argument) specifiers; // Comparison of abstract types might not be possible.
+  bool operator==(const BreadthFoldableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible.
-  // type operator!=(argument) specifiers; // Comparison of abstract types might not be possible.
+  bool operator!=(const BreadthFoldableContainer&) const noexcept = delete;  // Comparison of abstract types might not be possible.
 
   /* ************************************************************************ */
 
   // Specific member functions
 
-  // typedef std::function<void(const Data&, const void*, void*) noexcept> FoldFunctor;
+  using typename FoldableContainer<Data>::FoldFunctor;
 
-  // type FoldPreOrder(arguments) specifiers;
+  virtual void FoldBreadth(const FoldFunctor, const void*, void*) const = 0;
-  // type FoldPostOrder(arguments) specifiers;
-
-  // type Exists(argument) specifiers; // Override TestableContainer member
-
-};
-
-/* ************************************************************************** */
-
-template <typename Data>
-class InOrderMappableContainer { // Must extend MappableContainer
-
-private:
-
-  // ...
-
-protected:
-
-  // ...
-
-public:
-
-  // Destructor
-  // ~InOrderMappableContainer() specifiers
-
-  /* ************************************************************************ */
-
-  // Copy assignment
-  // type operator=(argument); // Copy assignment of abstract types should not be possible.
-
-  // Move assignment
-  // type operator=(argument); // 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.
-
-  /* ************************************************************************ */
-
-  // Specific member functions
-
-  // using typename MappableContainer<Data>::MapFunctor;
-
-  // type MapInOrder(arguments) specifiers;
-
-};
-
-/* ************************************************************************** */
-
-template <typename Data>
-class InOrderFoldableContainer { // Must extend FoldableContainer
-
-private:
-
-  // ...
-
-protected:
-
-  // ...
-
-public:
-
-  // Destructor
-  // ~InOrderFoldableContainer() specifiers
-
-  /* ************************************************************************ */
-
-  // Copy assignment
-  // type operator=(argument); // Copy assignment of abstract types should not be possible.
-
-  // Move assignment
-  // type operator=(argument); // 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.
-
-  /* ************************************************************************ */
-
-  // Specific member functions
-
-  // using typename MappableContainer<Data>::MapFunctor;
-
-  // type FoldInOrder(arguments) specifiers;
-
-};
-
-/* ************************************************************************** */
-
-template <typename Data>
-class BreadthMappableContainer { // Must extend MappableContainer
-
-private:
-
-  // ...
-
-protected:
-
-  // ...
-
-public:
-
-  // Destructor
-  // ~BreadthMappableContainer() specifiers
-
-  /* ************************************************************************ */
-
-  // Copy assignment
-  // type operator=(argument); // Copy assignment of abstract types should not be possible.
-
-  // Move assignment
-  // type operator=(argument); // 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.
-
-  /* ************************************************************************ */
-
-  // Specific member functions
-
-  // using typename MappableContainer<Data>::MapFunctor;
-
-  // type MapBreadth(arguments) specifiers;
-
-};
-
-/* ************************************************************************** */
-
-template <typename Data>
-class BreadthFoldableContainer { // Must extend FoldableContainer
-
-private:
-
-  // ...
-
-protected:
-
-  // ...
-
-public:
-
-  // Destructor
-  // ~BreadthFoldableContainer() specifiers
-
-  /* ************************************************************************ */
-
-  // Copy assignment
-  // type operator=(argument); // Copy assignment of abstract types should not be possible.
-
-  // Move assignment
-  // type operator=(argument); // 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.
-
-  /* ************************************************************************ */
-
-  // Specific member functions
-
-  // using typename FoldableContainer<Data>::FoldFunctor;
-
-  // type FoldBreadth(arguments) specifiers;
 
 };
 

librerie/exercise4/iterator/iterator.hpp

@@ -13,78 +13,70 @@ class Iterator {
 
 private:
 
-  // ...
-
 protected:
 
-  // ...
-
 public:
 
   // Destructor
-  // ~Iterator() specifiers
+  virtual ~Iterator() = default;
 
   /* ************************************************************************ */
 
   // Copy assignment
-  // type operator=(argument); // Copy assignment of abstract types should not be possible.
+  Iterator& operator=(const Iterator&) = delete; // Copy assignment of abstract types should not be possible.
 
   // Move assignment
-  // type operator=(argument); // Move assignment of abstract types should not be possible.
+  Iterator& operator=(Iterator&&) noexcept = delete; // Move assignment of abstract types should not be possible.
 
   /* ************************************************************************ */
 
   // Comparison operators
-  // type operator==(argument) specifiers; // Comparison of abstract types might not be possible.
+  bool operator==(const Iterator&) const noexcept = delete; // Comparison of abstract types might not be possible.
-  // type operator!=(argument) specifiers; // Comparison of abstract types might not be possible.
+  bool operator!=(const Iterator&) const noexcept = delete; // Comparison of abstract types might not be possible.
 
   /* ************************************************************************ */
 
   // Specific member functions
 
-  // type operator*() specifiers; // (concrete function must throw std::out_of_range when terminated)
+  virtual Data& operator*() const = 0; // (concrete function must throw std::out_of_range when terminated)
 
-  // type Terminated() specifiers; // (concrete function should not throw exceptions)
+  virtual bool Terminated() const noexcept = 0; // (concrete function should not throw exceptions)
 
 };
 
 /* ************************************************************************** */
 
 template <typename Data>
-class ForwardIterator { // Must extend Iterator
+class ForwardIterator : virtual public Iterator<Data> { // Must extend Iterator
 
 private:
 
-  // ...
-
 protected:
 
-  // ...
-
 public:
 
   // Destructor
-  // ~ForwardIterator() specifiers
+  virtual ~ForwardIterator() = default;
 
   /* ************************************************************************ */
 
   // Copy assignment
-  // type operator=(argument); // Copy assignment of abstract types should not be possible.
+  ForwardIterator& operator=(const ForwardIterator&) = delete; // Copy assignment of abstract types should not be possible.
 
   // Move assignment
-  // type operator=(argument); // Move assignment of abstract types should not be possible.
+  ForwardIterator& operator=(ForwardIterator&&) noexcept = delete; // Move assignment of abstract types should not be possible.
 
   /* ************************************************************************ */
 
   // Comparison operators
-  // type operator==(argument) specifiers; // Comparison of abstract types might not be possible.
+  bool operator==(const ForwardIterator&) const noexcept = delete; // Comparison of abstract types might not be possible.
-  // type operator!=(argument) specifiers; // Comparison of abstract types might not be possible.
+  bool operator!=(const ForwardIterator&) const noexcept = delete; // Comparison of abstract types might not be possible.
 
   /* ************************************************************************ */
 
   // Specific member functions
 
-  // type operator++() specifiers; // (concrete function must throw std::out_of_range when terminated)
+  virtual void operator++() = 0; // (concrete function must throw std::out_of_range when terminated)
 
 };
 

librerie/exercise4/list/list.cpp

@@ -3,8 +3,263 @@ namespace lasd {
 
 /* ************************************************************************** */
 
-// ...
+// Specific constructors
-
+template <typename Data>
-/* ************************************************************************** */
+List<Data>::Node::Node(const Data& newValue){
-
+  value = newValue;
+  next = nullptr;
+}
+
+// Copy constructor
+template <typename Data>
+List<Data>::Node::Node(const Node& copyFrom){
+  value = copyFrom.value;
+  next = nullptr;
+}
+
+// Move constructor
+template <typename Data>
+List<Data>::Node::Node(Node&& moveFrom){
+  std::swap(value, moveFrom.value);
+  std::swap(next, moveFrom.next);
+}
+
+template <typename Data>
+List<Data>::Node::Node(Data&& moveFrom){
+  std::swap(value, moveFrom);
+}
+
+template <typename Data>
+bool List<Data>::Node::operator==(const Node& node)const noexcept{
+  return (node.value == value);
+}
+
+template <typename Data>
+bool List<Data>::Node::operator!=(const Node& node)const noexcept{
+  return !(*this == node);
+}
+
+template <typename Data>
+List<Data>::List(const LinearContainer<Data>& con){
+  for(ulong i = 0; i<con.Size(); ++i){
+    InsertAtBack(con[i]);
+    }
+}
+
+template <typename Data>
+List<Data>::List(const List<Data>& copyFrom){
+  for(ulong i = 0; i<copyFrom.Size(); ++i){
+    InsertAtBack(copyFrom[i]);
+    }
+}
+
+template <typename Data>
+List<Data>::List(List<Data>&& moveFrom){
+  std::swap(size, moveFrom.size);
+  std::swap(head, moveFrom.head);
+  std::swap(tail, moveFrom.tail);
+}
+
+template <typename Data>
+List<Data>::~List(){
+  Clear();
+}
+
+template <typename Data>
+ List<Data>& List<Data>::operator=(const List<Data>& copyFrom){
+ if(*this != copyFrom){
+   Clear();
+   for(ulong i = 0 ; i<copyFrom.Size() ; ++i){
+     InsertAtBack(copyFrom[i]);
+     }
+   }
+   return *this;
+ }
+
+ template <typename Data>
+ List<Data>& List<Data>::operator=(List<Data>&& moveFrom)noexcept{
+   if(*this != moveFrom){
+     std::swap(size, moveFrom.size);
+     std::swap(head, moveFrom.head);
+     std::swap(tail, moveFrom.tail);
+  }
+  return *this;
+ }
+
+ template <typename Data>
+ bool List<Data>::operator==(const List<Data>& list) const noexcept{
+   if(size != list.Size()) return false;
+   for(ulong i = 0 ; i < size ; ++i){
+     if((*this)[i] != list[i]) return false;
+   }
+   return true;
+ }
+
+template <typename Data>
+bool List<Data>::operator!=(const List<Data>& list) const noexcept{
+  return !(*this==list);
+}
+
+template <typename Data>
+void List<Data>::InsertAtFront(const Data& data){
+  struct Node* tmp = new Node(data);
+  tmp->next = head;
+  head = tmp;
+  size++;
+  if(size == 1){
+    tail = head;
+  }
+ }
+
+template <typename Data>
+void List<Data>::InsertAtFront(Data&& data){
+  struct Node* tmp = new Node(std::move(data));
+  tmp->next = head;
+  head = tmp;
+  size++;
+  if(size == 1){
+    tail = head;
+  }
+}
+
+template <typename Data>
+  void List<Data>::RemoveFromFront(){
+    if(head == nullptr){
+      throw std::length_error("List is empty!");
+    }
+    else{
+      struct Node* tmp = head;
+      head = head->next;
+      tmp->next = nullptr;
+      delete tmp;
+      size--;
+      if(head==nullptr){
+        tail=nullptr;
+      }
+    }
+  }
+
+template <typename Data>
+Data List<Data>::FrontNRemove(){
+  if(head == nullptr){
+    throw std::length_error("List is empty!");
+  }
+  else{
+    Data value = head->value;
+    RemoveFromFront();
+    return value;
+  }
+}
+
+template <typename Data>
+void List<Data>::InsertAtBack(const Data& data){
+  if(size == 0){
+    InsertAtFront(data);
+  }
+  else{
+    struct Node* last = new Node(data);
+    tail->next = last;
+    tail = last;
+    size++;
+  }
+}
+
+template <typename Data>
+void List<Data>::InsertAtBack(Data&& data){
+  if(size == 0){
+    InsertAtFront(data);
+  }
+  else{
+    struct Node* last = new Node(std::move(data));
+    tail->next = last;
+    tail = last;
+    size++;
+  }
+}
+
+template <typename Data>
+void List<Data>::Clear(){
+  while(head != nullptr){
+    RemoveFromFront();
+  }
+}
+
+template <typename Data>
+Data& List<Data>::Front() const{
+  if(size == 0){
+    throw std::length_error("List is empty!");
+  }else{
+    return head->value;
+  }
+}
+
+template <typename Data>
+Data& List<Data>::Back() const{
+  if(size == 0){
+    throw std::length_error("List is empty!");
+  }else{
+    return tail->value;
+  }
+}
+
+template <typename Data>
+Data& List<Data>::operator[](const ulong index) const{
+  if(index >= size || index < 0){
+    throw std::out_of_range("Out of Range!");
+  }else{
+    struct Node* tmp = head;
+    for(ulong i=0; i<index; ++i){
+      tmp = tmp->next;
+    }
+    return tmp->value;
+  }
+}
+
+template <typename Data>
+void List<Data>::MapPreOrder(MapFunctor function, void* par){
+  MapPreOrder(function, par, head);
+}
+
+template <typename Data>
+void List<Data>::MapPostOrder(MapFunctor function, void* par){
+  MapPostOrder(function, par, head);
+}
+
+template <typename Data>
+void List<Data>::FoldPreOrder(FoldFunctor function, const void* constPar, void* par) const{
+  FoldPreOrder(function, constPar, par, head);
+}
+
+template <typename Data>
+void List<Data>::FoldPostOrder(FoldFunctor function, const void* constPar, void* par) const{
+  FoldPostOrder(function, constPar, par, head);
+}
+
+template <typename Data>
+void List<Data>::MapPreOrder(MapFunctor function, void* par, struct Node* node){
+  if(node == nullptr) return;
+  function(node->value, par);
+  MapPreOrder(function, par, node->next);
+}
+
+template <typename Data>
+void List<Data>::MapPostOrder(MapFunctor function, void* par, struct Node* node){
+  if(node == nullptr) return;
+  MapPostOrder(function, par, node->next);
+  function(node->value, par);
+}
+
+template <typename Data>
+void List<Data>::FoldPreOrder(FoldFunctor function, const void* constPar, void* par, struct Node* node) const{
+  if(node == nullptr) return;
+  function(node->value, constPar, par);
+  FoldPreOrder(function, constPar, par, node->next);
+}
+
+template <typename Data>
+void List<Data>::FoldPostOrder(FoldFunctor function, const void* constPar, void* par, struct Node* node) const{
+  if(node == nullptr) return;
+  FoldPostOrder(function, constPar, par, node->next);
+  function(node->value, constPar, par);
+}
 }

librerie/exercise4/list/list.hpp

@@ -13,150 +13,150 @@ namespace lasd {
 /* ************************************************************************** */
 
 template <typename Data>
-class List { // Must extend LinearContainer<Data>, MappableContainer<Data>, and FoldableContainer<Data>
+class List : virtual public LinearContainer<Data>,
+             virtual public MappableContainer<Data>,
+             virtual public FoldableContainer<Data>{ // Must extend LinearContainer<Data>, MappableContainer<Data>, and FoldableContainer<Data>
 
 private:
 
-  // ...
-
 protected:
 
-  // using LinearContainer<Data>::???;
+  using LinearContainer<Data>:: size;
 
   struct Node
   {
-
+    Data value;
-    // Data
+    Node*  next = nullptr;
-    // ...
 
     /* ********************************************************************** */
 
     // Specific constructors
-    // ...
+     Node(const Data&);
 
     /* ********************************************************************** */
 
     // Copy constructor
-    // ...
+    Node(const Node&);
 
     // Move constructor
-    // ...
+    Node(Node&&);
+    Node(Data&&);
 
     /* ********************************************************************** */
 
     // Destructor
-    // ...
+    ~Node() = default;
 
     /* ********************************************************************** */
 
     // Comparison operators
-    // ...
+    bool operator==(const Node&) const noexcept;
+    bool operator!=(const Node&) const noexcept;
 
     /* ********************************************************************** */
 
     // Specific member functions
 
-    // ...
-
   };
 
-  // ...
+  struct Node* head = nullptr;
+  struct Node* tail = nullptr;
 
 public:
 
   // Default constructor
-  // List() specifiers;
+  List() = default;
 
   /* ************************************************************************ */
 
   // Specific constructor
-  // List(argument) specifiers; // A list obtained from a LinearContainer
+  List(const LinearContainer<Data>&); // A list obtained from a LinearContainer
 
   /* ************************************************************************ */
 
   // Copy constructor
-  // List(argument) specifiers;
+  List(const List&);
 
   // Move constructor
-  // List(argument) specifiers;
+  List(List&&);
 
   /* ************************************************************************ */
 
   // Destructor
-  // ~List() specifiers;
+  ~List();
 
   /* ************************************************************************ */
 
   // Copy assignment
-  // type operator=(argument) specifiers;
+   List& operator=(const List&);
 
   // Move assignment
-  // type operator=(argument) specifiers;
+   List& operator=(List&&) noexcept;
 
   /* ************************************************************************ */
 
   // Comparison operators
-  // type operator==(argument) specifiers;
+   bool operator==(const List&) const noexcept;
-  // type operator!=(argument) specifiers;
+   bool operator!=(const List&) const noexcept;
 
   /* ************************************************************************ */
 
   // Specific member functions
 
-  // type InsertAtFront(argument) specifier; // Copy of the value
+  void InsertAtFront(const Data&); // Copy of the value
-  // type InsertAtFront(argument) specifier; // Move of the value
+  void InsertAtFront(Data&&); // Move of the value
-  // type RemoveFromFront() specifier; // (must throw std::length_error when empty)
+  void RemoveFromFront(); // (must throw std::length_error when empty)
-  // type FrontNRemove() specifier; // (must throw std::length_error when empty)
+  Data FrontNRemove(); // (must throw std::length_error when empty)
 
-  // type InsertAtBack(argument) specifier; // Copy of the value
+  void InsertAtBack(const Data&); // Copy of the value
-  // type InsertAtBack(argument) specifier; // Move of the value
+  void InsertAtBack(Data&&); // Move of the value
 
   /* ************************************************************************ */
 
   // Specific member functions (inherited from Container)
 
-  // type Clear() specifiers; // Override Container member
+   void Clear() override; // Override Container member
 
   /* ************************************************************************ */
 
   // Specific member functions (inherited from LinearContainer)
 
-  // type Front() specifiers; // Override LinearContainer member (must throw std::length_error when empty)
+  Data& Front() const override; // Override LinearContainer member (must throw std::length_error when empty)
-  // type Back() specifiers; // Override LinearContainer member (must throw std::length_error when empty)
+  Data& Back() const override; // Override LinearContainer member (must throw std::length_error when empty)
 
-  // type operator[](argument) specifiers; // Override LinearContainer member (must throw std::out_of_range when out of range)
+  Data& operator[](const ulong) const override; // Override LinearContainer member (must throw std::out_of_range when out of range)
 
   /* ************************************************************************ */
 
   // Specific member functions (inherited from MappableContainer)
 
-  // using typename MappableContainer<Data>::MapFunctor;
+  using typename MappableContainer<Data>::MapFunctor;
 
-  // type MapPreOrder(arguments) specifiers; // Override MappableContainer member
+  void MapPreOrder(const MapFunctor, void*) override; // Override MappableContainer member
-  // type MapPostOrder(arguments) specifiers; // Override MappableContainer member
+  void MapPostOrder(const MapFunctor, void*) override; // Override MappableContainer member
 
   /* ************************************************************************ */
 
   // Specific member functions (inherited from FoldableContainer)
 
-  // using typename FoldableContainer<Data>::FoldFunctor;
+  using typename FoldableContainer<Data>::FoldFunctor;
 
-  // type FoldPreOrder(arguments) specifiers; // Override FoldableContainer member
+  void FoldPreOrder(const FoldFunctor, const void*, void*) const override; // Override FoldableContainer member
-  // type FoldPostOrder(arguments) specifiers; // Override FoldableContainer member
+  void FoldPostOrder(const FoldFunctor, const void*, void*) const override; // Override FoldableContainer member
 
 protected:
 
   // Auxiliary member functions (for MappableContainer)
 
-  // type MapPreOrder(arguments) specifiers; // Accessory function executing from one point of the list onwards
+  void MapPreOrder(const MapFunctor, void* , struct Node*); // Accessory function executing from one point of the list onwards
-  // type MapPostOrder(arguments) specifiers; // Accessory function executing from one point of the list onwards
+  void MapPostOrder(const MapFunctor, void* , struct Node*); // Accessory function executing from one point of the list onwards
 
   /* ************************************************************************ */
 
   // Auxiliary member functions (for FoldableContainer)
 
-  // type FoldPreOrder(arguments) specifiers; // Accessory function executing from one point of the list onwards
+  void FoldPreOrder(const FoldFunctor, const void*, void*, struct Node*) const; // Accessory function executing from one point of the list onwards
-  // type FoldPostOrder(arguments) specifiers; // Accessory function executing from one point of the list onwards
+  void FoldPostOrder(const FoldFunctor, const void*, void*, struct Node*) const;; // Accessory function executing from one point of the list onwards
 
 };
 

librerie/exercise4/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/exercise4/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;
+  bool operator==(const QueueLst&) const noexcept;
-  // type operator!=(argument) specifiers;
+  bool operator!=(const QueueLst&) const noexcept;
 
   /* ************************************************************************ */
 
   // Specific member functions (inherited from Queue)
 
-  // type Enqueue(argument) specifiers; // Override Queue member (copy of the value)
+  void Enqueue(const Data&) override; // Override Queue member (copy of the value)
-  // type Enqueue(argument) specifiers; // Override Queue member (move of the value)
+  void Enqueue(Data&&) override; // Override Queue member (move of the value)
-  // type Head() specifiers; // Override Queue member (must throw std::length_error when empty)
+  Data& Head() const override; // Override Queue member (must throw std::length_error when empty)
-  // type Dequeue() specifiers; // Override Queue member (must throw std::length_error when empty)
+  void Dequeue() override; // Override Queue member (must throw std::length_error when empty)
-  // type HeadNDequeue() specifiers; // 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/exercise4/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.
+  bool operator==(const Queue&) const noexcept = delete; // 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.
 
   /* ************************************************************************ */
 
   // Specific member functions
 
-  // type Enqueue(argument) specifiers; // Copy of the value
+  virtual void Enqueue(const Data&) = 0; // Copy of the value
-  // type Enqueue(argument) specifiers; // Move of the value
+  virtual void Enqueue(Data&&) = 0; // Move of the value
-  // type Head() specifiers; // (concrete function must throw std::length_error when empty)
+  virtual Data& Head() const = 0; // (concrete function must throw std::length_error when empty)
-  // type Dequeue() specifiers; // (concrete function must throw std::length_error when empty)
+  virtual void Dequeue() = 0; // (concrete function must throw std::length_error when empty)
-  // type HeadNDequeue() specifiers; // (concrete function must throw std::length_error when empty)
+  virtual Data HeadNDequeue() = 0; // (concrete function must throw std::length_error when empty)
 
 };
 

librerie/exercise4/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/exercise4/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;
+  bool operator==(const QueueVec&) const noexcept;
-  // type operator!=(argument) specifiers;
+  bool operator!=(const QueueVec&) const noexcept;
 
   /* ************************************************************************ */
 
   // Specific member functions (inherited from Queue)
 
-  // type Enqueue(argument) specifiers; // Override Queue member (copy of the value)
+  void Enqueue(const Data&) override; // Override Queue member (copy of the value)
-  // type Enqueue(argument) specifiers; // Override Queue member (move of the value)
+  void Enqueue(Data&&) override; // Override Queue member (move of the value)
-  // type Head() specifiers; // Override Queue member (must throw std::length_error when empty)
+  Data& Head() const override; // Override Queue member (must throw std::length_error when empty)
-  // type Dequeue() specifiers; // Override Queue member (must throw std::length_error when empty)
+  void Dequeue() override; // Override Queue member (must throw std::length_error when empty)
-  // type HeadNDequeue() specifiers; // 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;
+  void Expand();
-  // type Reduce() specifiers;
+  void Reduce();
-  // type SwapVectors(arguments) specifiers;
+
+  //void SwapVectors(arguments) specifiers;
 
 };
 

librerie/exercise4/stack/lst/stacklst.cpp

@@ -3,7 +3,77 @@ namespace lasd {
 
 /* ************************************************************************** */
 
-// ...
+// Constructors
+template <typename Data>
+StackLst<Data>::StackLst(const LinearContainer<Data>& linear)
+  : List<Data>(linear){}
+
+template <typename Data>
+StackLst<Data>::StackLst(const StackLst& stcklist)
+  : List<Data>(stcklist){}
+
+template <typename Data>
+StackLst<Data>::StackLst(StackLst&& stcklist) noexcept
+  : List<Data>(std::move(stcklist)){}
+
+// Destructor
+template <typename Data>
+StackLst<Data>::~StackLst(){
+  Clear();
+}
+
+template <typename Data>
+StackLst<Data>& StackLst<Data>::operator=(const StackLst& copyFrom){
+  List<Data>::operator=(copyFrom);
+  return *this;
+}
+
+template <typename Data>
+StackLst<Data>& StackLst<Data>::operator=(StackLst&& moveFrom) noexcept{
+  List<Data>::operator=(std::move(moveFrom));
+  return *this;
+}
+
+template <typename Data>
+bool StackLst<Data>::operator==(const StackLst& stcklist) const noexcept{
+  return List<Data>::operator==(stcklist);
+}
+
+template <typename Data>
+bool StackLst<Data>::operator!=(const StackLst& stcklist) const noexcept{
+  return List<Data>::operator!=(stcklist);
+}
+
+// Specific member functions (inherited from Stack)
+template <typename Data>
+void StackLst<Data>::Push(const Data& element){
+  List<Data>::InsertAtFront(element);
+}
+
+template <typename Data>
+void StackLst<Data>::Push(Data&& element) noexcept{
+  List<Data>::InsertAtFront(element);
+}
+
+template <typename Data>
+Data& StackLst<Data>::Top() const{
+  return List<Data>::Front();
+}
+
+template <typename Data>
+void StackLst<Data>::Pop(){
+  List<Data>::RemoveFromFront();
+}
+
+template <typename Data>
+Data StackLst<Data>::TopNPop(){
+  return List<Data>::FrontNRemove();
+}
+
+template <typename Data>
+void StackLst<Data>::Clear(){
+  List<Data>::Clear();
+}
 
 /* ************************************************************************** */
 

librerie/exercise4/stack/lst/stacklst.hpp

@@ -14,70 +14,69 @@ namespace lasd {
 /* ************************************************************************** */
 
 template <typename Data>
-class StackLst { // Must extend Stack<Data> and List<Data>
+class StackLst : virtual public Stack<Data>,
+                 virtual protected List<Data> { // Must extend Stack<Data> and List<Data>
 
 private:
 
-  // ...
-
 protected:
 
-  // using List<Data>::???;
+  using List<Data>::head;
-
+  using List<Data>::size;
-  // ...
+  using typename List<Data>::Node;
 
 public:
 
   // Default constructor
-  // StackLst() specifier;
+  StackLst() = default;
 
   /* ************************************************************************ */
 
   // Specific constructor
-  // StackLst(argument) specifiers; // A stack obtained from a LinearContainer
+  StackLst(const LinearContainer<Data>&); // A stack obtained from a LinearContainer
 
   /* ************************************************************************ */
 
   // Copy constructor
-  // StackLst(argument);
+  StackLst(const StackLst&);
 
   // Move constructor
-  // StackLst(argument);
+  StackLst(StackLst&&) noexcept;
 
   /* ************************************************************************ */
 
   // Destructor
-  // ~StackLst() specifier;
+  virtual ~StackLst();
 
   /* ************************************************************************ */
 
   // Copy assignment
-  // type operator=(argument);
+  StackLst& operator=(const StackLst&);
 
   // Move assignment
-  // type operator=(argument);
+  StackLst& operator=(StackLst&&) noexcept;
 
   /* ************************************************************************ */
 
   // Comparison operators
-  // type operator==(argument) specifiers;
+  bool operator==(const StackLst&) const noexcept;
-  // type operator!=(argument) specifiers;
+  bool operator!=(const StackLst&) const noexcept;
 
   /* ************************************************************************ */
 
   // Specific member functions (inherited from Stack)
 
-  // type Push(argument) specifiers; // Override Stack member (copy of the value)
+  void Push(const Data&) override; // Override Stack member (copy of the value)
-  // type Push(argument) specifiers; // Override Stack member (move of the value)
+  void Push(Data&&) noexcept override; // Override Stack member (move of the value)
-  // type Top() specifiers; // Override Stack member (must throw std::length_error when empty)
+  Data& Top() const override; // Override Stack member (must throw std::length_error when empty)
-  // type Pop() specifiers; // Override Stack member (must throw std::length_error when empty)
+  void Pop() override; // Override Stack member (must throw std::length_error when empty)
-  // type TopNPop() specifiers; // Override Stack member (must throw std::length_error when empty)
+  Data TopNPop() override; // Override Stack 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/exercise4/stack/stack.hpp

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

librerie/exercise4/stack/vec/stackvec.cpp

@@ -2,9 +2,142 @@
 namespace lasd {
 
 /* ************************************************************************** */
-
+// constructors
-// ...
+template <typename Data>
-
+StackVec<Data>::StackVec(){
-/* ************************************************************************** */
+  size = 4; // default vector is instantiated with 4 cells
-
+  stackSize = 0;
+  Elements = new Data[size];
+}
+
+template <typename Data>
+StackVec<Data>::StackVec(const LinearContainer<Data>& linear)
+  : Vector<Data>(linear){
+  stackSize = linear.Size(); // the array is full
+}
+
+template <typename Data>
+StackVec<Data>::StackVec(const StackVec& stckvec)
+  : Vector<Data>(stckvec){
+  stackSize = stckvec.Size(); // the array is full
+}
+
+
+template <typename Data>
+StackVec<Data>::StackVec(StackVec&& toMove) noexcept
+  : Vector<Data>(std::move(toMove)){
+  std::swap(stackSize, toMove.stackSize);
+}
+
+template <typename Data>
+StackVec<Data>::~StackVec(){
+  // Vector destructor will be called automatically
+}
+
+template <typename Data>
+StackVec<Data>& StackVec<Data>::operator=(const StackVec<Data>& copyFrom){
+  Vector<Data>::operator=(copyFrom); // espandere di un po' forse
+  stackSize = copyFrom.Size();
+  return *this;
+}
+
+template <typename Data>
+StackVec<Data>& StackVec<Data>::operator=(StackVec<Data>&& moveFrom) noexcept{
+  Vector<Data>::operator=(std::move(moveFrom));
+  stackSize = moveFrom.Size();
+  return *this;
+}
+
+template <typename Data>
+bool StackVec<Data>::operator==(const StackVec<Data>& toCompare) const noexcept{
+  if(stackSize == toCompare.Size()){
+    for(ulong i=0 ; i<stackSize ; ++i){
+      if(Elements[i] != toCompare[i]){
+        return false;
+      }
+    }
+    return true;
+  }else{
+    return false;
+  }
+}
+
+template <typename Data>
+bool StackVec<Data>::operator!=(const StackVec<Data>& toCompare) const noexcept{
+  return !(*this == toCompare);
+}
+
+// Specific member functions (inherited from Stack)
+template <typename Data>
+void StackVec<Data>::Push(const Data& data){
+  if(size == stackSize){
+    Expand();
+  }
+  Elements[stackSize] = data;
+  ++stackSize;
+}
+
+template <typename Data>
+void StackVec<Data>::Push(Data&& data){
+  if(size == stackSize){
+    Expand();
+  }
+  std::swap(Elements[stackSize], data);
+  ++stackSize;
+}
+
+template <typename Data>
+Data& StackVec<Data>::Top() const{
+  if(stackSize == 0){
+    throw std::length_error("Empty Stack!");
+  }
+  return Elements[stackSize-1];
+}
+
+template <typename Data>
+void StackVec<Data>::Pop(){
+  if(stackSize==0){
+    throw std::length_error("Empty Stack!");
+  }
+  --stackSize;
+  if(stackSize < (int)(size/4)){
+    Reduce();
+  }
+}
+
+template <typename Data>
+Data StackVec<Data>::TopNPop(){
+  Data data = Top();
+  Pop();
+  return data;
+}
+
+template <typename Data>
+bool StackVec<Data>::Empty() const noexcept{
+  return (stackSize == 0);
+}
+
+template <typename Data>
+ulong StackVec<Data>::Size() const noexcept{
+  return stackSize;
+}
+
+template <typename Data>
+void StackVec<Data>::Expand(){
+  Vector<Data>::Resize(size * 2);
+}
+
+template <typename Data>
+void StackVec<Data>::Reduce(){
+  if(size <= 4) return; // we're not going to have vectors with less than 4 cells
+  Vector<Data>::Resize((ulong)size/2);
+}
+
+template <typename Data>
+void StackVec<Data>::Clear(){
+  delete [] Elements;
+  size = 4;
+  stackSize = 0;
+  Elements = new Data[size];
+}
 }

librerie/exercise4/stack/vec/stackvec.hpp

@@ -14,81 +14,81 @@ namespace lasd {
 /* ************************************************************************** */
 
 template <typename Data>
-class StackVec { // Must extend Stack<Data> and Vector<Data>
+class StackVec : virtual public Stack<Data>,
+                 virtual protected Vector<Data>{ // Must extend Stack<Data> and Vector<Data>
 
 private:
 
-  // ...
-
 protected:
 
-  // using Vector<Data>::???;
+  ulong stackSize = 0; // first empty cell and # of elements in the vector
+  using Vector<Data>::Elements;
+  using Vector<Data>::size; // dimension of the vector
 
-  // ...
 
 public:
 
   // Default constructor
-  // StackVec() specifier;
+  StackVec();
 
   /* ************************************************************************ */
 
   // Specific constructor
-  // StackVec(argument) specifiers; // A stack obtained from a LinearContainer
+  StackVec(const LinearContainer<Data>&); // A stack obtained from a LinearContainer
 
   /* ************************************************************************ */
 
   // Copy constructor
-  // StackVec(argument);
+  StackVec(const StackVec&);
 
   // Move constructor
-  // StackVec(argument);
+  StackVec(StackVec&&) noexcept;
 
   /* ************************************************************************ */
 
   // Destructor
-  // ~StackVec() specifier;
+  virtual ~StackVec();
 
   /* ************************************************************************ */
 
   // Copy assignment
-  // type operator=(argument);
+  StackVec& operator=(const StackVec&);
 
   // Move assignment
-  // type operator=(argument);
+  StackVec& operator=(StackVec&&) noexcept;
 
   /* ************************************************************************ */
 
   // Comparison operators
-  // type operator==(argument) specifiers;
+  bool operator==(const StackVec&) const noexcept;
-  // type operator!=(argument) specifiers;
+  bool operator!=(const StackVec&) const noexcept;
 
   /* ************************************************************************ */
 
   // Specific member functions (inherited from Stack)
 
-  // type Push(argument) specifiers; // Override Stack member (copy of the value)
+  void Push(const Data&) override; // Override Stack member (copy of the value)
-  // type Push(argument) specifiers; // Override Stack member (move of the value)
+  void Push(Data&&) override; // Override Stack member (move of the value)
-  // type Top() specifiers; // Override Stack member (must throw std::length_error when empty)
+  Data& Top() const override; // Override Stack member (must throw std::length_error when empty)
-  // type Pop() specifiers; // Override Stack member (must throw std::length_error when empty)
+  void Pop() override; // Override Stack member (must throw std::length_error when empty)
-  // type TopNPop() specifiers; // Override Stack member (must throw std::length_error when empty)
+  Data TopNPop() override; // Override Stack 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;
+  void Expand();
-  // type Reduce() specifiers;
+  void Reduce();
 
 };
 

librerie/exercise4/vector/vector.cpp

@@ -1,10 +1,160 @@
 
 namespace lasd {
 
-/* ************************************************************************** */
+template <typename Data>
-
+Vector<Data>::Vector(const ulong newsize){
-// ...
+  Elements = new Data[newsize]{};
-
+  size = newsize;
-/* ************************************************************************** */
+}
-
+
+template <typename Data>
+Vector<Data>::Vector(const LinearContainer<Data>& con){
+  size = con.Size();
+  Elements = new Data[size]{};
+  for(ulong i=0; i<size; ++i){
+    Elements[i] = con[i];
+  }
+}
+
+// Copy constructor
+template <typename Data>
+Vector<Data>::Vector(const Vector<Data>& vec){
+  size = vec.size;
+  Elements = new Data[size]{};
+  for(ulong i=0; i<size; ++i){
+    Elements[i] = vec[i];
+  }
+}
+
+// Move constructor
+template <typename Data>
+ Vector<Data>::Vector(Vector<Data>&& vec)noexcept{
+   std::swap(Elements, vec.Elements);
+   std::swap(size, vec.size);
+ }
+
+ // Destructor
+template <typename Data>
+Vector<Data>::~Vector(){
+  Clear();
+}
+
+// Copy assignment
+template <typename Data>
+Vector<Data>& Vector<Data>::operator=(const Vector<Data>& vec){
+  Vector<Data>* tmpvec = new Vector<Data>(vec);
+  std::swap(*tmpvec, *this);
+  delete tmpvec;
+  return *this;
+}
+
+// Move assignment
+template <typename Data>
+Vector<Data>& Vector<Data>::operator=(Vector<Data>&& vec)noexcept{
+  std::swap(Elements,vec.Elements);
+  std::swap(size, vec.size);
+  return *this;
+}
+
+template <typename Data>
+bool Vector<Data>::operator==(const Vector<Data>& vec) const noexcept{
+  if(size == vec.size){
+    for(ulong i=0; i<size; ++i){
+      if(Elements[i] != vec.Elements[i])
+        return false;
+      }
+      return true;
+  }else{
+      return false;
+   }
+}
+
+template <typename Data>
+bool Vector<Data>::operator!=(const Vector<Data>& vec)const noexcept{
+  return !(*this == vec);
+}
+
+template <typename Data>
+void Vector<Data>::Resize(const ulong newsize){
+  if(newsize == 0){
+    Clear();
+  }
+  else if(size != newsize){
+    ulong limit = (size < newsize) ? size : newsize;
+    Data* TmpElements = new Data[newsize]{};
+    for(ulong i=0; i<limit; ++i){
+      std::swap(Elements[i], TmpElements[i]);
+    }
+    std::swap(Elements, TmpElements);
+    size = newsize;
+    delete[] TmpElements;
+  }
+}
+
+template <typename Data>
+void Vector<Data>::Clear(){
+  delete[] Elements;
+  Elements = nullptr;
+  size = 0;
+}
+
+template <typename Data>
+Data& Vector<Data>::Front() const {
+  if(size != 0){
+    return Elements[0];
+  }
+  else{
+    throw std::length_error("Access to an empty vector!");
+  }
+}
+
+template <typename Data>
+Data& Vector<Data>::Back() const {
+  if(size != 0){
+    return Elements[size - 1];
+  }
+  else{
+    throw std::length_error("Access to an empty vector!");
+  }
+}
+
+template <typename Data>
+Data& Vector<Data>::operator[](const ulong index) const{
+  if(index < size){
+    return Elements[index];
+  }
+  else{
+    throw std::out_of_range("Tried to access index " + std::to_string(index) + " but the dimension of the vector is " + std::to_string(size));
+  }
+}
+
+template <typename Data>
+void Vector<Data>::MapPreOrder(const MapFunctor fun, void* par){
+  for(ulong i=0; i<size; ++i){
+    fun(Elements[i], par);
+  }
+}
+
+template <typename Data>
+void Vector<Data>::MapPostOrder(const MapFunctor fun, void* par){
+  ulong index = size;
+  while(index > 0){
+    fun(Elements[--index], par);
+  }
+}
+
+template <typename Data>
+void Vector<Data>::FoldPreOrder(const FoldFunctor fun, const void* par, void* acc) const{
+  for(ulong i=0; i<size; ++i){
+    fun(Elements[i], par, acc);
+  }
+}
+
+template <typename Data>
+void Vector<Data>::FoldPostOrder(const FoldFunctor fun, const void* par, void* acc) const{
+  ulong idx = size;
+  while(idx > 0){
+    fun(Elements[--idx], par, acc);
+  }
+}
 }

librerie/exercise4/vector/vector.hpp

@@ -13,99 +13,65 @@ namespace lasd {
 /* ************************************************************************** */
 
 template <typename Data>
-class Vector { // Must extend LinearContainer<Data>, MappableContainer<Data>, and FoldableContainer<Data>
+class Vector : virtual public LinearContainer<Data>,
+               virtual public MappableContainer<Data>,
+               virtual public FoldableContainer<Data>{ // Must extend LinearContainer<Data>, MappableContainer<Data>, and FoldableContainer<Data>
 
 private:
 
-  // ...
 
 protected:
 
-  // using LinearContainer<Data>::???;
+   using LinearContainer<Data>::size;
-
+   Data* Elements = nullptr;
-  // ...
 
 public:
 
-  // Default constructor
+  Vector() = default;
-  // Vector() specifiers;
-
-  /* ************************************************************************ */
 
   // Specific constructors
-  // Vector(argument) specifiers; // A vector with a given initial dimension
+  Vector(const ulong); // A vector with a given initial dimension
-  // Vector(argument) specifiers; // A vector obtained from a LinearContainer
+  Vector(const LinearContainer<Data>&); // A vector obtained from a LinearContainer
-
-  /* ************************************************************************ */
 
   // Copy constructor
-  // Vector(argument) specifiers;
+  Vector(const Vector&);
 
   // Move constructor
-  // Vector(argument) specifiers;
+  Vector(Vector&&)noexcept;
-
-  /* ************************************************************************ */
 
   // Destructor
-  // ~Vector() specifiers;
+  ~Vector();
-
-  /* ************************************************************************ */
 
   // Copy assignment
-  // type operator=(argument) specifiers;
+   Vector& operator=(const Vector&);
 
   // Move assignment
-  // type operator=(argument) specifiers;
+  Vector& operator=(Vector&&) noexcept;
-
-  /* ************************************************************************ */
 
   // Comparison operators
-  // type operator==(argument) specifiers;
+  bool operator==(const Vector&) const noexcept;
-  // type operator!=(argument) specifiers;
+  bool operator!=(const Vector&) const noexcept;
 
-  /* ************************************************************************ */
+  void Resize(const ulong); // Resize the vector to a given size
 
-  // Specific member functions
+  void Clear() override; // Override Container member
 
-  // type Resize(argument) specifiers; // Resize the vector to a given size
+  Data& Front() const override; // Override LinearContainer member (must throw std::length_error when empty)
+  Data& Back() const override; // Override LinearContainer member (must throw std::length_error when empty)
 
-  /* ************************************************************************ */
+  Data& operator[](const ulong) const override; // Override LinearContainer member (must throw std::out_of_range when out of range)
 
-  // Specific member functions (inherited from Container)
+  using typename MappableContainer<Data>::MapFunctor;
 
-  // type Clear() specifiers; // Override Container member
+  void MapPreOrder(const MapFunctor, void*) override; // Override MappableContainer member
+  void MapPostOrder(const MapFunctor, void*) override; // Override MappableContainer member
 
-  /* ************************************************************************ */
+  using typename FoldableContainer<Data>::FoldFunctor;
-
-  // Specific member functions (inherited from LinearContainer)
-
-  // type Front() specifiers; // Override LinearContainer member (must throw std::length_error when empty)
-  // type Back() specifiers; // Override LinearContainer member (must throw std::length_error when empty)
-
-  // type operator[](argument) specifiers; // Override LinearContainer member (must throw std::out_of_range when out of range)
-
-  /* ************************************************************************ */
-
-  // Specific member functions (inherited from MappableContainer)
-
-  // using typename MappableContainer<Data>::MapFunctor;
-
-  // type MapPreOrder(arguments) specifiers; // Override MappableContainer member
-  // type MapPostOrder(arguments) specifiers; // Override MappableContainer member
-
-  /* ************************************************************************ */
-
-  // Specific member functions (inherited from FoldableContainer)
-
-  // using typename FoldableContainer<Data>::FoldFunctor;
-
-  // type FoldPreOrder(arguments) specifiers; // Override FoldableContainer member
-  // type FoldPostOrder(arguments) specifiers; // Override FoldableContainer member
 
+  void FoldPreOrder(const FoldFunctor, const void*, void*) const override; // Override FoldableContainer member
+  void FoldPostOrder(const FoldFunctor, const void*, void*) const override; // Override FoldableContainer member
 };
 
-/* ************************************************************************** */
-
 }
 
 #include "vector.cpp"