Library 3

container & iterator.hpp

librerie/exercise3/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/exercise3/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;
-  // type operator!=(argument) specifiers;
+  bool operator==(const StackVec&) const noexcept;
+  bool operator!=(const StackVec&) const noexcept;
 
   /* ************************************************************************ */
 
   // Specific member functions (inherited from Stack)
 
-  // type Push(argument) specifiers; // Override Stack member (copy of the value)
-  // type Push(argument) specifiers; // Override Stack member (move of the value)
-  // type Top() specifiers; // Override Stack member (must throw std::length_error when empty)
-  // type Pop() specifiers; // Override Stack member (must throw std::length_error when empty)
-  // type TopNPop() specifiers; // Override Stack member (must throw std::length_error when empty)
+  void Push(const Data&) override; // Override Stack member (copy of the value)
+  void Push(Data&&) override; // Override Stack member (move of the value)
+  Data& Top() const override; // Override Stack member (must throw std::length_error when empty)
+  void Pop() override; // 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;
-  // type Reduce() specifiers;
+  void Expand();
+  void Reduce();
 
 };