darr.h File Reference

#include <stdbool.h>
#include <stddef.h>

Go to the source code of this file.

Classes
struct	darr_t

Macros
#define	DARR_DEFAULT_CAPACITY   2
#define	DARR_DEFAULT_GROWING_FACTOR   1.25f

Typedefs
typedef bool	compfun_t(void const *curr, void const *value)
typedef struct darr_t	darr_t

Functions
darr_t *	darr_new (void)
size_t	darr_get_size (darr_t *da)
size_t	darr_get_capacity (darr_t *da)
void *	darr_at (darr_t *da, size_t index)
int	darr_push (darr_t *da, void *value, size_t size)
int	darr_pop (darr_t *da)
int	darr_insert_at (darr_t *da, size_t index, void *value, size_t size)
int	darr_delete_at (darr_t *da, size_t index)
int	darr_find (darr_t *da, void *value, compfun_t compare)
void	darr_destroy (darr_t *da)

Macro Definition Documentation

DARR_DEFAULT_CAPACITY

#define DARR_DEFAULT_CAPACITY   2

Initial array capacity, that's just an arbitrary number and it can shrank as the items is removed. But this value can be changed to avoid resizing the array too soon.

Definition at line 13 of file darr.h.

DARR_DEFAULT_GROWING_FACTOR

#define DARR_DEFAULT_GROWING_FACTOR   1.25f

The growing factor will define how much the array should be resized when needed. Between 1 and 2 is a good choice. By the way, this value should be a float.

Definition at line 22 of file darr.h.

Typedef Documentation

compfun_t

typedef bool compfun_t(void const *curr, void const *value)

Type for the function that the darr_find() method will use to iterate over all items in the array to compare with the target item that needs to be found. The user isn't meant to use this type, it's useful to make the definition of the find paramter easier to write – but it can also be used as reference to build the comparation function in the main code.

Definition at line 32 of file darr.h.

darr_t

typedef struct darr_t darr_t

Struct that will hold the actual dinamic array and other informations to search, insert and remove elements from within. Since C doesn't support generic types, the array will be stored as an array that points to a sequence of pointers (I know complicated).

Since all the items is a generic pointer (void*) to something, it's due to the developer to cast that item into a type that makes sence, for an example: darr_at(mydarr, 1) will be a void*, cast this void to a int with (int *)darr_at(mydarr, 1) to interprete this as a pointer to an integer, and now access the value that it's pointing to with an extra *, like *(int *)darr_at(mydarr, 1).

Check the detailed darr_t description for more information about it's attributes.

Function Documentation

darr_at()

void * darr_at	(	darr_t *	da,
		size_t	index )

Definition at line 50 of file darr.c.

                                        {
  return index >= da->_size ? NULL : da->_arr[index];
}

darr_delete_at()

int darr_delete_at	(	darr_t *	da,
		size_t	index )

Definition at line 106 of file darr.c.

                                             {
  if (index >= da->_size)
    return -1;
 
  free(da->_arr[index]);
 
  memmove(&da->_arr[index], &da->_arr[index + 1],
          sizeof(void *) * (da->_size - index));
 
  if (!_shrink_darr(da))
    return -1;
 
  --da->_size;
 
  return index;
}

darr_destroy()

void darr_destroy

(

darr_t *

da

)

Definition at line 131 of file darr.c.

                              {
  if (da == NULL)
    return;
 
  for (size_t i = 0; i < da->_size; ++i)
    if (da->_arr[i] != NULL)
      free(da->_arr[i]);
 
  if (da->_arr != NULL)
    free(da->_arr);
 
  free(da);
}

darr_find()

int darr_find	(	darr_t *	da,
		void *	value,
		compfun_t	compare )

Definition at line 123 of file darr.c.

                                                          {
  for (size_t i = 0; i < da->_size; ++i)
    if (compare(da->_arr[i], value))
      return i;
 
  return -1;
}

darr_get_capacity()

size_t darr_get_capacity

(

darr_t *

da

)

Simple getter, this one was intended to be used for debugging propurses, but it can be in handy when needing to have fine control over the memory usage.

Returns

The darr_t._capacity attribute.

Definition at line 45 of file darr.c.

{ return da->_capacity; }

darr_get_size()

size_t darr_get_size

(

darr_t *

da

)

Simple getter, intended to be used in for/while loops to interact with the array itself.

Returns

The darr_t._size attribute.

Definition at line 37 of file darr.c.

{ return da->_size; }

darr_insert_at()

int darr_insert_at	(	darr_t *	da,
		size_t	index,
		void *	value,
		size_t	size )

Definition at line 86 of file darr.c.

                                                                       {
  if (index > da->_size)
    return -1;
 
  if (!_increase_darr(da))
    return -1;
 
  memmove(&da->_arr[index + 1], &da->_arr[index],
          sizeof(void *) * (da->_size - index));
 
  void *copy = malloc(size);
 
  memcpy(copy, value, size);
 
  da->_arr[index] = copy;
  ++da->_size;
 
  return index;
}

darr_new()

darr_t * darr_new

(

void

)

Creates a darr_t instance in the heap and allocates the initial size that the array will occupe based on the DARR_DEFAULT_CAPACITY value. The array will be a pointer [array] to other pointers with void (generic) type, this means that the items should be castet to some type when using, e.g.: *(float *)da->_arr[1] or, even better, *(float *)darr_at(da, 1).

Returns

A pointer to the created darr_t instance, it should be used in the other darr_*() methods to interact with the array itself.

Definition at line 21 of file darr.c.

                       {
  darr_t *da = malloc(sizeof(darr_t));
 
  da->_size = 0;
  da->_capacity = DARR_DEFAULT_CAPACITY;
  da->_arr = malloc(da->_capacity * sizeof(void *));
 
  return da;
}

darr_pop()

int darr_pop

(

darr_t *

da

)

Definition at line 70 of file darr.c.

                         {
  if (da->_size == 0)
    return -1;
 
  size_t const index = da->_size - 1;
 
  free(da->_arr[index]);
 
  --da->_size;
 
  if (!_shrink_darr(da))
    return -1;
 
  return index;
}

darr_push()

int darr_push	(	darr_t *	da,
		void *	value,
		size_t	size )

Definition at line 54 of file darr.c.

                                                    {
  size_t const index = da->_size;
 
  if (!_increase_darr(da))
    return -1;
 
  void *copy = malloc(size);
 
  memcpy(copy, value, size);
 
  da->_arr[index] = copy;
  ++da->_size;
 
  return index;
}