Safer push_back and faster push_back (I went from 0(n^2) to 0(1))

src/main.c

@@ -3,7 +3,7 @@
  * dmm.dev@icloud.com
  * No LICENSE
  * Vector Library For C
-*/
+ */
 
 /*
  * Types Wanted:
@@ -13,7 +13,17 @@
  *      String
  */
 
-// Absolutely no AI is permitted when writing code.
+/* Absolutely no AI is permitted when writing code.
+ * AI is and can be used to generate tests for code; however, the test results
+ * and the AI can not give code as to how to fix the source aside from psuedo
+ * code that has no clear relation to the source aside from a recreation of the
+ * problem in a different way entirely
+ *
+ * Any code comments below are just used for my purposes with short term memory.
+ * It also serves as a way to remember what needs to be changed to be readable
+ * and not need comments in the first place.
+ */
+#include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -23,17 +33,35 @@ typedef struct
 {
 	char* arr;
 	size_t size;
+	size_t capacity;
 } Vec8_t;
 
+/* Takes in a temporary cpy of a vec
+ * - Can be nullptr to not have size incrementation and have a size of 0 (Create
+ * an empty vector)
+ *
+ * - Can be a vec to have size incrementation and size of base vec + 1 (Create a
+ * vector for modifying an old vector)
+ *
+ * */
 Vec8_t
-create(size_t init_size)
+create(const Vec8_t* input)
 {
-	Vec8_t vec = { .arr = nullptr, .size = 0 };
-	if (init_size > 0)
+	Vec8_t vec = { .arr = nullptr, .size = 0, .capacity = 4 };
+	if (input == nullptr)
 	{
-                vec.arr = malloc(init_size * sizeof(char));
-		vec.size = init_size;
+		vec.arr = calloc(vec.capacity, sizeof(char));
+		return vec;
 	}
+	if (input->size > 0)
+	{
+		vec.size = input->size + 1;
+	}
+	if (input->capacity >= vec.capacity)
+	{
+		vec.capacity = 2 * input->capacity;
+	}
+	vec.arr = calloc(vec.capacity, sizeof(char));
 	return vec;
 }
 
@@ -47,11 +75,22 @@ delete(Vec8_t* vec)
 	vec->arr = nullptr;
 }
 
-
 char
-at(Vec8_t* vec, int idx)
+at(const Vec8_t* vec, const int idx)
 {
-	if (vec->arr != nullptr && vec->size >= idx)
+	if (vec == nullptr)
+	{
+		return -2;
+	}
+	if (vec->arr == nullptr)
+	{
+		return -3;
+	}
+	if (vec->size <= idx)
+	{
+		return -4;
+	}
+	if (vec != nullptr && vec->arr != nullptr && vec->size > idx)
 	{
 		return vec->arr[idx];
 	}
@@ -59,27 +98,32 @@ at(Vec8_t* vec, int idx)
 }
 
 void
-print_vec(Vec8_t* vec) {
-        for(int i = 0; i < vec->size; i++) {
-                printf("%c ", at(vec, i));
-        }
-        printf("\n");
+print_vec(const Vec8_t* vec)
+{
+	for (int i = 0; i < vec->size; i++)
+	{
+		if (vec->arr[i])
+		{
+			printf("%c ", at(vec, i));
+		}
+	}
+	printf("\n");
 }
 
 int
-begin(Vec8_t* vec)
+begin(const Vec8_t* vec)
 {
-	if (vec->arr != nullptr && vec->size > 0)
+	if (vec != nullptr && vec->arr != nullptr && vec->size > 0)
 	{
-		return 1;
+		return 0;
 	}
 	return -1;
 }
 
 int
-end(Vec8_t* vec)
+end(const Vec8_t* vec)
 {
-	if (vec->arr != nullptr && vec->size > 0)
+	if (vec != nullptr && vec->arr != nullptr && vec->size > 0)
 	{
 		return (int)(vec->size - 1);
 	}
@@ -87,60 +131,77 @@ end(Vec8_t* vec)
 }
 
 char
-front(Vec8_t* vec)
+front(const Vec8_t* vec)
 {
-	if (vec->arr != nullptr && vec->size > 0)
-	{
-		return vec->arr[0];
-	}
-	return -1;
+	return at(vec, 0);
 }
 
 char
-back(Vec8_t* vec)
+back(const Vec8_t* vec)
 {
-	if (vec->arr != nullptr && vec->size > 0)
+	if (vec)
 	{
-		return vec->arr[vec->size - 1];
+		return at(vec, (int)vec->size - 1);
 	}
 	return -1;
 }
 
+/* Return a Vector
+ * if below capacity
+ *
+ *
+ * */
 Vec8_t
-add_back(Vec8_t* vec, char val)
+add_back(Vec8_t* vec, const char val)
 {
-	Vec8_t nvec = create(vec->size + 1);
-	memcpy(&nvec.arr[0], &vec->arr[0], vec->size * sizeof(char));
-	if (nvec.arr && (nvec.size > 0 || nvec.size > vec->size))
+	Vec8_t ret = { .arr = nullptr, .capacity = 0, .size = 0 };
+	if (vec->size < vec->capacity)
 	{
-		nvec.arr[vec->size] = val;
+		vec->arr[vec->size] = val;
+		vec->size++;
+		return *vec;
 	}
-	return nvec;
+
+	if (vec->size >= vec->capacity)
+	{
+		Vec8_t nvec = create(vec);
+		memcpy(&nvec.arr[0], &vec->arr[0], vec->size * sizeof(char));
+		if (nvec.arr && (nvec.size > 0 || nvec.size > vec->size))
+		{
+			nvec.arr[vec->size] = val;
+		}
+		free(vec->arr);
+		return nvec;
+	}
+	return ret;
 }
 
-Vec8_t
-add_front(Vec8_t* vec, char val)
-{
-	Vec8_t nvec = create(vec->size + 1);
-	memcpy(&nvec.arr[1], &vec->arr[0], vec->size * sizeof(char));
-	if (nvec.arr && (nvec.size > 0 || nvec.size > vec->size))
-	{
-		nvec.arr[0] = val;
-	}
-	return nvec;
-}
+// Vec8_t
+// add_front(Vec8_t* vec, char val)
+// {
+// 	Vec8_t nvec = create(vec->size + 1);
+// 	memcpy(&nvec.arr[1], &vec->arr[0], vec->size * sizeof(char));
+// 	if (nvec.arr && (nvec.size > 0 || nvec.size > vec->size))
+// 	{
+// 		nvec.arr[0] = val;
+// 	}
+// 	return nvec;
+// }
 
 int
 main()
 {
-	Vec8_t vec = create(0);
+	Vec8_t vec = create(nullptr);
 	vec = add_back(&vec, '3');
 	vec = add_back(&vec, '4');
 	vec = add_back(&vec, '5');
 	vec = add_back(&vec, '6');
-        print_vec(&vec);
-	vec = add_front(&vec, 'c');
-        print_vec(&vec);
+	vec = add_back(&vec, '7');
+	print_vec(&vec);
+	// vec = add_back(&vec, '6');
+	// vec = add_front(&vec, 'c');
+	//        print_vec(&vec);
+	//        printf("%c", at(nullptr, 0));
 
 	delete(&vec);
 	return 0;