Library 2

librerie/exercise2/stack/lst/stacklst.cpp

@@ -5,8 +5,8 @@ namespace lasd {
 
 // Constructors
 template <typename Data>
-StackLst(const LinearContainer<Data>& linear){
-  for(ulong i=linear.Size()-1 ; i>=0 ; --i){ // è possibile usare il costruttore di List?
+StackLst<Data>::StackLst(const LinearContainer<Data>& linear){
+  for(long int i=(long int)linear.Size()-1 ; i>=0 ; --i){ // è possibile usare il costruttore di List?
     Push(linear[i]);
   }
 }
@@ -17,9 +17,9 @@ StackLst(const LinearContainer<Data>& linear) : List<Data>(linear){
 return;
 }
 */
-
-StackLst(const StackLst& stcklist){
-  for(ulong i=stcklist.Size()-1 ; i>=0 ; --i){
+template <typename Data>
+StackLst<Data>::StackLst(const StackLst& stcklist){
+for(long int i=(long int)stcklist.Size()-1 ; i>=0 ; i--){
     Push(stcklist[i]);
   }
 }
@@ -35,62 +35,67 @@ StackLst<Data>::StackLst(StackLst&& stcklist) noexcept{
 }
 
 // Destructor
-virtual ~StackLst(){
+template <typename Data>
+StackLst<Data>::~StackLst(){
   Clear();
 }
 
-StackLst& operator=(const StackLst& copyFrom){
+template <typename Data>
+StackLst<Data>& StackLst<Data>::operator=(const StackLst& copyFrom){
   if(*this != copyFrom){
     Clear();
-    for(ulong i=copyFrom.Size()-1 ; i>=0 ; --i){
+    for(long int i=(long int)copyFrom.Size()-1 ; i>=0 ; --i){
       Push(copyFrom[i]);
     }
   }
   return *this;
 }
 
-StackLst& operator=(StackLst&& moveFrom){
+template <typename Data>
+StackLst<Data>& StackLst<Data>::operator=(StackLst&& moveFrom) noexcept{
   std::swap(size, moveFrom.size);
   std::swap(head, moveFrom.head);
   return *this;
 }
 
-bool operator==(const StackLst& stcklist) const noexcept{
+template <typename Data>
+bool StackLst<Data>::operator==(const StackLst& stcklist) const noexcept{
   return List<Data>::operator==(stcklist);
 }
 
-bool operator!=(const StackLst& stcklist) const noexcept{
+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 Push(const Data& element){
+void StackLst<Data>::Push(const Data& element){
   List<Data>::InsertAtFront(element);
 }
 
 template <typename Data>
-void Push(Data&& element){
+void StackLst<Data>::Push(Data&& element) noexcept{
   List<Data>::InsertAtFront(element);
 }
 
 template <typename Data>
-Data& Top() const{
+Data& StackLst<Data>::Top() const{
   return List<Data>::Front();
 }
 
 template <typename Data>
-void Pop(){
+void StackLst<Data>::Pop(){
   List<Data>::RemoveFromFront();
 }
 
 template <typename Data>
-Data TopNPop(){
+Data StackLst<Data>::TopNPop(){
   return List<Data>::FrontNRemove();
 }
 
 template <typename Data>
-void Clear(){
+void StackLst<Data>::Clear(){
   List<Data>::Clear();
 }
 

librerie/exercise2/stack/vec/stackvec.cpp

@@ -6,6 +6,7 @@ namespace lasd {
 template <typename Data>
 StackVec<Data>::StackVec(){
   size = 4; // default vector is instantiated with 4 cells
+  stackSize = 0;
   Elements = new Data[size];
 }
 
@@ -21,12 +22,12 @@ StackVec<Data>::StackVec(const LinearContainer<Data>& linear){ // si può richia
 
 template <typename Data>
 StackVec<Data>::StackVec(const StackVec& stckvec){// si può richiamare il costruttore della classe Vector
-  Elements = new Data[stckvec.Size()]; // espandere di un po' forse
-  for(ulong i=0 ; i<stckvec.Size() ; ++i){
+  Elements = new Data[stckvec.size]; // espandere di un po' forse
+  for(ulong i=0 ; i<stckvec.size ; ++i){
     Elements[i] = stckvec[i];
   }
-  size = stckvec.Size();
-  stackSize = stckvec.stackSize;
+  size = stckvec.size;
+  stackSize = stckvec.Size();
 }
 /*
 StackVec(const StackVec& stckvec) : Vector<Data>(copyFrom)
@@ -39,32 +40,42 @@ StackVec<Data>::StackVec(StackVec&& toMove) noexcept{
   std::swap(stackSize, toMove.stackSize);
 }
 
+template <typename Data>
 StackVec<Data>::~StackVec(){
   // Vector destructor will be called automatically
   // (TEST IT)
 }
 
 template <typename Data>
-StackVec& StackVec<Data>::operator=(const StackVec& copyFrom){
+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& StackVec<Data>::operator=(StackVec&& moveFrom) noexcept{
+StackVec<Data>& StackVec<Data>::operator=(StackVec<Data>&& moveFrom) noexcept{
   Vector<Data>::operator=(std::move(moveFrom)); // espandere di un po' forse
-  stackSize = copyFrom.Size();
+  stackSize = moveFrom.Size();
 }
 
 template <typename Data>
-bool StackVec<Data>::operator==(const StackVec& toCompare) const noexcept{
-  Vector<Data>::operator==(toCompare);
+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& toCompare) const noexcept{
-  Vector<Data>::operator!=(toCompare);
+bool StackVec<Data>::operator!=(const StackVec<Data>& toCompare) const noexcept{
+  return !(*this == toCompare);
 }
 
 // Specific member functions (inherited from Stack)
@@ -83,20 +94,21 @@ void StackVec<Data>::Push(Data&& data){
     Expand();
   }
   std::swap(Elements[stackSize], data);
+  ++stackSize;
 }
 
 template <typename Data>
 Data& StackVec<Data>::Top() const{
   if(stackSize == 0){
-    throw std::length_error("Empty Stack!");
+    throw std::length_error("Empty Stack! (TOP)");
   }
-  return Elements[stackSize-1]
+  return Elements[stackSize-1];
 }
 
 template <typename Data>
 void StackVec<Data>::Pop(){
-  if(stackSize<=0){
-    throw std::length_error("Empty Stack!");
+  if(stackSize==0){
+    throw std::length_error("Empty Stack! (POP)");
   }
   --stackSize;
   if(stackSize < (int)(size/4)){
@@ -131,6 +143,13 @@ void StackVec<Data>::Reduce(){
   Vector<Data>::Resize((ulong)size/2);
 }
 
+template <typename Data>
+void StackVec<Data>::Clear(){
+  delete [] Elements;
+  size = 4;
+  stackSize = 0;
+  Elements = new Data[size];
+}
 /* ************************************************************************** */
 
 }

librerie/exercise2/stack/vec/stackvec.hpp

@@ -23,7 +23,7 @@ protected:
 
   ulong stackSize = 0; // first empty cell
   using Vector<Data>::Elements;
-  using Vector<Data>::size;
+  using Vector<Data>::size; // dimension of the vector
 
 
 public: