added "slice" method,

"slice" method takes 2 arguments, start-index, and end-index . It will remove all elements from the start-index to the end-index.
list.slice(4, 8) // Removes elements from index 4 to and including index 8.

Author: timbatt

linkedLists.h

@@ -1,5 +1,6 @@
 #include <iostream>
-#include <string>
+#include <cstring>
+#include <stdlib.h>
 
 using namespace std;
 
@@ -9,11 +10,13 @@ class List
 	typedef struct Node
 	{
 		int data;
+		int index;
 		struct Node* next;
 		struct Node* prev;
 	} node;
-	
-	node* list()
+
+	// Private methods
+	node* m_listNode()
 	{
 		node* head = NULL;
 		head = (node*)malloc(sizeof(node));
@@ -25,14 +28,40 @@ class List
 		return head;
 	}
 
+	void m_removeNode(node* target)
+	{	
+		node* nextNode = target->next;
+		node* prevNode = target->prev;
+		
+		if(prevNode != NULL && nextNode != NULL)
+		{
+			prevNode->next = nextNode;
+			nextNode->prev = prevNode;
+		}
+        m_size--;
+        cout << "Removed " << target->data << endl;
+
+		free(target);
+
+	}
+
+    void copyNode(node* dest, node* src)
+    {
+        dest->next = src->next;
+        dest->prev = src->prev;
+        dest->data = src->data;
+    }
+
 	// Private variables.
-	int m_size = 0;
-	int m_maxIndex = m_size - 1;
-	node* m_head = list();
+	node* m_head = m_listNode();
 	node* m_first = m_head; // Sets the first list node to the current state of m_head
 	node* m_last = m_head;
+	node* m_lastRemovedNode = m_listNode();
+	int INDEX = 0;
+	int m_lastRemovedIndex;
 
 public:
+	int m_size = 0;
 	// prints list
 	void print()
 	{
@@ -41,9 +70,9 @@ class List
 		// with 0, so when the list is printed, we skip the first one.
 		if(m_size != 0)
 		{
-			if(m_head->next !=  NULL)
+			if(m_head->next != NULL)
 			{
-				m_head = m_head->next;
+				m_head = m_first->next;
 			}
 			while(m_head != NULL)
 			{
@@ -58,64 +87,68 @@ class List
 		printf("\n");
 	}
 
-	// removes element from given index
-	int remell(int index)
+	int remel(int index)
 	{
-		m_head = m_first;
-		if(index != 0)
-		{
-			m_head = m_head->next; // skip the first one, it's just the initializer.
-		}
-		if(m_head->next == NULL)
-		{
-			cout << "ERROR: NULL at index " << index << ".\n";
-			exit(1);
-		}
-		if(index > m_size - 1)
+		int maxIndex = m_size - 1;
+
+		// Index out of range
+		if(index > maxIndex)
 		{
-			cout << "[ERROR]: List is empty!\n";
+			cout << "[ERROR]: Index out of range!\n";
 			exit(1);
 		}
-		
+
+        m_head = m_first->next;
+        // Start at the beginning of the list and iterate over the items until reaching the desired index.
 		for(int i = 0; i <= index; i++)
-		{	
-			if (i == index - 1 || index == 0)
+		{
+			if (i == index && m_head != NULL)
 			{
-				if(m_head != NULL)
-				{
-					node* targetHead = m_head->next;
-					int data = targetHead->data;
-					if(targetHead->next != NULL)
-					{
-						node* nextHead = targetHead->next;
-						nextHead->prev = m_head; // New head-prev pointer = current head
-						m_head->next = nextHead; // current head-next pointer = nextHead
-						
-						free(targetHead);
-						m_size--;
-						return data;
-					}
-					// Target head is last item in list, do this...
-					else
-					{
-						m_head->next = NULL;
-						free(targetHead);
-						m_size--;
-						return data;
-					}
-				}
+				int data = m_head->data;
+                copyNode(m_lastRemovedNode, m_head);
+				m_removeNode(m_head);
+			    return data;
 			}
 			m_head = m_head->next;
 		}
+
 		cout << "[ERROR]: Something went wrong while removing element from index " << index << endl;
 		cout << "Make sure list is not empty, and index is not out of range.\n";
 		exit(1);
 	}
 
+    void slice(int startIndex, int endIndex)
+    {
+        int maxIndex = m_size - 1;
+
+		// Index out of range
+		if(startIndex > maxIndex)
+		{
+			cout << "[ERROR]: Index out of range!\n";
+			cout << "Max index is " << maxIndex << " but you chose " << startIndex << " for slice start.\n";
+			exit(1);
+		}
+        if(endIndex > maxIndex)
+        {
+            cout << "[ERROR]: Index out of range!\n";
+			cout << "Max index is " << maxIndex << " but you chose " << endIndex << " for slice end.\n";
+			exit(1);
+        }
+
+		remel(startIndex);
+		for(int i = startIndex + 1; i <= endIndex; i++)
+		{
+		        node* targetNode = m_lastRemovedNode->next;
+		        copyNode(m_lastRemovedNode, targetNode);
+		        m_removeNode(targetNode);
+		}
+    }
+	
 	int index(int index)
 	{
+		int maxIndex = m_size - 1;
 		m_head = m_first;
-		if (index > m_size - 1)
+		if (index > maxIndex)
 		{
 			cout << "[ERROR] No element at index " << index << "!!!\n";
 			cout << "The length of the list you are accessing is only " << m_size << endl;
@@ -139,8 +172,7 @@ class List
 	// appends to list
 	void append(int value)
 	{
-		
-		node* nextNode = list();
+		node* nextNode = m_listNode();
 		m_last->next = nextNode;
 		nextNode->prev = m_last;
 		nextNode->data = value;

list-test.cpp

@@ -8,17 +8,17 @@ int main()
 {
 	List nums;
 
-	int count = 100;
-	
-	for(int i = 0; i < count; i++)
+	int count = 10;
+
+	for(int i = 0; i <= count; i++)
 	{
 		nums.append(i);
 		cout << "Appended " << i << endl;
 	}
-	for(int i = 0; i < count; i++)
-	{
-		int num = nums.remell(0);
-		cout << "Removed " << num << endl;
-	}
-	
+	nums.slice(5, 8);
+	nums.print();
+	nums.slice(2, 4);
+	nums.print();
+
+
 }