int main()
{
	int arr[] = { 1, 2, 3, 4 };
}

#include <stdlib.h>
 
int main()
{
 
	// Heap 상에 할당할 Static Array의 길이
	int len = 4;
 
	// Heap에 int 4칸짜리 Static Array에 필요한 byte만큼 동적 할당한 뒤,
	// 그 시작 주소를 반환하여 포인터에 저장
	int* arr = malloc(sizeof(int) * len);
 
	// 초기화
	for (int i = 0; i < len; i++) {
		arr[i] = i + 1;
	}
 
}

arr[4] = 250;

arr[4] = 5;

#include <stdlib.h>
#include <string.h>
 
int main()
{
 
		// Heap 상에 할당할 Static Array의 길이
		int len = 4;
 
		// Heap에 int 4칸짜리 Static Array에 필요한 byte만큼 동적 할당한 뒤,
		// 그 시작 주소를 반환하여 포인터에 저장
		int* arr = malloc(sizeof(int) * len);
 
		// 초기화
		for (int i = 0; i < len; i++) {
			arr[i] = i+1;
		}
 
		// 이전 len보다 2배 크기로 Heap 상의 새로운 메모리 공간에 재할당
		int* arr2 = malloc(sizeof(int) * len * 2);
 
		// arr2는 아직 초기화 되지 않았기 때문에 쓰레기 값을 가지고 있음
		// memcpy로 arr에 저장된 모든 요소를 arr2에 copy
		memcpy(arr2, arr, sizeof(int) * len);
 
		// 이제 용량이 2배가 되어 index 4에도 안전하게 접근할 수 있다.
		arr2[4] = 5;
 
		// 동적 할당된 메모리는 반드시 수동으로 할당 해제해야 한다.
		// 그렇지 않으면 메모리 누수가 발생하기 때문이다.
		free(arr);
		free(arr2);
}

#include <stdlib.h>
#include <string.h>
 
int main()
{
		// Heap에 Static Array 동적 할당 및 Stack에 해당 메모리 공간의 시작 주소 저장
		int* arr = malloc(sizeof(int) * 4);
		// arr에 요소 4개를 모두 저장
		for (int i = 0; i < len; i++) {
			arr[i] = i + 1;
		}
 
		// arr 용량 초과, Heap 상의 새로운 메모리 공간에 재할당
		int* arr2 = malloc(sizeof(int) * 8);
		// 이전 요소 copy
 
		memcpy(arr2, arr, sizeof(int) * 4);
		// 이전 Static Array 해제
		free(arr);
 
		// 이하 생략
		int* arr3 = malloc(sizeof(int) * 16);
		memcpy(arr3, arr2, sizeof(int) * 8);
		free(arr2);
 
		int* arr4 = malloc(sizeof(int) * 32);
		memcpy(arr4, arr3, sizeof(int) * 16);
		free(arr3);
 
		// ...
 
		free(arr4);
}

lst = [1, 2, 3]   # 빈 동적 배열 생성
lst.append(4)     # 요소 4 추가            -> [1, 2, 3, 4]
lst.insert(2, 5)  # index 2에 요소 5 추가   -> [1, 2, 5, 3, 4]
lst.remove(3)     # 값이 3인 요소 제거       -> [1, 2, 5, 4]
length = len(lst) # 동적 배열의 길이         -> 4
value = lst[0]    # index 0 요소 읽기      -> 1

#include <vector>
 
int main()
{
		// 빈 동적 배열 생성
    std::vector<int> vec;
 
    vec.push_back(1);  // 동적 배열에 요소 1 추가 -> [1]
    vec.push_back(2);  // 동적 배열에 요소 2 추가 -> [1, 2]
    vec.push_back(3);  // 동적 배열에 요소 3 추가 -> [1, 2, 3]
    vec.push_back(4);  // 동적 배열에 요소 4 추가 -> [1, 2, 3, 4]
 
		// index 2에 요소 5 삽입                    -> [1, 2, 5, 3, 4]
    vec.insert(my_vector.begin() + 2, 5);
 
		// index 3인 요소 삭제                      -> [1, 2, 5, 4]
    vec.erase(my_vector.begin() + 3);
 
		// 동적 배열의 크기                           -> 4
    int size = my_vector.size();
 
		// index 0 요소 읽기                        -> 1
    int value = my_vector[0];
}

import java.util.ArrayList;
 
