[Esercizio 1]

container.cpp container.hpp

librerie/exercise1/build.sh

@@ -0,0 +1,7 @@
+
+#! /bin/bash
+
+g++ -O3 -o main \
+  zlasdtest/exercise1/simpletest.cpp zlasdtest/exercise1/fulltest.cpp \
+  zlasdtest/container/container.cpp \
+  zlasdtest/test.cpp zmytest/test.cpp main.cpp

librerie/exercise1/container/container.cpp

@@ -0,0 +1,17 @@
+
+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/exercise1/container/container.hpp

@@ -0,0 +1,304 @@
+
+#ifndef CONTAINER_HPP
+#define CONTAINER_HPP
+
+/* ************************************************************************** */
+
+#include <stdexcept>
+#include <functional>
+
+/* ************************************************************************** */
+
+namespace lasd {
+
+/* ************************************************************************** */
+
+class Container {
+
+private:
+
+protected:
+
+  ulong size = 0;
+
+public:
+
+  // Destructor
+  virtual ~Container() = default;
+
+  /* ************************************************************************ */
+
+  // Copy assignment
+  Container& operator=(const Container&) = delete; // Copy assignment of abstract types should not be possible.
+
+  // Move assignment
+  Container& operator=(Container&&) = delete; // Move assignment of abstract types should not be possible.
+
+  /* ************************************************************************ */
+
+  // Comparison operators
+  bool operator==(const Container&) const noexcept = delete; // 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 { // (concrete function should not throw exceptions)
+    return (size==0);
+  };
+
+  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&&) = 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)
+
+  virtual Data& operator[](const ulong) const = 0; // (concrete function must throw std::out_of_range when out of range)
+
+};
+
+/* ************************************************************************** */
+
+template <typename Data>
+class TestableContainer : 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&&) = 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&&) = 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 voi 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&&) = delete; // Move assignment of abstract types should not be possible.
+
+  /* ************************************************************************ */
+
+  // Comparison operators
+  bool operator==(const FoldableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible.
+  bool operator!=(const 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 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;
+
+};
+
+/* ************************************************************************** */
+
+}
+
+#include "container.cpp"
+
+#endif

librerie/exercise1/list/list.cpp

@@ -0,0 +1,10 @@
+
+namespace lasd {
+
+/* ************************************************************************** */
+
+// ...
+
+/* ************************************************************************** */
+
+}

librerie/exercise1/list/list.hpp

@@ -0,0 +1,169 @@
+
+#ifndef LIST_HPP
+#define LIST_HPP
+
+/* ************************************************************************** */
+
+#include "../container/container.hpp"
+
+/* ************************************************************************** */
+
+namespace lasd {
+
+/* ************************************************************************** */
+
+template <typename Data>
+class List { // Must extend LinearContainer<Data>, MappableContainer<Data>, and FoldableContainer<Data>
+
+private:
+
+  // ...
+
+protected:
+
+  // using LinearContainer<Data>::???;
+
+  struct Node
+  {
+
+    // Data
+    // ...
+
+    /* ********************************************************************** */
+
+    // Specific constructors
+    // ...
+
+    /* ********************************************************************** */
+
+    // Copy constructor
+    // ...
+
+    // Move constructor
+    // ...
+
+    /* ********************************************************************** */
+
+    // Destructor
+    // ...
+
+    /* ********************************************************************** */
+
+    // Comparison operators
+    // ...
+
+    /* ********************************************************************** */
+
+    // Specific member functions
+
+    // ...
+
+  };
+
+  // ...
+
+public:
+
+  // Default constructor
+  // List() specifiers;
+
+  /* ************************************************************************ */
+
+  // Specific constructor
+  // List(argument) specifiers; // A list obtained from a LinearContainer
+
+  /* ************************************************************************ */
+
+  // Copy constructor
+  // List(argument) specifiers;
+
+  // Move constructor
+  // List(argument) specifiers;
+
+  /* ************************************************************************ */
+
+  // Destructor
+  // ~List() 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
+
+  // type InsertAtFront(argument) specifier; // Copy of the value
+  // type InsertAtFront(argument) specifier; // Move of the value
+  // type RemoveFromFront() specifier; // (must throw std::length_error when empty)
+  // type FrontNRemove() specifier; // (must throw std::length_error when empty)
+
+  // type InsertAtBack(argument) specifier; // Copy of the value
+  // type InsertAtBack(argument) specifier; // Move of the value
+
+  /* ************************************************************************ */
+
+  // Specific member functions (inherited from Container)
+
+  // type Clear() specifiers; // Override Container member
+
+  /* ************************************************************************ */
+
+  // 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
+
+protected:
+
+  // Auxiliary member functions (for MappableContainer)
+
+  // type MapPreOrder(arguments) specifiers; // Accessory function executing from one point of the list onwards
+  // type MapPostOrder(arguments) specifiers; // 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
+  // type FoldPostOrder(arguments) specifiers; // Accessory function executing from one point of the list onwards
+
+};
+
+/* ************************************************************************** */
+
+}
+
+#include "list.cpp"
+
+#endif

librerie/exercise1/main.cpp

@@ -0,0 +1,16 @@
+
+#include "zlasdtest/test.hpp"
+
+#include "zmytest/test.hpp"
+
+/* ************************************************************************** */
+
+#include <iostream>
+
+/* ************************************************************************** */
+
+int main() {
+  std::cout << "Lasd Libraries 2020" << std::endl;
+  lasdtest(); // To call in the menu of your library test!
+  return 0;
+}

librerie/exercise1/vector/vector.cpp

@@ -0,0 +1,10 @@
+
+namespace lasd {
+
+/* ************************************************************************** */
+
+// ...
+
+/* ************************************************************************** */
+
+}

librerie/exercise1/vector/vector.hpp

@@ -0,0 +1,113 @@
+
+#ifndef VECTOR_HPP
+#define VECTOR_HPP
+
+/* ************************************************************************** */
+
+#include "../container/container.hpp"
+
+/* ************************************************************************** */
+
+namespace lasd {
+
+/* ************************************************************************** */
+
+template <typename Data>
+class Vector { // Must extend LinearContainer<Data>, MappableContainer<Data>, and FoldableContainer<Data>
+
+private:
+
+  // ...
+
+protected:
+
+  // using LinearContainer<Data>::???;
+
+  // ...
+
+public:
+
+  // Default constructor
+  // Vector() specifiers;
+
+  /* ************************************************************************ */
+
+  // Specific constructors
+  // Vector(argument) specifiers; // A vector with a given initial dimension
+  // Vector(argument) specifiers; // A vector obtained from a LinearContainer
+
+  /* ************************************************************************ */
+
+  // Copy constructor
+  // Vector(argument) specifiers;
+
+  // Move constructor
+  // Vector(argument) specifiers;
+
+  /* ************************************************************************ */
+
+  // Destructor
+  // ~Vector() 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
+
+  // type Resize(argument) specifiers; // Resize the vector to a given size
+
+  /* ************************************************************************ */
+
+  // Specific member functions (inherited from Container)
+
+  // type Clear() specifiers; // Override Container member
+
+  /* ************************************************************************ */
+
+  // 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
+
+};
+
+/* ************************************************************************** */
+
+}
+
+#include "vector.cpp"
+
+#endif

