배열을 이용한 c언어 코드

ArrayList.h

#ifndef __ARRAY_LIST_H__
#define __ARRAY_LIST_H__

#define LIST_LEN    100    // 배열의 최대 크기
#define TRUE    1
#define FALSE   0

typedef int LData;

typedef struct __ArayList
{
    LData arr[LIST_LEN]; // 리스트의 저장소인 배열
    int numOfData;       // 리스트의 갯수를 반환해 주기 위한 변수
    int curPosition;     // 데이터를 참조 하기 위한 현재 위치 변수
} ArrayList;

typedef ArrayList List;

void ListInit(List *plist);
void LInsert(List *plist, LData data);

int LFirst(List *plist);
int LNext(List *plist);

LData LRemove(List *plist);
int LCount(List *plist);

#endif

ArrayList.c

#include <stdio.h>
#include "ArrayList.h"

void ListInit(List *plist)
{
    plist->numOfData = 0;
    // 초기화시 -1을 가르키며, 추가 시에 1씩 증가 시킨다.
    plist->curPosition = -1;
}
void LInsert(List *plist, LData data)
{
		// 최대 크기를 넘어가면 실행되지 않는다.
    if (plist->numOfData > LIST_LEN)
        return ;
    plist->arr[plist->numOfData] = data;
    (plist->numOfData)++;
}

int LFirst(List *plist, LData *pdata)
{
    if (plist->numOfData == 0)
        return ;
    (plist->curPosition) = 0;
		// 현재 위치의 값을 매개변수에 들어온 주솟 값을 이용해서 넣는다.
    *pdata = plist->arr[plist->curPosition];
    return 1;
}

int LNext(List *plist, LData *pdata)
{
		// 현재 위치가 데이터의 수를 넘어갔을 경우. 즉 빈공간을 가르킬 경우
    if (plist->curPosition >= plist->numOfData)
        return 0;
    (plist->curPosition)++;
    *pdata = plist->arr[plist->curPosition];
    (plist->numOfData)++;
    return 1;
}

LData LRemove(List *plist)
{
    int rpos = plist->curPosition;
    int rdata = plist->arr[plist->curPosition];

		// 지운 뒤 삽입 하는 것이 아닌 앞으로 당기면서 값을 새로 넣어준다.
    for (int i = rpos; i < plist->numOfData; i++)
        plist->arr[i] = plist->arr[i + 1];
    (plist->numOfData)--;
    // 배열의 원소가 지워진후 앞으로 당겨졌기 때문에
    // curposition의 값을 내려주지 않으면
    // 아직 참조 되지 않을 값을 가르킨다.
    (plist->curPosition)--;
    return rdata;
}
int LCount(List *plist)
{
    return plist->numOfData;
}

배열을 이용한c++코드

ArrayList.h

#ifndef __ARRAY_LIST_CPP_H__
#define __ARRAY_LIST_CPP_H__

#define LIST_LEN    100

typedef int LData;

class ArrayList
{
private:
    int numOfData;
    int curPosition;
    int arr[LIST_LEN];
public:
    void ListInit();
    void LInsert(LData data);

    int LFirst(LData *pdata);
    int LNext(LData *pdata);

    LData LRemove();
    int LCount();
};

#endif

ArrayList.cpp

#include <iostream>
#include "ArrayListCPP.h"

void ArrayList::ListInit()
{
    numOfData = 0;
    curPosition = -1;
}

void ArrayList::LInsert(LData data)
{
    arr[numOfData] = data;
    numOfData++;
}

int ArrayList::LFirst(LData *pdata)
{
    if (numOfData == 0)
        return 0;
    curPosition = 0;
    *pdata = arr[curPosition];
    return 1;
}
int ArrayList::LNext(LData *pdata)
{
    ++curPosition;
    if (curPosition >= numOfData)
        return 0;
    *pdata = arr[curPosition];
    return 1;
}

LData ArrayList::LRemove()
{
    int rData = arr[curPosition];
    int rPos = curPosition;

    for (int i = rPos; i < numOfData; i++)
        arr[i] = arr[i + 1];
    numOfData--;
    curPosition--;
    return rData;
}

int ArrayList::LCount()
{
    return numOfData;
};

ArrayList.cpp with template

#ifndef __ARRAY_LIST_CPP_H__
#define __ARRAY_LIST_CPP_H__

#define LIST_LEN    100

template <typename T>
class ArrayList
{
private:
    int numOfData;
    int curPosition;
    T arr[LIST_LEN];
public:
    void ListInit();
    void LInsert(T data);

    int LFirst(T *pdata);
    int LNext(T *pdata);

    T LRemove();
    int LCount();
};

template <typename T>
void ArrayList<T>::ListInit()
{
    numOfData = 0;
    curPosition = -1;
}

template <typename T>
void ArrayList<T>::LInsert(T data)
{
    arr[numOfData] = data;
    numOfData++;
}

template <typename T>
int ArrayList<T>::LFirst(T *pdata)
{
    if (numOfData == 0)
        return 0;
    curPosition = 0;
    *pdata = arr[curPosition];
    return 1;
}
template <typename T>
int ArrayList<T>::LNext(T *pdata)
{
    ++curPosition;
    if (curPosition >= numOfData)
        return 0;
    *pdata = arr[curPosition];
    return 1;
}
template <typename T>
T ArrayList<T>::LRemove()
{
    int rData = arr[curPosition];
    int rPos = curPosition;

    for (int i = rPos; i < numOfData; i++)
        arr[i] = arr[i + 1];
    numOfData--;
    curPosition--;
    return rData;
}

template <typename T>
int ArrayList<T>::LCount()
{
    return numOfData;
};

#endif