public class Main {
    public static void main(String[] args) {
				// 빈 동적 배열 생성
        ArrayList<Integer> lst = new ArrayList<>();
 
        lst.add(1);  // 동적 배열에 요소 1 추가 -> [1]
        lst.add(2);  // 동적 배열에 요소 2 추가 -> [1, 2]
        lst.add(3);  // 동적 배열에 요소 3 추가 -> [1, 2, 3]
        lst.add(4);  // 동적 배열에 요소 4 추가 -> [1, 2, 3, 4]
 
				// 인덱스 2 위치에 요소 5 삽입          -> [1, 2, 5, 3, 4]
        lst.add(2, 5);
 
				// index 3인 요소 삭제               -> [1, 2, 5, 4]
        lst.remove(3);
 
				// 동적 배열의 크기                   -> 4
        int size = lst.size();
 
				// index 0인 요소 읽기               -> 1
        int value = lst.get(0);
 
    }
}

fun main() {
		// 빈 동적 배열 생성
    val lst = ArrayList<Int>()
 
    lst.add(1)  // 동적 배열에 요소 1 추가 -> [1]
    lst.add(2)  // 동적 배열에 요소 2 추가 -> [1, 2]
    lst.add(3)  // 동적 배열에 요소 3 추가 -> [1, 2, 3]
    lst.add(4)  // 동적 배열에 요소 4 추가 -> [1, 2, 3, 4]
 
    lst.add(2, 5)  // index 2에 5 삽입  -> [1, 2, 5, 3, 4]
 
		// index 3인 요소 삭제               -> [1, 2, 5, 4]
    lst.removeAt(3)
 
	  // 동적 배열의 크기                   -> 4
    val size = lst.size
 
		// index 0인 요소 읽기               -> 1
    val value = lst[0]
}

fn main() {
		// 빈 동적 배열 생성
    let mut vec: Vec<i32> = Vec::new();
 
    vec.push(1);  // 동적 배열에 요소 1 추가 -> [1]
    vec.push(2);  // 동적 배열에 요소 2 추가 -> [1, 2]
    vec.push(3);  // 동적 배열에 요소 3 추가 -> [1, 2, 3]
    vec.push(4);  // 동적 배열에 요소 4 추가 -> [1, 2, 3, 4]
 
		// index 2에 5 삽입                   -> [1, 2, 5, 3, 4]
    vec.insert(2, 5);
 
		// index 3인 요소 삭제                 -> [1, 2, 5, 4]
    vec.remove(3);
 
		// 동적 배열의 크기                     -> 4
    let size = vec.len();
 
		// index 0인 요소 읽기                 -> 1
    let value = vec[0];
}

typedef struct {
		int* ptr;
		int len;
		int cap;
} ArrayList;

arr = [1, 2, 3]

ArrayList new(int cap)
{
		// 실제로 데이터를 저장할 Static Array를 Heap 상에 동적 할당한 뒤,
		// 시작 주소만을 반환하여 포인터에 저장
		int* ptr = malloc(sizeof(int) * cap);
 
		// ArrayList 구조체 생성 및 반환
		ArrayList arr = {
				.ptr = ptr,
				.len = 0,
				.cap = cap,
		};
 
		return arr;
}

void resize(ArrayList* arr)
{
		// cap을 2배로 증가시킴
		arr->cap *= 2;
 
		// cap을 2배로 Heap에 Static Array 재할당
		int* next_ptr = malloc(sizeof(int) * arr->cap);
 
		// 기존 Static Array에 저장된 모든 데이터를 새로운 Static Array에 복사
		memcpy(next_ptr, arr->ptr, arr->len);
 
		// 기존 Static Array 할당 해제
		free(arr->ptr);
 
		// arr->ptr에 새로운 Static Array의 주소 저장
		arr->ptr = next_ptr;
}

void add(ArrayList* arr, int value)
{
		// len이 cap과 같다면 요소를 추가할 공간이 없음
		// resize 함수를 호출하여 용량을 2배 증가시킴
		if (arr->len == arr->cap)
		{
				resize(arr);
		}
 
		// arr->len++은 arr->len으로 평가된 뒤 1 증가함
		// 즉, Static Array의 len번째 메모리 공간에 value를 삽입
		arr->ptr[arr->len++] = value;
}

void insert(ArrayList* arr, int index, int value)
{
		// 삽입하려는 index가 len일 경우, add와 동일
		// 그러나 index가 음수거나 len보다 클 경우는 불가능
		assert(index >= 0 && index <= arr->len);
 
		// len이 cap과 같다면 요소를 추가할 공간이 없음
		// resize 함수를 호출하여 용량을 2배 증가시킴
		if (arr->len == arr->cap)
		{
				resize(arr);
		}
 
		// 위에서 resize를 해주기 때문에 cap은 항상 len보다 크다는 것이 보장됨
		// 고로 last index + 1과 같은 len부터 index + 1까지 순회하며
		// Static Array[i]를 Static Array[i - 1]로 덮어 쓸 수 있음
		for (int i = arr->len; i > index; i--)
		{
				arr->ptr[i] = arr->ptr[i - 1];
		}
 
		// index에는 인자로 받은 새로운 요소를 넣어줄 것이기 때문에 위에서 처리해주지 않았음
		arr->ptr[index] = value;
 
		// 요소가 늘었으므로 len도 증가
		arr->len++;
}