librerie/exercise1/zlasdtest/container/container.cpp

@@ -0,0 +1,49 @@
+
+#include <iostream>
+
+/* ************************************************************************** */
+
+#include "../../container/container.hpp"
+
+/* ************************************************************************** */
+
+// Container member functions!
+
+void Empty(uint& testnum, uint& testerr, const lasd::Container& con, bool chk) {
+  bool tst;
+  testnum++;
+  std::cout << " " << testnum << " The container is " << ((tst = con.Empty()) ? "" : "not ") << "empty: ";
+  std::cout << ((tst = (tst == chk)) ? "Correct" : "Error") << "!" << std::endl;
+  testerr += (1 - (uint) tst);
+}
+
+void Size(uint& testnum, uint& testerr, const lasd::Container& con, bool chk, ulong siz) {
+  bool tst;
+  testnum++;
+  std::cout << " " << testnum << " The container has size " << con.Size() << ": ";
+  std::cout << ((tst = ((con.Size() == siz) == chk)) ? "Correct" : "Error") << "!" << std::endl;
+  testerr += (1 - (uint) tst);
+}
+
+/* ************************************************************************** */
+
+// Auxiliary functions for MappableContainer!
+
+void MapStringAppend(std::string& dat, void* par) {
+  dat.append(*((std::string*) par));
+}
+
+/* ************************************************************************** */
+
+// Auxiliary functions for FoldableContainer!
+
+void FoldParity(const int& dat, const void* _, void* acc) {
+  *((int*) acc) += dat;
+  *((int*) acc) %= 2;
+}
+
+void FoldStringConcatenate(const std::string& dat, const void* _, void* acc) {
+  ((std::string*) acc)->append(dat);
+}
+
+/* ************************************************************************** */

librerie/exercise1/zlasdtest/container/container.hpp

