Library 1

fixed issue #2 and cleaned code
2021-04-23 21:44:06 +02:00 · 2021-04-23 21:44:06 +02:00 · dc0739a4f8
parent 69489dac81
commit dc0739a4f8
5 changed files with 273 additions and 354 deletions
--- a/.gitignore
+++ b/.gitignore
@ -0,0 +1,2 @@
+
+**/main
--- a/librerie/exercise1/container/container.hpp
+++ b/librerie/exercise1/container/container.hpp
@ -31,7 +31,6 @@ public:
   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)
@ -43,10 +42,6 @@ public:
   virtual void Clear() = 0;
 };

-/* ************************************************************************** */
-
-
-
 template <typename Data>
 class LinearContainer : virtual public Container{ // Must extend Container

@ -72,7 +67,6 @@ public:
  /* ************************************************************************ */

  // 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)

@ -105,7 +99,6 @@ public:
  /* ************************************************************************ */

  // Specific member functions
-
  virtual bool Exists(const Data&) const noexcept = 0; // (concrete function should not throw exceptions)

 };
--- a/librerie/exercise1/list/list.cpp
+++ b/librerie/exercise1/list/list.cpp
@ -29,21 +29,16 @@ List<Data>::Node::Node(Data&& moveFrom){
  std::swap(value, moveFrom);
 }

-
-// Comparison operator
 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);
 }