void remove(ArrayList* arr, int index)
{
		// 요소가 반드시 1개 이상 존재해야 하며,
		// 제거하려는 요소의 index는 len보다 작아야 할 것
		assert(arr->len > 0 && index < arr->len);
 
		// index ~ last index - 1까지 반복
		for (int i = index; i < arr->len - 1; i++)
		{
				// i에 위치한 요소를 i + 1에 위치한 요소로 덮어 씀(한 칸씩 당겨줌)
				arr->ptr[i] = arr->ptr[i + 1];
		}
 
		// 요소가 줄었으므로 len도 감소
		arr->len--;
}

for (int i = index; i < arr->len; i++)
{
		// ...
}

arr->ptr[i] = arr->ptr[i + 1];

void drop(ArrayList* arr)
{
		free(arr->ptr);
}

#include <assert.h>
#include <stdlib.h>
#include <string.h>
 
typedef struct {
	int* ptr;
	int len;
	int cap;
} ArrayList;
 
ArrayList new(int cap)
{
	// 실제로 데이터를 저장할 Static Array를 Heap 상에 동적 할당한 뒤,
	// 시작 주소만을 반환하여 포인터에 저장
	int* ptr = malloc(sizeof(int) * cap);
 
	// ArrayList 구조체 생성 및 반환
	ArrayList arr = {
		.ptr = ptr,
		.len = 0,
		.cap = cap,
	};
 
	return arr;
}
 
void resize(ArrayList* arr)
{
	// cap을 2배로 증가시킴
	arr->cap *= 2;
 
	// cap을 2배로 Heap에 Static Array 재할당
	int* next_ptr = malloc(sizeof(int) * arr->cap);
 
	// 기존 Static Array에 저장된 모든 데이터를 새로운 Static Array에 복사
	memcpy(next_ptr, arr->ptr, arr->len);
 
	// 기존 Static Array 할당 해제
	free(arr->ptr);
 
	// arr->ptr에 새로운 Static Array의 주소 저장
	arr->ptr = next_ptr;
}
 
void add(ArrayList* arr, int value)
{
	// len이 cap과 같다면 요소를 추가할 공간이 없음
	// resize 함수를 호출하여 용량을 2배 증가시킴
	if (arr->len == arr->cap)
	{
		resize(arr);
	}
 
	// arr->len++은 arr->len으로 평가된 뒤 1 증가함
	// 즉, Static Array의 len번째 메모리 공간에 value를 삽입
	arr->ptr[arr->len++] = value;
}
 
void insert(ArrayList* arr, int index, int value)
{
	// 삽입하려는 index가 len일 경우, add와 동일
	// 그러나 index가 음수거나 len보다 클 경우는 불가능
	assert(index >= 0 && index <= arr->len);
 
	// len이 cap과 같다면 요소를 추가할 공간이 없음
	// resize 함수를 호출하여 용량을 2배 증가시킴
	if (arr->len == arr->cap)
	{
		resize(arr);
	}
 
	// 위에서 resize를 해주기 때문에 cap은 항상 len보다 크다는 것이 보장됨
	// 고로 last index + 1과 같은 len부터 index + 1까지 순회하며
	// Static Array[i]를 Static Array[i - 1]로 덮어 쓸 수 있음
	for (int i = arr->len; i > index; i--)
	{
		arr->ptr[i] = arr->ptr[i - 1];
	}
 
	// index에는 인자로 받은 새로운 요소를 넣어줄 것이기 때문에 위에서 처리해주지 않았음
	arr->ptr[index] = value;
 
	// 요소가 늘었으므로 len도 증가
	arr->len++;
}
 
void remove(ArrayList* arr, int index)
{
	// 요소가 반드시 1개 이상 존재해야 하며,
	// 제거하려는 요소의 index는 len보다 작아야 할 것
	assert(arr->len > 0 && index < arr->len);
 
	// index ~ last index - 1까지 반복
	for (int i = index; i < arr->len - 1; i++)
	{
		// i에 위치한 요소를 i + 1에 위치한 요소로 덮어 씀(한 칸씩 당겨줌)
		arr->ptr[i] = arr->ptr[i + 1];
	}
 
	// 요소가 줄었으므로 len도 감소
	arr->len--;
}
 
void drop(ArrayList* arr)
{
	free(arr->ptr);
}
 
int main()
{
	ArrayList arr = new(2);
	add(&arr, 1);
	add(&arr, 2);
	insert(&arr, 0, 100);
	remove(&arr, 0);
 
	// error cases
	//
	// insert(&arr, -1, 100);
	// insert(&arr, arr.len + 1, 100);
	// remove(&arr, -1);
	// remove(&arr, arr.len);
 
	drop(&arr);
}