@@ -0,0 +1,301 @@
+
+#ifndef CONTAINERTEST_HPP
+#define CONTAINERTEST_HPP
+
+#include "../../container/container.hpp"
+
+/* ************************************************************************** */
+
+// Container member functions!
+
+void Empty(uint&, uint&, const lasd::Container&, bool);
+
+void Size(uint&, uint&, const lasd::Container&, bool, ulong);
+
+/* ************************************************************************** */
+
+// LinearContainer member functions!
+
+template <typename Data>
+void GetFront(uint& testnum, uint& testerr, const lasd::LinearContainer<Data>& con, bool chk, const Data& val) {
+  bool tst;
+  testnum++;
+  try {
+    std::cout << " " << testnum << " The front of the linear container is \"" << con.Front() << "\": ";
+    std::cout << ((tst = ((con.Front() == val) == chk)) ? "Correct" : "Error") << "!" << std::endl;
+  } catch(std::length_error exc) {
+    std::cout << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
+  } catch(std::exception exc) {
+    tst = true;
+    std::cout << std::endl << "Wrong std::exception: " << exc.what() << "!" << std::endl;
+  }
+  testerr += (1 - (uint) tst);
+}
+
+template <typename Data>
+void SetFront(uint& testnum, uint& testerr, const lasd::LinearContainer<Data>& con, bool chk, const Data& val) {
+  bool tst;
+  testnum++;
+  try {
+    std::cout << " " << testnum << " Setting the front of the linear container to \"" << val << "\": ";
+    con.Front() = val;
+    std::cout << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl;
+  } catch(std::length_error exc) {
+    std::cout << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
+  } catch(std::exception exc) {
+    tst = true;
+    std::cout << std::endl << "Wrong std::exception: " << exc.what() << "!" << std::endl;
+  }
+  testerr += (1 - (uint) tst);
+}
+
+template <typename Data>
+void GetBack(uint& testnum, uint& testerr, const lasd::LinearContainer<Data>& con, bool chk, const Data& val) {
+  bool tst;
+  testnum++;
+  try {
+    std::cout << " " << testnum << " The back of the linear container is \"" << con.Back() << "\": ";
+    std::cout << ((tst = ((con.Back() == val) == chk)) ? "Correct" : "Error") << "!" << std::endl;
+  } catch(std::length_error exc) {
+    std::cout << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
+  } catch(std::exception exc) {
+    tst = true;
+    std::cout << std::endl << "Wrong std::exception: " << exc.what() << "!" << std::endl;
+  }
+  testerr += (1 - (uint) tst);
+}
+
+template <typename Data>
+void SetBack(uint& testnum, uint& testerr, const lasd::LinearContainer<Data>& con, bool chk, const Data& val) {
+  bool tst;
+  testnum++;
+  try {
+    std::cout << " " << testnum << " Setting the back of the linear container to \"" << val << "\": ";
+    con.Back() = val;
+    std::cout << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl;
+  } catch(std::length_error exc) {
+    std::cout << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
+  } catch(std::exception exc) {
+    tst = true;
+    std::cout << std::endl << "Wrong std::exception: " << exc.what() << "!" << std::endl;
+  }
+  testerr += (1 - (uint) tst);
+}
+
+template <typename Data>
+void SetAt(uint& testnum, uint& testerr, lasd::LinearContainer<Data>& con, bool chk, const ulong& ind, const Data& val) {
+  bool tst;
+  testnum++;
+  try {
+    std::cout << " " << testnum << " Set of the linear container at index \"" << ind << "\" with value \"" << val << "\": ";
+    con[ind] = val;
+    std::cout << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl;
+  } catch(std::out_of_range exc) {
+    std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
+  } catch(std::exception exc) {
+    tst = true;
+    std::cout << std::endl << "Wrong std::exception: " << exc.what() << "!" << std::endl;
+  }
+  testerr += (1 - (uint) tst);
+}
+
+template <typename Data>
+void GetAt(uint& testnum, uint& testerr, lasd::LinearContainer<Data>& con, bool chk, const ulong& ind, const Data& val) {
+  bool tst;
+  testnum++;
+  try {
+    std::cout << " " << testnum << " Get of the linear container at index \"" << ind << "\" with value \"" << con[ind] << "\": ";
+    std::cout << ((tst = ((con[ind] == val) == chk)) ? "Correct" : "Error") << "!" << std::endl;
+  } catch(std::out_of_range exc) {
+    std::cout << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
+  } catch(std::exception exc) {
+    tst = true;
+    std::cout << std::endl << "Wrong std::exception: " << exc.what() << "!" << std::endl;
+  }
+  testerr += (1 - (uint) tst);
+}
+
+/* ************************************************************************** */
+
+// TestableContainer member functions!
+
+template <typename Data>
+void Exists(uint& testnum, uint& testerr, const lasd::TestableContainer<Data>& con, bool chk, const Data& val) {
+  bool tst;
+  testnum++;
+  std::cout << " " << testnum << " Data \"" << val << "\" " << ((tst = con.Exists(val)) ? "does" : "does not") << " exist: ";
+  std::cout << ((tst = (tst == chk)) ? "Correct" : "Error") << "!" << std::endl;
+  testerr += (1 - (uint) tst);
+}
+
+/* ************************************************************************** */
+
+// MappableContainer member functions!
+
+template <typename Data, typename Parameter>
+void MapPreOrder(uint& testnum, uint& testerr, lasd::MappableContainer<Data>& con, bool chk, typename lasd::MappableContainer<Data>::MapFunctor fun, const Parameter& inipar) {
+  bool tst = true;
+  testnum++;
+  Parameter par = {inipar};
+  try {
+    std::cout << " " << testnum << " Executing map in pre order - ";
+    con.MapPreOrder(fun, &par);
+    std::cout << ": " << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl;
+  } catch(std::exception exc) {
+    std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
+  }
+  testerr += (1 - (uint) tst);
+}
+
+template <typename Data, typename Parameter>
+void MapPostOrder(uint& testnum, uint& testerr, lasd::MappableContainer<Data>& con, bool chk, typename lasd::MappableContainer<Data>::MapFunctor fun, const Parameter& inipar) {
+  bool tst = true;
+  testnum++;
+  Parameter par = {inipar};
+  try {
+    std::cout << " " << testnum << " Executing map in post order - ";
+    con.MapPostOrder(fun, &par);
+    std::cout << ": " << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl;
+  } catch(std::exception exc) {
+    std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
+  }
+  testerr += (1 - (uint) tst);
+}
+
+template <typename Data>
+void MapPrint(const Data& dat, void* _) {
+  std::cout << dat << " ";
+}
+
+template <typename Data>
+void MapIncrement(Data& dat, void* _) {
+  dat++;
+}
+
+template <typename Data>
+void MapIncrementNPrint(Data& dat, void* _) {
+  std::cout << dat++ << "->" << dat << "; ";
+}
+
+template <typename Data>
+void MapDouble(Data& dat, void* _) {
+  dat *= 2;
+}
+
+template <typename Data>
+void MapDoubleNPrint(Data& dat, void* _) {
+  std::cout << dat << "->" << (dat *= 2) << "; ";
+}
+
+template <typename Data>
+void MapInvert(Data& dat, void* _) {
+  dat = -dat;
+}
+
+template <typename Data>
+void MapInvertNPrint(Data& dat, void* _) {
+  std::cout << dat << "->" << (dat = -dat) << "; ";
+}
+
+template <typename Data>
+void MapParityInvert(Data& dat, void* _) {
+  if (dat % 2 != 0) { dat = -dat; }
+}
+
+void MapStringAppend(std::string&, void*);
+
+/* ************************************************************************** */
+
+// FoldableContainer member functions!
+
+template <typename Data, typename Parameter, typename Value>
+void FoldPreOrder(uint& testnum, uint& testerr, const lasd::FoldableContainer<Data>& con, bool chk, typename lasd::FoldableContainer<Data>::FoldFunctor fun, const Parameter& inipar, const Value& inival, const Value& finval) {
+  bool tst;
+  testnum++;
+  Parameter par = {inipar};
+  Value val = inival;
+  try {
+    std::cout << " " << testnum << " Executing fold in pre order - ";
+    con.FoldPreOrder(fun, &par, &val);
+    std::cout << "obtained value is \"" << val << "\": ";
+    std::cout << ((tst = ((val == finval) == chk)) ? "Correct" : "Error") << "!" << std::endl;
+  } catch(std::exception exc) {
+    std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
+  }
+  testerr += (1 - (uint) tst);
+}
+
+template <typename Data, typename Parameter, typename Value>
+void FoldPostOrder(uint& testnum, uint& testerr, const lasd::FoldableContainer<Data>& con, bool chk, typename lasd::FoldableContainer<Data>::FoldFunctor fun, const Parameter& inipar, const Value& inival, const Value& finval) {
+  bool tst;
+  testnum++;
+  Parameter par = {inipar};
+  Value val = inival;
+  try {
+    std::cout << " " << testnum << " Executing fold in post order - ";
+    con.FoldPostOrder(fun, &par, &val);
+    std::cout << "obtained value is \"" << val << "\": ";
+    std::cout << ((tst = ((val == finval) == chk)) ? "Correct" : "Error") << "!" << std::endl;
+  } catch(std::exception exc) {
+    std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
+  }
+  testerr += (1 - (uint) tst);
+}
+
+template <typename Data>
+void FoldAdd(const Data& dat, const void* _, void* acc) {
+  *((Data*) acc) += dat;
+}
+
+template <typename Data>
+void FoldMultiply(const Data& dat, const void* _, void* acc) {
+  *((Data*) acc) *= dat;
+}
+
+void FoldParity(const int&, const void*, void*);
+
+void FoldStringConcatenate(const std::string&, const void*, void*);
+
+/* ************************************************************************** */
+
+// BreadthMappableContainer member functions!
+
+template <typename Data, typename Parameter>
+void MapBreadth(uint& testnum, uint& testerr, lasd::BreadthMappableContainer<Data>& con, bool chk, typename lasd::BreadthMappableContainer<Data>::MapFunctor fun, const Parameter& inipar) {
+  bool tst = true;
+  testnum++;
+  Parameter par = {inipar};
+  try {
+    std::cout << " " << testnum << " Executing map in pre order - ";
+    con.MapBreadth(fun, &par);
+    std::cout << ": " << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl;
+  } catch(std::exception exc) {
+    std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
+  }
+  testerr += (1 - (uint) tst);
+}
+
+/* ************************************************************************** */
+
+// BreadthFoldableContainer member functions!
+
+template <typename Data, typename Parameter, typename Value>
+void FoldBreadth(uint& testnum, uint& testerr, const lasd::BreadthFoldableContainer<Data>& con, bool chk, typename lasd::BreadthFoldableContainer<Data>::FoldFunctor fun, const Parameter& inipar, const Value& inival, const Value& finval) {
+  bool tst;
+  testnum++;
+  Parameter par = {inipar};
+  Value val = inival;
+  try {
+    std::cout << " " << testnum << " Executing fold in post order - ";
+    con.FoldBreadth(fun, &par, &val);
+    std::cout << "obtained value is \"" << val << "\": ";
+    std::cout << ((tst = ((val == finval) == chk)) ? "Correct" : "Error") << "!" << std::endl;
+  } catch(std::exception exc) {
+    std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
+  }
+  testerr += (1 - (uint) tst);
+}
+
+/* ************************************************************************** */
+
+#endif

