dynamic array

array.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "array.h"

array_t *array_new(void) {
    array_t *array = malloc(sizeof(array_t));
    if (array == NULL) {
       return NULL;
    }

    array->size = 0;
    array->data = NULL;

    return array;
}

int array_get(array_t *array, unsigned int index, int *value) {
    if (index >= array->size) {
        return -1;
    }

    *value = array->data[index];
    return 0;
}

int array_set(array_t *array, unsigned int index, int value) {
    if (index >= array->size) {
        return -1;
    }

    array->data[index] = value;
    return 0;
}

int array_delete(array_t *array, unsigned int index) {
    if (index >= array->size) {
        return -1;
    }

    int last = array->data[array->size - 1];

    int *temp = realloc(array->data, (array->size - 1) * sizeof(int));
    if (array->size != 1 && temp == NULL) {
        return -2;
    }
    array->data = temp;
    array->size--;

    if ((array->size - index ) > 1) {
        memmove(array->data + index, array->data + index + 1, (array->size - index - 1) * sizeof(int));
    }
    

    if (index < array->size) {
        array->data[array->size - 1] = last;
    }

    return 0;
}    

int array_append(array_t *array, int value) {
    int *temp = realloc(array->data, (array->size + 1) * sizeof(int));

    if (temp == NULL) {
        return -2;
    }

    array->data = temp;
    array->data[array->size] = value;
    array->size++;
    return 0;
}

unsigned int array_length(array_t *array) {
    return array->size;
}

void array_free(array_t *array) {
    free(array->data);
    free(array);
}

//dump to stdout for debugging
void array_dump(array_t *array) {
    for (int i = 0; i < array->size; i++) {
        printf("%d ", array->data[i]);
    }
    printf("\n");
}

array.h

//array.h

typedef struct {
    unsigned int size;
    int *data;
} array_t;

array_t *array_new(void);
int array_get(array_t *array, unsigned int index, int *value);
int array_set(array_t *array, unsigned int index, int value);
int array_delete(array_t *array, unsigned int index);
int array_append(array_t *array, int value);
unsigned int array_length(array_t *array);
void array_free(array_t *array);
//dump to stdout for debugging
void array_dump(array_t *array);

/* methods returning int should return:
	 0 on success
	-1 on out of bounds
	-2 on out of memory
 */

main.c

//main.c

#include <stdio.h>
#include <assert.h>
#include "array.h"

int main(void) {
    array_t *arr = array_new();
    if (!arr) {
        perror("erorr allocating array");
        return -1;
    }

    int value;

    /* Test basic append and length */
    assert(array_append(arr, 42) == 0);
    assert(array_append(arr, -50) == 0);
    assert(array_append(arr, 76) == 0);
    assert(array_length(arr) == 3);

    array_dump(arr); /* should print 42 -50 76 */

    /* Test get */
    assert(array_get(arr, 0, &value) == 0);
    assert(value == 42);
    assert(array_get(arr, 1, &value) == 0);
    assert(value == -50);
    assert(array_get(arr, 2, &value) == 0);
    assert(value == 76);

    /* Test out of bounds get */
    assert(array_get(arr, 3, &value) == -1);

    /* Test set */
    assert(array_set(arr, 1, 25) == 0);
    assert(array_get(arr, 1, &value) == 0);
    assert(value == 25);

    array_dump(arr); /* should print 42 25 76 */

    /* Test removal of end element */
    assert(array_delete(arr, 2) == 0);
    assert(array_length(arr) == 2);
    assert(array_get(arr, 0, &value) == 0);
    assert(value == 42);
    assert(array_get(arr, 1, &value) == 0);
    assert(value == 25);

    /* Test removal of middle element */
    assert(array_append(arr, 10) == 0);
    assert(array_length(arr) == 3);
    assert(array_delete(arr, 1) == 0);
    assert(array_length(arr) == 2);
    assert(array_get(arr, 0, &value) == 0);
    assert(value == 42);
    assert(array_get(arr, 1, &value) == 0);
    assert(value == 10);

    /* Test removal of beginning element */
    assert(array_append(arr, 23) == 0);
    assert(array_length(arr) == 3);
    assert(array_delete(arr, 0) == 0);
    assert(array_length(arr) == 2);
    assert(array_get(arr, 0, &value) == 0);
    assert(value == 10);
    assert(array_get(arr, 1, &value) == 0);
    assert(value == 23);

    array_free(arr);

    return 0;
}