Merge pull request #33 from yusuf601/feat/tail_pointer

fix: implementasi tail pointer

Author: yusuf601

CMakeLists.txt

@@ -31,6 +31,7 @@ enable_testing()
 add_executable(forward_list_test
   test/testing.cpp
 )
+# set_tests_properties(forward_list_test PROPERTIES TIMEOUT 5)
 target_link_libraries(forward_list_test
   PRIVATE forward_list_lib GTest::gtest_main
 )

build_testing.sh

@@ -1,6 +1,6 @@
 build(){
     cmake -S . -B build
     cmake --build build -j
-    ctest --test-dir build -V
+    ctest --test-dir build --timeout 5 -V
 }
 build

header/forward_list.hpp

@@ -43,14 +43,15 @@ class forward_lists{
          */
         template <typename It>  
         requires my_input_iterator<It>
-        forward_lists(It begin,It end): head(nullptr),size(0){
+        forward_lists(It begin,It end){
             head = new Node(T{});
             size = 0;
             head->next = nullptr;
             tail = head;
-            Node** curr = &tail->next; //curr menunjuk head->next
+            Node** curr = &head->next; //curr menunjuk head->next
             while(begin != end){
-                *curr = new Node(*begin); //isi node
+                *curr = new Node(*begin); //isi node dengan deferencing begin
+                tail = *curr;
                 curr = &((*curr)->next); //curr = curr->next
                 size++; //increment size
                 ++begin; //increment iterator
@@ -65,10 +66,11 @@ class forward_lists{
             head->next = nullptr;
             tail = head;
             size = 0;
-            Node** curr = &tail->next; //store alamat memory head ke curr
+            Node** curr = &head->next; //store alamat memory head ke curr
             for(const T& it: arr){
                 *curr = new Node(it); //deference pointer
                 //head = new Node(it) ->meaning
+                tail = *curr;
                 curr = &((*curr)->next); //store alamat curr->next
                //curr = head->next
                //curr selalu menunjuk ke posisi kosong
@@ -119,21 +121,29 @@ class forward_lists{
          * karena head = others.head maka head == nullptr,akan mengakibatkan
          * undefined behavior
          */
-        forward_lists(forward_lists&& others) noexcept : head(nullptr){
-            head = others.head;
+        forward_lists(forward_lists&& others) noexcept: head(new Node(T{})),tail(head),size(0){
+            head->next = others.head->next;
+            tail = others.tail == head ? head: others.tail; //ternery operator,if you dont understand please read documentation 
             size = others.size;
-            others.head = nullptr; //kosongkan others lama agar tidak memory leak
+
+            //kosongkan object lama
+            others.head->next = nullptr; 
+            others.tail = others.head;
             others.size = 0;
         }
         /**
          * @brief move assignment constructor
          */
         forward_lists& operator=(forward_lists&& others)noexcept{
-            if(this != others){
+            if(this != &others){
                 clear();
-                head = others.head;
+                head->next = others.head->next;
+                tail = others.tail == head ? head: others.tail; //ternery operator,if you dont understand please read documentation 
                 size = others.size;
-                others.head = nullptr;
+
+                //kosongkan object lama
+                others.head->next = nullptr; 
+                others.tail = others.head;
                 others.size = 0;
             }
             return *this;
@@ -250,6 +260,9 @@ class forward_lists{
         std::size_t max_size()const noexcept{
             return std::numeric_limits<T>::max() / sizeof(Node);
         }   
+        T back()const noexcept{
+            return this->tail->data;
+        }
     public:
         /**
          * @brief method untuk insertion val pada pos front
@@ -288,15 +301,14 @@ class forward_lists{
         void pop_front(){   
             if(tail == head){
                 return;
-            }else if(head->next == tail->next){
-                head = tail = nullptr;
-                size--;
-            }else{
-                Node* temp = head->next;
-                Node* next = head->next;
-                head->next = next->next;
-                delete temp;
             }
+            Node* temp = head->next;
+            head->next = temp->next;
+            if(temp == tail){
+                tail = head;
+            }
+            delete temp;
+            size--;
         }
         /**
          * @brief Menyisipkan elemen setelah posisi iterator tertentu.
@@ -551,7 +563,7 @@ class forward_lists{
             head = new Node(T{});
             head->next = nullptr;
             Node** curr = &head->next;
-            size++;
+            //size++;
             for(const T& value: arr){
                 *curr = new Node(value); //curr = new Node
                 curr = &((*curr)->next); //curr = curr->next
@@ -602,18 +614,25 @@ class forward_lists{
         }
         void splice_after(const Iterator pos,forward_lists& others){
             Node* src = pos.get_raw();//pos object saat ini
-            Node* begin = others.begin(); //begin object lain
-            Node* end = others.end();
-            //hubungkan node terakhir ke object saat ini
-            Node* moved = src->next; //object saat ini
-            end->next = moved; //end->next = src->next
-           //hubungkan ke list tujuan
-            Node* curr = src; //curr menunjuk src
-            curr->next = begin;//curr next adalah begin dari object lain
-            //moved->next = begin; //object saat ini
-            size = others.size;
+            Node* begin = others.head->next ; //begin object lain
+            Node* end = others.tail; //end object lain
+
+            //lingking node pertama others ke object saat ini
+            Node* moved = src->next; 
+            moved->next = begin->next; //tunjuk node setelah begin
+
+            begin->next = moved; //linking begin ke node setelah iterator
+            //linking node terakhir object lain ke src->next
+            end->next = src->next;
+
+            //linking node pertama object saat ini ke head object lain
+            src->next = begin;
+            size += others.size;
             others.size = 0;
         }
+        // void splice_after(const Iterator pos,forward_lists& others,const Iterator first,const Iterator last){
+        //     Node* curr = pos.get_raw();
+        // }
     public:
         /**
          * @brief method untuk print semua node list 
@@ -632,13 +651,16 @@ class forward_lists{
          * berguna pada destructor
          * @details time complexity O(n),Space Complexity O(n)
          */
-        void clear(){
-            while(head->next != nullptr){
-                Node* temp = head->next;
-                head->next = head->next->next;
-                delete temp;
-            }
-            size = 0;
-        }
+    void clear(){
+        Node* curr = head->next;   // mulai dari setelah dummy
+        while(curr != nullptr){
+            Node* temp = curr;
+            curr = curr->next;
+            delete temp;
+        }
+        head->next = nullptr;  // dummy menunjuk ke kosong
+        tail = head;           // tail kembali ke dummy
+        size = 0;
+    }
 };
 #endif

implementation/implementation.cpp

@@ -6,6 +6,8 @@ int main(){
     forward_lists<int>flst = {1,2,3};
     flst.pop_front();
     flst.pop_front();
+    std::cout << "harus nya sisa 3" << std::endl;
+    std::cout << "ini tail " << flst.back() << std::endl;
     flst.print_all(flst.begin(),flst.end()); //3
     //initializer list
     std::cout << "initializer list constructor" << std::endl;

test/testing.cpp

@@ -16,7 +16,7 @@ TEST(Basic_stl,pop_element){
     forward_lists<int>fl = {1,2,3,4,5};
     EXPECT_EQ(fl.get_size(),5);
     EXPECT_EQ(fl.front(), 1);
-    fl.pop_front();
+     fl.pop_front();
     std::vector<int>actual;
     std::vector<int>expectation = {2,3,4,5};
     for(auto x: fl){
@@ -68,15 +68,15 @@ TEST(Constructor_testing,basic_constructor_test){
 }
 TEST(Constructor_testing,mv_constructor){
     forward_lists<int>fl = {1,2,3,4};
-    forward_lists<int>flst = std::move(fl);
     int size_fl = fl.get_size();
-    int size_flst = flst.get_size();
-    EXPECT_EQ(size_fl,size_flst);
     std::vector<int>exFl;
-    std::vector<int>exFlst;
     for(auto x: fl){
         exFl.push_back(x);
     }
+    forward_lists<int>flst = std::move(fl);
+    int size_flst = flst.get_size();
+    EXPECT_EQ(size_fl,size_flst);
+    std::vector<int>exFlst;
     for(auto x: flst){
         exFlst.push_back(x);
     }
@@ -85,6 +85,7 @@ TEST(Constructor_testing,mv_constructor){
 TEST(Constructor_testing,mv_assgn_test){
     forward_lists<int>list;
     list = {1,2,3};
+    int Ssize = list.get_size();
     forward_lists<int>cp;
     cp = std::move(list);
     std::vector<int>Slist;
@@ -95,10 +96,9 @@ TEST(Constructor_testing,mv_assgn_test){
     for(auto x: cp){
         Scp.push_back(x);
     }
-    int SizeList = list.get_size();
-    int SizeCp = cp.get_size();
-    EXPECT_EQ(SizeList,SizeCp);
-    EXPECT_EQ(Slist,Scp);
+    EXPECT_EQ(list.get_size(),0);
+    EXPECT_EQ(cp.get_size(),3);
+    EXPECT_EQ(cp.get_size(),Ssize);
 }
 TEST(Insert_testing,push_testing){
     forward_lists<int>fl;
@@ -212,4 +212,18 @@ TEST(Assign_test,Assign_testIII){
         actual.push_back(x);
     }
     EXPECT_EQ(actual,expectations);
-}
+}
+// TEST(splice_test,splice_testI){
+//     forward_lists<int>fl = {1,2,3};
+//     forward_lists<int>list = {10,20,30};
+//     fl.splice_after(fl.begin(),list);
+//     std::vector<int>expectations = {1,10,20,30,2,3};
+//     std::vector<int>actual;
+//     for(auto x: fl){
+//         actual.push_back(x);
+//     }
+//     EXPECT_EQ(fl.get_size(),6);
+//     EXPECT_EQ(list.get_size(),0);
+//     EXPECT_TRUE(!list.is_empty());
+//     EXPECT_EQ(actual,expectations);
+// }