librerie/exercise1/zlasdtest/exercise1/fulltest.cpp

@@ -0,0 +1,3 @@
+
+void testFullExercise1() {
+}

librerie/exercise1/zlasdtest/exercise1/simpletest.cpp

@@ -0,0 +1,447 @@
+
+#include <iostream>
+
+/* ************************************************************************** */
+
+#include "../container/container.hpp"
+
+#include "../vector/vector.hpp"
+
+#include "../list/list.hpp"
+
+/* ************************************************************************** */
+
+using namespace std;
+
+/* ************************************************************************** */
+
+void stestVectorInt(uint& testnum, uint& testerr) {
+  uint loctestnum = 0, loctesterr = 0;
+  cout << endl << "Begin of Vector<int> Test:" << endl;
+  try {
+    {
+      lasd::Vector<int> vec;
+      Empty(loctestnum, loctesterr, vec, true);
+
+      GetFront(loctestnum, loctesterr, vec, false, 0);
+      GetBack(loctestnum, loctesterr, vec, false, 0);
+      SetAt(loctestnum, loctesterr, vec, false, 1, 0);
+      GetAt(loctestnum, loctesterr, vec, false, 2, 0);
+
+      Exists(loctestnum, loctesterr, vec, false, 0);
+
+      MapPreOrder(loctestnum, loctesterr, vec, true, &MapPrint<int>, 0);
+      MapPostOrder(loctestnum, loctesterr, vec, true, &MapPrint<int>, 0);
+
+      FoldPreOrder(loctestnum, loctesterr, vec, true, &FoldAdd<int>, 0, 0, 0);
+      FoldPostOrder(loctestnum, loctesterr, vec, true, &FoldAdd<int>, 0, 0, 0);
+    }
+    {
+      lasd::Vector<int> vec(3);
+      Empty(loctestnum, loctesterr, vec, false);
+      Size(loctestnum, loctesterr, vec, true, 3);
+
+      SetAt(loctestnum, loctesterr, vec, true, 0, 4);
+      SetAt(loctestnum, loctesterr, vec, true, 1, 3);
+      SetAt(loctestnum, loctesterr, vec, true, 2, 1);
+
+      GetFront(loctestnum, loctesterr, vec, true, 4);
+      GetBack(loctestnum, loctesterr, vec, true, 1);
+
+      SetFront(loctestnum, loctesterr, vec, true, 5);
+      SetBack(loctestnum, loctesterr, vec, true, 4);
+
+      Exists(loctestnum, loctesterr, vec, true, 4);
+
+      MapPreOrder(loctestnum, loctesterr, vec, true, &MapPrint<int>, 0);
+      MapPostOrder(loctestnum, loctesterr, vec, true, &MapPrint<int>, 0);
+      FoldPreOrder(loctestnum, loctesterr, vec, true, &FoldAdd<int>, 0, 0, 12);
+      FoldPostOrder(loctestnum, loctesterr, vec, true, &FoldMultiply<int>, 0, 1, 60);
+
+      vec.Resize(2);
+      FoldPostOrder(loctestnum, loctesterr, vec, true, &FoldMultiply<int>, 0, 1, 15);
+    }
+  } catch(...) {
+    loctestnum++; loctesterr++;
+    cout << endl << "Unmanaged error! " << endl;
+  }
+  cout << "End of Vector<int> Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl;
+  testnum += loctestnum;
+  testerr += loctesterr;
+}
+
+void stestVectorDouble(uint& testnum, uint& testerr) {
+  uint loctestnum = 0, loctesterr = 0;
+  cout << endl << "Begin of Vector<double> Test:" << endl;
+  try {
+    lasd::Vector<double> vec(3);
+    Empty(loctestnum, loctesterr, vec, false);
+    Size(loctestnum, loctesterr, vec, true, 3);
+
+    SetAt(loctestnum, loctesterr, vec, true, 0, 5.5);
+    SetAt(loctestnum, loctesterr, vec, true, 1, 3.3);
+    SetAt(loctestnum, loctesterr, vec, true, 2, 1.1);
+
+    GetFront(loctestnum, loctesterr, vec, true, 5.5);
+    GetBack(loctestnum, loctesterr, vec, true, 1.1);
+
+    Exists(loctestnum, loctesterr, vec, true, 3.3);
+
+    FoldPreOrder(loctestnum, loctesterr, vec, true, &FoldAdd<double>, 0.0, 0.0, 9.9);
+    FoldPostOrder(loctestnum, loctesterr, vec, true, &FoldMultiply<double>, 0.0, 1.0, 19.965);
+  } catch(...) {
+    loctestnum++; loctesterr++;
+    cout << endl << "Unmanaged error! " << endl;
+  }
+  cout << "End of Vector<double> Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl;
+  testnum += loctestnum;
+  testerr += loctesterr;
+}
+
+void stestVectorString(uint& testnum, uint& testerr) {
+  uint loctestnum = 0, loctesterr = 0;
+  cout << endl << "Begin of Vector<string> Test:" << endl;
+  try {
+    lasd::Vector<string> vec(2);
+    Empty(loctestnum, loctesterr, vec, false);
+    Size(loctestnum, loctesterr, vec, true, 2);
+
+    SetAt(loctestnum, loctesterr, vec, true, 0, string("A"));
+    SetAt(loctestnum, loctesterr, vec, true, 1, string("B"));
+
+    GetFront(loctestnum, loctesterr, vec, true, string("A"));
+    GetBack(loctestnum, loctesterr, vec, true, string("B"));
+
+    Exists(loctestnum, loctesterr, vec, true, string("A"));
+
+    MapPreOrder(loctestnum, loctesterr, vec, true, &MapStringAppend, string(" "));
+    MapPreOrder(loctestnum, loctesterr, vec, true, &MapPrint<string>, 0);
+    FoldPreOrder(loctestnum, loctesterr, vec, true, &FoldStringConcatenate, string(""), string("X"), string("XA B "));
+    FoldPostOrder(loctestnum, loctesterr, vec, true, &FoldStringConcatenate, string(""), string("X"), string("XB A "));
+
+    Exists(loctestnum, loctesterr, vec, false, string("A"));
+
+    lasd::Vector<string> copvec(vec);
+    EqualVector(loctestnum, loctesterr, vec, copvec, true);
+    MapPreOrder(loctestnum, loctesterr, vec, true, &MapStringAppend, string("!"));
+    NonEqualVector(loctestnum, loctesterr, vec, copvec, true);
+
+    copvec = std::move(vec);
+    FoldPreOrder(loctestnum, loctesterr, copvec, true, &FoldStringConcatenate, string(""), string("?"), string("?A !B !"));
+
+    lasd::Vector<string> movvec(std::move(vec));
+    FoldPreOrder(loctestnum, loctesterr, movvec, true, &FoldStringConcatenate, string(""), string("?"), string("?A B "));
+    SetAt(loctestnum, loctesterr, vec, false, 1, string(""));
+    vec.Resize(1);
+    SetAt(loctestnum, loctesterr, vec, true, 0, string("X"));
+
+    movvec.Clear();
+    Empty(loctestnum, loctesterr, movvec, true);
+  } catch(...) {
+    loctestnum++; loctesterr++;
+    cout << endl << "Unmanaged error! " << endl;
+  }
+  cout << "End of Vector<string> Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl;
+  testnum += loctestnum;
+  testerr += loctesterr;
+}
+
+void stestVector(uint& testnum, uint& testerr) {
+  uint loctestnum = 0, loctesterr = 0;
+  stestVectorInt(loctestnum, loctesterr);
+  stestVectorDouble(loctestnum, loctesterr);
+  stestVectorString(loctestnum, loctesterr);
+  testnum += loctestnum;
+  testerr += loctesterr;
+  cout << endl << "Exercise 1 - Vector (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl;
+}
+
+/* ************************************************************************** */
+
+void stestListInt(uint& testnum, uint& testerr) {
+  uint loctestnum = 0, loctesterr = 0;
+  cout << endl << "Begin of List<int> Test:" << endl;
+  try {
+    lasd::List<int> lst;
+    Empty(loctestnum, loctesterr, lst, true);
+    Size(loctestnum, loctesterr, lst, true, 0);
+
+    GetFront(loctestnum, loctesterr, lst, false, 0);
+    GetBack(loctestnum, loctesterr, lst, false, 0);
+
+    Exists(loctestnum, loctesterr, lst, false, 0);
+
+    MapPreOrder(loctestnum, loctesterr, lst, true, &MapPrint<int>, 0);
+    MapPostOrder(loctestnum, loctesterr, lst, true, &MapPrint<int>, 0);
+    FoldPreOrder(loctestnum, loctesterr, lst, true, &FoldAdd<int>, 0, 0, 0);
+    FoldPostOrder(loctestnum, loctesterr, lst, true, &FoldAdd<int>, 0, 0, 0);
+
+    RemoveFromFront(loctestnum, loctesterr, lst, false);
+    FrontNRemove(loctestnum, loctesterr, lst, false, 0);
+
+    InsertAtBack(loctestnum, loctesterr, lst, true, 4);
+    InsertAtFront(loctestnum, loctesterr, lst, true, 5);
+    InsertAtFront(loctestnum, loctesterr, lst, true, 9);
+    InsertAtBack(loctestnum, loctesterr, lst, true, 2);
+    InsertAtFront(loctestnum, loctesterr, lst, true, 1);
+
+    GetFront(loctestnum, loctesterr, lst, true, 1);
+    GetBack(loctestnum, loctesterr, lst, true, 2);
+    SetFront(loctestnum, loctesterr, lst, true, 2);
+    SetBack(loctestnum, loctesterr, lst, true, 6);
+
+    GetAt(loctestnum, loctesterr, lst, true, 3, 4);
+    SetAt(loctestnum, loctesterr, lst, true, 3, 3);
+
+    Exists(loctestnum, loctesterr, lst, false, 4);
+
+    MapPreOrder(loctestnum, loctesterr, lst, true, &MapPrint<int>, 0);
+    MapPostOrder(loctestnum, loctesterr, lst, true, &MapPrint<int>, 0);
+    FoldPreOrder(loctestnum, loctesterr, lst, true, &FoldAdd<int>, 0, 0, 25);
+    FoldPostOrder(loctestnum, loctesterr, lst, true, &FoldMultiply<int>, 0, 1, 1620);
+
+    RemoveFromFront(loctestnum, loctesterr, lst, true);
+    FrontNRemove(loctestnum, loctesterr, lst, true, 9);
+    FoldPostOrder(loctestnum, loctesterr, lst, true, &FoldMultiply<int>, 0, 1, 90);
+
+    lasd::List<int> coplst(lst);
+    EqualList(loctestnum, loctesterr, lst, coplst, true);
+    MapPreOrder(loctestnum, loctesterr, lst, true, &MapIncrement<int>, 0);
+    NonEqualList(loctestnum, loctesterr, lst, coplst, true);
+
+    InsertAtFront(loctestnum, loctesterr, lst, true, 0);
+    InsertAtBack(loctestnum, loctesterr, lst, true, 0);
+    NonEqualList(loctestnum, loctesterr, lst, coplst, true);
+    coplst = lst;
+    EqualList(loctestnum, loctesterr, lst, coplst, true);
+
+    RemoveFromFront(loctestnum, loctesterr, coplst, true);
+    FrontNRemove(loctestnum, loctesterr, coplst, true, 6);
+    coplst = std::move(lst);
+    FoldPreOrder(loctestnum, loctesterr, lst, true, &FoldAdd<int>, 0, 0, 11);
+    FoldPreOrder(loctestnum, loctesterr, coplst, true, &FoldAdd<int>, 0, 0, 17);
+
+    lasd::List<int> movlst(std::move(lst));
+    MapPreOrder(loctestnum, loctesterr, movlst, true, &MapIncrement<int>, 0);
+    FoldPreOrder(loctestnum, loctesterr, movlst, true, &FoldAdd<int>, 0, 0, 14);
+
+    movlst.Clear();
+    Empty(loctestnum, loctesterr, movlst, true);
+    Size(loctestnum, loctesterr, movlst, true, 0);
+  } catch(...) {
+    loctestnum++; loctesterr++;
+    cout << endl << "Unmanaged error! " << endl;
+  }
+  cout << "End of List<int> Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl;
+  testnum += loctestnum;
+  testerr += loctesterr;
+}
+
+void stestListDouble(uint& testnum, uint& testerr) {
+  uint loctestnum = 0, loctesterr = 0;
+  cout << endl << "Begin of List<double> Test:" << endl;
+  try {
+    lasd::List<double> lst;
+    Empty(loctestnum, loctesterr, lst, true);
+    Size(loctestnum, loctesterr, lst, true, 0);
+
+    InsertAtBack(loctestnum, loctesterr, lst, true, -2.5);
+    InsertAtBack(loctestnum, loctesterr, lst, true, 2.5);
+
+    lst.Clear();
+
+    InsertAtBack(loctestnum, loctesterr, lst, true, 0.5);
+    InsertAtFront(loctestnum, loctesterr, lst, true, 3.3);
+    InsertAtFront(loctestnum, loctesterr, lst, true, 5.5);
+    InsertAtBack(loctestnum, loctesterr, lst, true, 1.1);
+
+    GetFront(loctestnum, loctesterr, lst, true, 5.5);
+    GetBack(loctestnum, loctesterr, lst, true, 1.1);
+
+    Exists(loctestnum, loctesterr, lst, false, 0.0);
+
+    MapPreOrder(loctestnum, loctesterr, lst, true, &MapPrint<double>, 0);
+    MapPostOrder(loctestnum, loctesterr, lst, true, &MapPrint<double>, 0);
+    FoldPreOrder(loctestnum, loctesterr, lst, true, &FoldAdd<double>, 0.0, 0.0, 10.4);
+    FoldPostOrder(loctestnum, loctesterr, lst, true, &FoldMultiply<double>, 0.0, 1.0, 9.9825);
+  } catch(...) {
+    loctestnum++; loctesterr++;
+    cout << endl << "Unmanaged error! " << endl;
+  }
+  cout << "End of List<double> Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl;
+  testnum += loctestnum;
+  testerr += loctesterr;
+}
+
+void stestListString(uint& testnum, uint& testerr) {
+  uint loctestnum = 0, loctesterr = 0;
+  cout << endl << "Begin of List<string> Test:" << endl;
+  try {
+    lasd::List<string> lst;
+    Empty(loctestnum, loctesterr, lst, true);
+    Size(loctestnum, loctesterr, lst, true, 0);
+
+    InsertAtFront(loctestnum, loctesterr, lst, true, string("A"));
+    InsertAtBack(loctestnum, loctesterr, lst, true, string("B"));
+
+    GetFront(loctestnum, loctesterr, lst, true, string("A"));
+    GetBack(loctestnum, loctesterr, lst, true, string("B"));
+
+    Exists(loctestnum, loctesterr, lst, true, string("B"));
+
+    MapPreOrder(loctestnum, loctesterr, lst, true, &MapStringAppend, string(" "));
+    MapPreOrder(loctestnum, loctesterr, lst, true, &MapPrint<string>, 0);
+    FoldPreOrder(loctestnum, loctesterr, lst, true, &FoldStringConcatenate, string(""), string("X"), string("XA B "));
+    FoldPostOrder(loctestnum, loctesterr, lst, true, &FoldStringConcatenate, string(""), string("X"), string("XB A "));
+
+    Exists(loctestnum, loctesterr, lst, false, string("B"));
+
+    lasd::List<string> coplst(lst);
+    EqualList(loctestnum, loctesterr, lst, coplst, true);
+    RemoveFromFront(loctestnum, loctesterr, coplst, true);
+    NonEqualList(loctestnum, loctesterr, lst, coplst, true);
+
+    lst = coplst;
+    EqualList(loctestnum, loctesterr, lst, coplst, true);
+    InsertAtBack(loctestnum, loctesterr, lst, true, string("A"));
+    InsertAtFront(loctestnum, loctesterr, lst, true, string("C"));
+    NonEqualList(loctestnum, loctesterr, lst, coplst, true);
+
+    coplst = std::move(lst);
+    FoldPreOrder(loctestnum, loctesterr, coplst, true, &FoldStringConcatenate, string(""), string("?"), string("?CB A"));
+  } catch(...) {
+    loctestnum++; loctesterr++;
+    cout << endl << "Unmanaged error! " << endl;
+  }
+  cout << "End of List<string> Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl;
+  testnum += loctestnum;
+  testerr += loctesterr;
+}
+
+void stestList(uint& testnum, uint& testerr) {
+  uint loctestnum = 0, loctesterr = 0;
+  stestListInt(loctestnum, loctesterr);
+  stestListDouble(loctestnum, loctesterr);
+  stestListString(loctestnum, loctesterr);
+  testnum += loctestnum;
+  testerr += loctesterr;
+  cout << endl << "Exercise 1 - List (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl;
+}
+
+/* ************************************************************************** */
+
+void stestVectorListInt(uint& testnum, uint& testerr) {
+  uint loctestnum = 0, loctesterr = 0;
+  cout << endl << "Begin of Vector/List<int> Test:" << endl;
+  try {
+    lasd::Vector<int> vec(3);
+    SetAt(loctestnum, loctesterr, vec, true, 0, -1);
+    SetAt(loctestnum, loctesterr, vec, true, 1, 0);
+    SetAt(loctestnum, loctesterr, vec, true, 2, 1);
+
+    lasd::List<int> lst;
+    InsertAtFront(loctestnum, loctesterr, lst, true, 1);
+    InsertAtFront(loctestnum, loctesterr, lst, true, 0);
+    InsertAtFront(loctestnum, loctesterr, lst, true, -1);
+
+    lasd::Vector<int> copvec(lst);
+    EqualVector(loctestnum, loctesterr, vec, copvec, true);
+    lasd::Vector<int> copvecx(vec);
+    EqualVector(loctestnum, loctesterr, copvecx, copvec, true);
+
+    lasd::List<int> coplst(vec);
+    EqualList(loctestnum, loctesterr, lst, coplst, true);
+    lasd::List<int> coplstx(lst);
+    EqualList(loctestnum, loctesterr, coplstx, coplst, true);
+  } catch(...) {
+    loctestnum++; loctesterr++;
+    cout << endl << "Unmanaged error! " << endl;
+  }
+  cout << "End of Vector/List<int> Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl;
+  testnum += loctestnum;
+  testerr += loctesterr;
+}
+
+void stestVectorListDouble(uint& testnum, uint& testerr) {
+  uint loctestnum = 0, loctesterr = 0;
+  cout << endl << "Begin of Vector/List<double> Test:" << endl;
+  try {
+    lasd::Vector<double> vec(3);
+    SetAt(loctestnum, loctesterr, vec, true, 0, -0.5);
+    SetAt(loctestnum, loctesterr, vec, true, 1, 0.0);
+    SetAt(loctestnum, loctesterr, vec, true, 2, 0.5);
+
+    lasd::List<double> lst;
+    InsertAtBack(loctestnum, loctesterr, lst, true, -0.5);
+    InsertAtBack(loctestnum, loctesterr, lst, true, 0.0);
+    InsertAtBack(loctestnum, loctesterr, lst, true, 0.5);
+
+    lasd::Vector<double> copvec(lst);
+    EqualVector(loctestnum, loctesterr, vec, copvec, true);
+    lasd::Vector<double> copvecx(vec);
+    EqualVector(loctestnum, loctesterr, copvecx, copvec, true);
+
+    lasd::List<double> coplst(vec);
+    EqualList(loctestnum, loctesterr, lst, coplst, true);
+    lasd::List<double> coplstx(lst);
+    EqualList(loctestnum, loctesterr, coplstx, coplst, true);
+  } catch(...) {
+    loctestnum++; loctesterr++;
+    cout << endl << "Unmanaged error! " << endl;
+  }
+  cout << "End of Vector/List<double> Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl;
+  testnum += loctestnum;
+  testerr += loctesterr;
+}
+
+void stestVectorListString(uint& testnum, uint& testerr) {
+  uint loctestnum = 0, loctesterr = 0;
+  cout << endl << "Begin of Vector/List<string> Test:" << endl;
+  try {
+    lasd::Vector<string> vec(3);
+    SetAt(loctestnum, loctesterr, vec, true, 0, string("A"));
+    SetAt(loctestnum, loctesterr, vec, true, 1, string("B"));
+    SetAt(loctestnum, loctesterr, vec, true, 2, string("C"));
+
+    lasd::List<string> lst;
+    InsertAtFront(loctestnum, loctesterr, lst, true, string("B"));
+    InsertAtBack(loctestnum, loctesterr, lst, true, string("C"));
+    InsertAtFront(loctestnum, loctesterr, lst, true, string("A"));
+
+    lasd::Vector<string> copvec(lst);
+    EqualVector(loctestnum, loctesterr, vec, copvec, true);
+    lasd::Vector<string> copvecx(vec);
+    EqualVector(loctestnum, loctesterr, copvecx, copvec, true);
+
+    lasd::List<string> coplst(vec);
+    EqualList(loctestnum, loctesterr, lst, coplst, true);
+    lasd::List<string> coplstx(lst);
+    EqualList(loctestnum, loctesterr, coplstx, coplst, true);
+  } catch(...) {
+    loctestnum++; loctesterr++;
+    cout << endl << "Unmanaged error! " << endl;
+  }
+  cout << "End of Vector/List<string> Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl;
+  testnum += loctestnum;
+  testerr += loctesterr;
+}
+
+void stestVectorList(uint& testnum, uint& testerr) {
+  uint loctestnum = 0, loctesterr = 0;
+  stestVectorListInt(loctestnum, loctesterr);
+  stestVectorListDouble(loctestnum, loctesterr);
+  stestVectorListString(loctestnum, loctesterr);
+  testnum += loctestnum;
+  testerr += loctesterr;
+  cout << endl << "Exercise 1 - Vector/List (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl;
+}
+
+/* ************************************************************************** */
+
+void testSimpleExercise1() {
+  uint testnum = 0, testerr = 0;
+  stestVector(testnum, testerr);
+  stestList(testnum, testerr);
+  stestVectorList(testnum, testerr);
+  cout << endl << "Exercise 1 (Simple Test) (Errors/Tests: " << testerr << "/" << testnum << ")" << endl;
+}