-
-// Specific constructor
 template <typename Data>
 List<Data>::List(const LinearContainer<Data>& con){
  for(ulong i = 0; i<con.Size(); ++i){
@ -51,7 +46,6 @@ List<Data>::List(const LinearContainer<Data>& con){
    }
 }

-// Copy constructor
 template <typename Data>
 List<Data>::List(const List<Data>& copyFrom){
  for(ulong i = 0; i<copyFrom.Size(); ++i){
@ -59,7 +53,6 @@ List<Data>::List(const List<Data>& copyFrom){
    }
 }

-// Move constructor
 template <typename Data>
 List<Data>::List(List<Data>&& moveFrom){
  std::swap(size, moveFrom.size);
@ -72,7 +65,6 @@ List<Data>::~List(){
  Clear();
 }

-// Copy assignment
 template <typename Data>
 List<Data>& List<Data>::operator=(const List<Data>& copyFrom){
 if(*this != copyFrom){
@ -84,7 +76,6 @@ template <typename Data>
   return *this;
 }

- //Move assignment
 template <typename Data>
 List<Data>& List<Data>::operator=(List<Data>&& moveFrom)noexcept{
   if(*this != moveFrom){
@ -95,11 +86,10 @@ template <typename Data>
  return *this;
 }

- //Comparison operators
 template <typename Data>
 bool List<Data>::operator==(const List<Data>& list) const noexcept{
-   if(this->size != list.Size()) return false;
-   for(ulong i = 0; i < (this->size); ++i){
+   if(size != list.Size()) return false;
+   for(ulong i = 0 ; i < size ; ++i){
     if((*this)[i] != list[i]) return false;
   }
   return true;
@ -110,28 +100,23 @@ bool List<Data>::operator!=(const List<Data>& list) const noexcept{
  return !(*this==list);
 }

-// Specific member functions
-
 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(data);
+  struct Node* tmp = new Node(std::move(data));
  tmp->next = head;
  head = tmp;
  size++;
-
  if(size == 1){
    tail = head;
  }
@ -148,7 +133,6 @@ bool List<Data>::operator!=(const List<Data>& list) const noexcept{
      tmp->next = nullptr;
      delete tmp;
      size--;
-
      if(head==nullptr){
        tail=nullptr;
      }
@ -186,7 +170,7 @@ bool List<Data>::operator!=(const List<Data>& list) const noexcept{
    InsertAtFront(data);
  }
  else{
-      struct Node* last = new Node(data);
+    struct Node* last = new Node(std::move(data));
    tail->next = last;
    tail = last;
    size++;
@ -219,20 +203,18 @@ bool List<Data>::operator!=(const List<Data>& list) const noexcept{
 }

 template <typename Data>
-  Data& List<Data>::operator[](const ulong idx) const{
-    if(idx >= size || idx < 0){
+Data& List<Data>::operator[](const ulong index) const{
+  if(index >= size || index < 0){
    throw std::out_of_range("Out of Range!");
-    }else
-    {
+  }else{
    struct Node* tmp = head;
-      for(ulong i=0; i<idx; ++i){
+    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);
@ -253,43 +235,31 @@ bool List<Data>::operator!=(const List<Data>& list) const noexcept{
  FoldPostOrder(function, constPar, par, head);
 }

-     //OVERLOAD Accessory Function
-
 template <typename Data>
 void List<Data>::MapPreOrder(MapFunctor function, void* par, struct Node* node){
-       if(node == nullptr)
-         return;
-
+  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;
-
+  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;
-
+  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;
-
+  if(node == nullptr) return;
  FoldPostOrder(function, constPar, par, node->next);
  function(node->value, constPar, par);
 }
-/* ************************************************************************** */
 }
--- a/librerie/exercise1/vector/vector.cpp
+++ b/librerie/exercise1/vector/vector.cpp
@ -56,7 +56,6 @@ template <typename Data>
  return *this;
 }

-   // Comparison operators
 template <typename Data>
 bool Vector<Data>::operator==(const Vector<Data>& vec) const noexcept{
  if(size == vec.size){
@ -70,7 +69,6 @@ template <typename Data>
   }
 }

-
 template <typename Data>
 bool Vector<Data>::operator!=(const Vector<Data>& vec)const noexcept{
  return !(*this == vec);
@ -80,8 +78,8 @@ template <typename Data>
 void Vector<Data>::Resize(const ulong newsize){
  if(newsize == 0){
    Clear();
-     }else if(size != newsize)
-     {
+  }
+  else if(size != newsize){
    ulong limit = (size < newsize) ? size : newsize;
    Data* TmpElements = new Data[newsize]{};
    for(ulong i=0; i<limit; ++i){
@ -93,7 +91,6 @@ template <typename Data>
  }
 }

-
 template <typename Data>
 void Vector<Data>::Clear(){
  delete[] Elements;
@ -103,38 +100,34 @@ template <typename Data>

 template <typename Data>
 Data& Vector<Data>::Front() const {
-       if(size != 0)
-       {
+  if(size != 0){
    return Elements[0];
-       }else{
+  }
+  else{
    throw std::length_error("Access to an empty vector!");
  }
 }

 template <typename Data>
 Data& Vector<Data>::Back() const {
-       if(size != 0)
-        {
+  if(size != 0){
    return Elements[size - 1];
-        }else{
+  }
+  else{
    throw std::length_error("Access to an empty vector!");
  }
 }

-
 template <typename Data>
-    Data& Vector<Data>::operator[](const ulong idx) const{
-      if(idx < size)
-      {
-        return Elements[idx];
+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(idx) + " but the dimension of the vector is " + std::to_string(size));
+  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){
@ -144,14 +137,12 @@ template <typename Data>

 template <typename Data>
 void Vector<Data>::MapPostOrder(const MapFunctor fun, void* par){
-      ulong idx = size;
-      while(idx > 0)
-      {
-        fun(Elements[--idx], 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){
--- a/librerie/exercise1/vector/vector.hpp
+++ b/librerie/exercise1/vector/vector.hpp
@ -25,90 +25,53 @@ protected:
   using LinearContainer<Data>::size;
   Data* Elements = nullptr;

-  // ...
-
 public:

-  // Default constructor
-  // Vector() specifiers;
  Vector() = default;

-
-  /* ************************************************************************ */
-
  // Specific constructors
  Vector(const ulong); // A vector with a given initial dimension
  Vector(const LinearContainer<Data>&); // A vector obtained from a LinearContainer

-  /* ************************************************************************ */
-
  // Copy constructor
  Vector(const Vector&);

  // Move constructor
  Vector(Vector&&)noexcept;

-  /* ************************************************************************ */
-
  // Destructor
  ~Vector();

-  /* ************************************************************************ */
-
  // Copy assignment
   Vector& operator=(const Vector&);

  // Move assignment
  Vector& operator=(Vector&&) noexcept;

-  /* ************************************************************************ */
-
  // Comparison operators
  bool operator==(const Vector&) const noexcept;
  bool operator!=(const Vector&) const noexcept;

-  /* ************************************************************************ */
-
-  // Specific member functions
-
  void Resize(const ulong); // Resize the vector to a given size

-  /* ************************************************************************ */
-
-  // Specific member functions (inherited from Container)
-
  void Clear() override; // Override Container member

-  /* ************************************************************************ */
-
-  // Specific member functions (inherited from LinearContainer)
-
  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 MappableContainer)
-
  using typename MappableContainer<Data>::MapFunctor;

  void MapPreOrder(const MapFunctor, void*) override; // Override MappableContainer member
  void MapPostOrder(const MapFunctor, void*) override; // Override MappableContainer member

-  /* ************************************************************************ */
-
-  // Specific member functions (inherited from FoldableContainer)
-
  using typename FoldableContainer<Data>::FoldFunctor;

  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"