=============
Dynamic Array
=============


--------
Examples
--------

C
==

.. code-block:: c

  #include <stdio.h>
  #include <stdlib.h>
  
  #define ARRAY_INITIAL_SIZE 100;
  
  typedef struct {
      int size;
      int max;
      int *data;
  } Dynamic_array;
  
  void array_initialize(Dynamic_array* array) {
      array->size = 0;
      array->max = ARRAY_INITIAL_SIZE;
      array->data = malloc(sizeof(int) * array->max);
  }
  
  void array_append(Dynamic_array* array, int val) {
      if (array->size >= array->max) {
          array->max *= 2;
          array->data = realloc(array->data, sizeof(int) * array->max);
      }
      array->data[array->size++] = val;
  }
  
  void array_set(Dynamic_array* array, int index, int val) {
      while (index >= array->size) {
          array_append(array, 0);
      }
      array->data[index] = val;
  }
  
  int array_get(Dynamic_array( array, int index) {
      if (index >= array->size || index < 0) {
          printf("Error: Index %d out of bounds for array of size%d\n", index, array->size);
          exit(1);
      }
      return array->data[index];
  }
  
  void array_free(Dynamic_array* array) {
      free(array->data);
  }
  
  int main(int argc, char *argv[]) {
      Dynamic_array array;
      int i;
      array_initialize(&array);
      for (i = 0; i < 200; i++) {
          array_append(&array, i * 2);
      }
      array_set(&array, 300, 600);
      array_free(&array);
      return 0;
  }


C
==

.. code-block:: c

  #define VECTOR_INITIAL_CAPACITY 100
  
  typedef struct {
      int size;
      int capacity;
      int *data;
  } Vector;
  
  void vector_init(Vector *vector);
  void vector_append(Vector *vector, int value);
  int vector_get(Vector *vector, int index);
  void vector_set(Vector *vector, int index, in value);
  void vector_double_capacity_if_full(Vector *vector);
  void vector_free(Vector *vector);

.. code-block:: c

  #include <stdio.h>
  #include <stdlib.h>
  #include "vector.h"
  
  void vector_init(Vector *vector) {
      vector->size = 0;
      vector->capacity = VECTOR_INITIAL_CAPACITY;
      vector->data = malloc(sizeof(int) * vector->capacity);
  }
  
  void vector_append(Vector *vector, int value) {
      vector_double_capacity_if_full(vector);
      vector->data[vector->size++] = value;
  }
  
  int vector_get(Vector *vector, int index) {
      if (index >= vector->size || index < 0) {
          printf("Index %d out of bounds for vector of size %d\n", index, vector->size);
          exit(1);
      }
      return vector->data[index];
  }
  
  void vector_set(Vector *vector, int index, int value) {
      while (index >= vector->size) {
          vector_append(vector, 0);
      }
      vector->data[index] = value;
  }
  
  void vector_double_capacity_if_full(Vector *vector) {
      if (vector->size >= vector->capacity) {
          vector->capacity *= 2;
          vector->data = realloc(vector->data, sizeof(int) * vector->capacity);
      }
  }
  
  void vector_free(Vector *vector) {
      free(vector->data);
  }


C++
====

.. code-block:: cpp

  class DynamicArray {
  public:
      DynamicArray();
      DynamicArray(int initSize);
      DynamicArray(const DynamicArray &original);
      ~DynamicArray();
  
      void insert(int position, int value);
      int get(int position);
      int getSize();
      void resize(int newSize);
      int &operator[](int index);
      bool operator==(DynamicArray);
      bool operator!=(DynamicArray);
  
  private:
      int size;
      int *array;
  };

.. code-block:: cpp

  #include "dynamicarray.h"
  
  using namespace std;
  
  DynamicArray::DynamicArray() {
      DynamicArray::DynamicArray(5);
  }
  
  DynamicArray::DynamicArray(int initSize) {
      size = initSize;
      array = new int[size];
      for (int i = 0; i < size; i++) {
          array[i] = 0;
      }
  }
  
  DynamicArray::DynamicArray(const DynamicArray &original) {
      size = original.size;
      array = new int[size];
      for (int i = 0; i < size; i++) {
          array[i] = original.array[i];
      }
  }
  
  DynamicArray::~DynamicArray() {
      delete[] array;
  }
  
  void DynamicArray::insert(int position, int value) {
      array[position] = value;
  }
  
  int DynamicArray::get(int position) {
      return array[position];
  }
  
  int DynamicArray::getSize() {
      return size;
  }
  
  void DynamicArray::resize(int newSize) {
      int *temp;
      temp = new int[newSize];
      for (int i = 0; i < (newSize); i++) {
          temp[i] = array[i];
      }
      delete[] array;
      array = temp;
      size = newSize;
  }
  
  bool DynamicArray::operator==(DynamicArray a) {
      if (a.size != size) return false;
      for (int i = 0; i < (a.size); i++) {
          if (a[i] != array[i]) return false;
      }
  }
  
  bool DynamicArray::operator!=(DynamicArray a) {
      if (a.size != size) return true;
      for (int i = 0; i < (a.size); i++) {
          if (a[i] != array[i]) return true;
      }
  }
  
  int &DynamicArray::operator[](int index) {
      if ((index - 1) > size) {
          resize(index + 1);
      }
      return array[index];
  }

.. code-block:: cpp

  #include <iostream>
  #include "dynamicarray.h"
  
  using namespace std;
  
  int main(int argc, char **argv) {
      DynamicArray array = DynamicArray(4);
      array.insert(1, 7);
      array.insert(3, 2);
      array[2] = 4;
      array[10] = 4
  
      DynamicArray array2 = DynamicArray(array);
  
      return 0;
  }