librerie/exercise1/zlasdtest/exercise1/test.hpp

@@ -0,0 +1,13 @@
+
+#ifndef EX1TEST_HPP
+#define EX1TEST_HPP
+
+/* ************************************************************************** */
+
+void testSimpleExercise1();
+
+void testFullExercise1();
+
+/* ************************************************************************** */
+
+#endif

librerie/exercise1/zlasdtest/list/list.hpp

@@ -0,0 +1,92 @@
+
+#ifndef LISTTEST_HPP
+#define LISTTEST_HPP
+
+#include "../../list/list.hpp"
+
+/* ************************************************************************** */
+
+template <typename Data>
+void InsertAtFront(uint& testnum, uint& testerr, lasd::List<Data>& lst, bool chk, const Data& val) {
+  bool tst;
+  testnum++;
+  try {
+    std::cout << " " << testnum << " Insert at the front of the list the value \"" << val << "\": ";
+    lst.InsertAtFront(val);
+    std::cout << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl;
+  } catch(std::exception exc) {
+    std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
+  }
+  testerr += (1 - (uint) tst);
+}
+
+template <typename Data>
+void RemoveFromFront(uint& testnum, uint& testerr, lasd::List<Data>& lst, bool chk) {
+  bool tst;
+  testnum++;
+  try {
+    std::cout << " " << testnum << " Remove from the list of \"" << lst.Front() << "\": ";
+    lst.RemoveFromFront();
+    std::cout << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl;
+  } catch(std::length_error exc) {
+    std::cout << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
+  }
+  testerr += (1 - (uint) tst);
+}
+
+template <typename Data>
+void FrontNRemove(uint& testnum, uint& testerr, lasd::List<Data>& lst, bool chk, const Data& val) {
+  bool tst;
+  testnum++;
+  try {
+    std::cout << " " << testnum << " FrontNRemove from the list of \"" << lst.Front() << "\": ";
+    std::cout << ((tst = ((lst.FrontNRemove() == val) == chk)) ? "Correct" : "Error") << "!" << std::endl;
+  } catch(std::length_error exc) {
+    std::cout << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
+  }
+  testerr += (1 - (uint) tst);
+}
+
+template <typename Data>
+void InsertAtBack(uint& testnum, uint& testerr, lasd::List<Data>& lst, bool chk, const Data& val) {
+  bool tst;
+  testnum++;
+  try {
+    std::cout << " " << testnum << " Insert at the back of the list the value \"" << val << "\": ";
+    lst.InsertAtBack(val);
+    std::cout << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl;
+  } catch(std::exception exc) {
+    std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
+  }
+  testerr += (1 - (uint) tst);
+}
+
+template <typename Data>
+void EqualList(uint& testnum, uint& testerr, const lasd::List<Data>& lst1, const lasd::List<Data>& lst2, bool chk) {
+  bool tst;
+  testnum++;
+  try {
+    std::cout << " " << testnum << " The two lists are " << ((tst = (lst1 == lst2)) ? "" : "not ") << "equal: ";
+    std::cout << ((tst = (tst == chk)) ? "Correct" : "Error") << "!" << std::endl;
+  } catch(std::exception exc) {
+    std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
+  }
+  testerr += (1 - (uint) tst);
+}
+
+template <typename Data>
+void NonEqualList(uint& testnum, uint& testerr, const lasd::List<Data>& lst1, const lasd::List<Data>& lst2, bool chk) {
+  bool tst;
+  testnum++;
+  try {
+    std::cout << " " << testnum << " The two lists are " << ((tst = (lst1 != lst2)) ? "not " : "") << "equal: ";
+    std::cout << ((tst = (tst == chk)) ? "Correct" : "Error") << "!" << std::endl;
+  } catch(std::exception exc) {
+    std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
+  }
+  testerr += (1 - (uint) tst);
+}
+
+/* ************************************************************************** */
+
+#endif

