array.c

//
//  array.c
//  GameEngine
//
//  Created by Zachary Becker on 3/31/11.
//  Copyright 2011 Home. All rights reserved.
//

#include "array.h"

#include <stdlib.h>
#include <stdarg.h>
#include <string.h>

ARRAY *array_create()
{
    ARRAY *array = malloc(sizeof(ARRAY));
    array->size = 0;
    array->capacity = 0;
    array->data = NULL;
    return array;
}

ARRAY *array_create_with(int count, ...)
{
    ARRAY *array = array_create();
    va_list args;
    va_start(args, count);
    for (int i = 0; i < count; ++i)
        array_push(array, va_arg(args, void *));
    va_end(args);
    return array;
}

void array_destroy(ARRAY *array)
{
    if (array->data != NULL)
        free(array->data);
    free(array);
}

ARRAY *array_copy(ARRAY *array)
{
    ARRAY *array_copy = array_create();
    array_copy->size = array->size;
    array_copy->capacity = array->capacity;
    array_copy->data = calloc(array_copy->capacity, sizeof(void *));
    memcpy(array->data, array_copy->data, array_copy->capacity * sizeof(void *));
    return array_copy;
}

int array_size(ARRAY *array)
{
    return array->size;
}

int array_capacity(ARRAY *array)
{
    return array->capacity;
}

int array_empty(ARRAY *array)
{
    return array->size == 0;
}

int array_reserve(ARRAY *array, int new_capacity)
{
    void *data;
    if (array->data)
        data = realloc(array->data, new_capacity * sizeof(void *));
    else
        data = calloc(new_capacity, sizeof(void *));
    if (!data)
        return -1; // Failed to allocate new memory
    if (array->data)
        memmove(array->data, data, array->size * sizeof(void *));
    array->data = data;
    array->capacity = new_capacity;
    return 0;
}

void *array_index(ARRAY *array, int index)
{
    return array->data[index];
}

void *array_front(ARRAY *array)
{
    return array->data[0];
}

void *array_back(ARRAY *array)
{
    return array->data[array->size - 1];
}

void array_push(ARRAY *array, void *data)
{
    if (array->size >= array->capacity)
        if (array->capacity <= 0)
            array_reserve(array, 2);
        else
            array_reserve(array, array->capacity * 2);
    array->data[array->size] = data;
    array->size++;
}

void array_push_elements(ARRAY *array, int count, ...)
{
    va_list args;
    va_start(args, count);
    for (int i = 0; i < count; ++i)
        array_push(array, va_arg(args, void *));
    va_end(args);
}

void array_pop(ARRAY *array)
{
    array->size--;
}

void array_insert(ARRAY *array, int index, void *data)
{
    if (array->size >= array->capacity)
        if (array->capacity <= 0)
            array_reserve(array, 2);
        else
            array_reserve(array, array->capacity * 2);
    memmove(&array->data[index], &array->data[index + 1],
            (array->size - index) * sizeof(void *));
    array->data[index] = data;
    array->size++;
}

void array_clear(ARRAY *array)
{
    if (array->data == NULL) {
        free(array->data);
        array->size = 0;
        array->capacity = 0;
    }
}

void array_erase(ARRAY *array, int index)
{
    array->size--;
    memmove(&array->data[index + 1], &array->data[index],
            (array->size - index) * sizeof(void *));
}

array.h

//
//  array.h
//  GameEngine
//
//  Created by Zachary Becker on 3/31/11.
//  Copyright 2011 Home. All rights reserved.
//

typedef struct array_s {
    int size;
    int capacity;
    void **data;
} ARRAY;

ARRAY *array_create();
ARRAY *array_create_with(int count, ...);
void array_destroy(ARRAY *array);
ARRAY *array_copy(ARRAY *array);

int array_size(ARRAY *array);
int array_capacity(ARRAY *array);
int array_empty(ARRAY *array);
int array_reserve(ARRAY *array, int new_capacity);

void *array_index(ARRAY *array, int index);
void *array_front(ARRAY *array);
void *array_back(ARRAY *array);

void array_push(ARRAY *array, void *data);
void array_push_elements(ARRAY *array, int count, ...);
void array_pop(ARRAY *array);
void array_insert(ARRAY *array, int index, void *data);

void array_clear(ARRAY *array);
void array_erase(ARRAY *array, int index);

main.c

#include <stdlib.h>
#include <stdio.h>

#include "array.h"

int *newInt(int n)
{
    int *int_p;
    int_p = malloc(sizeof(int));
    *int_p = n;
    return int_p;
}

int main(int argc, char **argv)
{
    ARRAY *array = array_create();
    int i;

    for (i = 0; i < 10; ++i)
       array_push(array, newInt(i));

    int *el;
    for (i = 0; i < array_size(array); ++i) {
        el = array_index(array, i);
        printf("%d ", *el);
    }
    printf("\n");

    for (i = 0; i < array_size(array); ++i)
        free(array_index(array, i));
    array_clear(array);

    return 0;    
}