librerie/exercise1/zlasdtest/test.cpp

@@ -0,0 +1,17 @@
+
+#include "./exercise1/test.hpp"
+
+/* ************************************************************************** */
+
+#include <iostream>
+
+using namespace std;
+
+/* ************************************************************************** */
+
+void lasdtest() {
+  cout << endl << "~*~#~*~ Welcome to the LASD Test Suite ~*~#~*~ " << endl;
+  testSimpleExercise1();
+  testFullExercise1();
+  cout << endl << "Goodbye!" << endl;
+}

librerie/exercise1/zlasdtest/test.hpp

@@ -0,0 +1,11 @@
+
+#ifndef LASDTEST_HPP
+#define LASDTEST_HPP
+
+/* ************************************************************************** */
+
+void lasdtest();
+
+/* ************************************************************************** */
+
+#endif

librerie/exercise1/zlasdtest/vector/vector.hpp

@@ -0,0 +1,37 @@
+
+#ifndef VECTORTEST_HPP
+#define VECTORTEST_HPP
+
+#include "../../vector/vector.hpp"
+
+/* ************************************************************************** */
+
+template <typename Data>
+void EqualVector(uint& testnum, uint& testerr, const lasd::Vector<Data>& vec1, const lasd::Vector<Data>& vec2, bool chk) {
+  bool tst;
+  testnum++;
+  try {
+    std::cout << " " << testnum << " The two vectors are " << ((tst = (vec1 == vec2)) ? "" : "not ") << "equal: ";
+    std::cout << ((tst = (tst == chk)) ? "Correct" : "Error") << "!" << std::endl;
+  } catch(std::exception exc) {
+    std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
+  }
+  testerr += (1 - (uint) tst);
+}
+
+template <typename Data>
+void NonEqualVector(uint& testnum, uint& testerr, const lasd::Vector<Data>& vec1, const lasd::Vector<Data>& vec2, bool chk) {
+  bool tst;
+  testnum++;
+  try {
+    std::cout << " " << testnum << " The two vectors are " << ((tst = (vec1 != vec2)) ? "not " : "") << "equal: ";
+    std::cout << ((tst = (tst == chk)) ? "Correct" : "Error") << "!" << std::endl;
+  } catch(std::exception exc) {
+    std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl;
+  }
+  testerr += (1 - (uint) tst);
+}
+
+/* ************************************************************************** */
+
+#endif

librerie/exercise1/zmytest/test.cpp

@@ -0,0 +1,2 @@
+
+// ...

librerie/exercise1/zmytest/test.hpp

@@ -0,0 +1,11 @@
+
+#ifndef MYTEST_HPP
+#define MYTEST_HPP
+
+/* ************************************************************************** */
+
+// ...
+
+/* ************************************************************************** */
+
+#endif

teoria/esempi_professore/examples/templates/main.cpp

@@ -3,11 +3,11 @@
 
 using namespace std;
 
-// template <typename Data>
-// class A;
-//
-// template <typename Data>
-// ostream& operator<< (ostream& outstr, const A<Data>& a);
+ template <typename Data>
+ class A;
+
+ template <typename Data>
+ ostream& operator<< (ostream& outstr, const A<Data>& a);
 
 template <typename Data>
 class A {
@@ -53,10 +53,10 @@ public:
     return false;
   }
 
-  template <typename DataX>
-  friend ostream& operator<<(ostream&, const A<DataX>&);
+  //template <typename DataX>
+  //friend ostream& operator<<(ostream&, const A<DataX>&);
 
-  // friend ostream& operator<< <>(ostream&, const A<Data>&);
+   friend ostream& operator<< <>(ostream&, const A<Data>&);
 
 };
 

teoria/template_multiple_file/main.cpp

@@ -0,0 +1,7 @@
+#include"vector.hpp"
+int main(){
+  Vector<int> v(5);
+  //v[1] = 3;
+  cout<<v<<endl;
+  return 0;
+}

teoria/template_multiple_file/vector.cpp

@@ -0,0 +1,22 @@
+template <typename Pippo>
+Vector<Pippo>::Vector(uint size1){
+  ptr = new Pippo[size1]();
+  size = size1;
+  cout << "A new object is created" << endl;
+}
+
+template <typename Pippo>
+Vector<Pippo>::~Vector(){
+  delete[] ptr;
+}
+
+// template <typename Pippo>
+// Vector<Pippo>::Pippo& operator[](const uint idx) {
+//   return ptr[idx];
+// }
+
+template <typename Pippo>
+ostream& operator<< (ostream& outstr, const Vector<Pippo>& a) {
+  for(int i=0;i<a.size;i++) outstr<<a.ptr[i];
+  return outstr;
+}

teoria/template_multiple_file/vector.hpp

@@ -0,0 +1,21 @@
+#include <iostream>
+using namespace std;
+
+ template <typename Pippo>
+ class Vector;
+
+ template <typename Pippo>
+ ostream& operator<< (ostream& outstr, const Vector<Pippo>& a);
+
+template <typename Pippo> // Lo chiamo Pippo per far capire che il nome è irrilevante
+class Vector{
+public:
+  Pippo* ptr = nullptr;
+  uint size;
+
+  Vector(uint);
+  ~Vector();
+
+  friend ostream& operator<< <>(ostream& outstr, const Vector<Pippo>&);
+};
+#include"vector.cpp"

teoria/template_single_file.cpp

@@ -0,0 +1,88 @@
+#include <iostream>
+using namespace std;
+
+ template <typename Pippo>
+ class A;
+
+ template <typename Pippo>
+ ostream& operator<< (ostream& outstr, const A<Pippo>& a);
+
+template <typename Pippo> // Lo chiamo Pippo per far capire che il nome è irrilevante
+class A{
+public:
+  Pippo* ptr = nullptr;
+  uint size;
+  A(uint size1){
+    ptr = new Pippo[size1]();
+    size = size1;
+    cout << "A new object is created" << endl;
+  }
+  ~A(){
+    delete[] ptr;
+  }
+  Pippo& operator[](const uint idx) {
+    return ptr[idx];
+  }
+
+  friend ostream& operator<< <>(ostream& outstr, const A<Pippo>&);
+
+/*
+  template <typename DataX>
+  friend ostream& operator<<(ostream&, const A<DataX>&);
+*/
+};
+
+template <typename Pippo>
+ostream& operator<< (ostream& outstr, const A<Pippo>& a) {
+  for(int i=0;i<a.size;i++) outstr<<a.ptr[i];
+  return outstr;
+}
+
+/*
+template <typename DataX>
+ostream& operator<< (ostream& outstr, const A<DataX>& a) {
+  for(int i=0;i<a.size;i++) outstr<<a.ptr[i];
+  return outstr;
+}
+*/
+
+int main(){
+  A<char> str(50);
+  A<int> v(10);
+
+  str[1] = 'k';
+  v[2] = 3;
+
+  cout<<str[1]<<endl;
+  cout<<v[2]<<endl;
+  cout<<v;
+  return 0;
+}
+
+/*
+  NB: per fare l'override della funzione operator<< (e equiv. di operator>>)
+      ci sono due metodi:
+
+      1.  Usare quello che non è commentato, ovvero questo programma. (consigliato)
+
+      2.
+        a.  Cancellare/commentare righe 4-8
+
+            4 template <typename Pippo>
+            5 class A;
+
+            7 template <typename Pippo>
+            8 ostream& operator<< (ostream& outstr, const A<Pippo>& a);
+
+        b.  Cancallare/commentare 35-39
+
+            35 template <typename Pippo>
+            36 ostream& operator<< (ostream& outstr, const A<Pippo>& a) {
+            37 for(int i=0;i<a.size;i++) outstr<<a.ptr[i];
+            38 return outstr;
+            39 }
+
+       c.   e decommentare ciò che è commentato.
+
+       Perché? Non lo so.
+*/