C,C++ 클래스 템플릿

 

https://youtu.be/LfFQ0ezVuZM

 

main.cpp

#include <iostream>

#include "Arr.h"
#include "CArr.h"

class CTest // 기본 private:
{
private://비공개
	int a;

public://공개
	CTest()
		:a(10)
	{

	}
public://공개

};

int main()
{
	{
		CTest* pTest = new CTest;
		delete pTest;

		tArr arr = {};
		InitArr(&arr);

		PushBack(&arr, 10);
		PushBack(&arr, 20);
		PushBack(&arr, 30);

		ReleaseArr(&arr);


		CArr<int> carr;
		carr.push_back(10);
		carr.push_back(20);
		carr.push_back(30);


		CArr<float> carr1;
		carr1.push_back(10.1232);
		carr1.push_back(22.310);
		carr1.push_back(32.3330);

		float iData = carr1[2];
		printf("%0.2f", iData);
	}

	return 0;
 }

 

CArr.h

#pragma once

#include <assert.h>

template<typename T>
class CArr
{
private:
	T*		m_pData;
	int		m_iCount;
	int		m_iMaxCount;

public:
	void push_back(const T& _Data);
	void resize(int _iResizeCount);

	T& operator[](int idx);

public:
	CArr();
	~CArr();
};

template<typename T>
void CArr<T>::push_back(const T& _Data)
{
	int i = 0;

	// 힙 영역에 할당한 공간이 다 참 확인
	if (m_iMaxCount <= m_iCount)
	{
		//재할당
		resize(_Data);
	}

	// 데이터 추가
	m_pData[m_iCount++] = _Data;
}

template<typename T>
void CArr<T>::resize(int _iResizeCount)
{
	// 현재 최대 수용량 보다 더 적은 수치로 확정하려는 경우
	if (m_iMaxCount >= _iResizeCount)
	{
		assert(nullptr);
	}


	//1. 리사이즈 시킬 개수만큼 동적할당 한다
	T* pNew = new T[_iResizeCount];

	//2. 기존 공간에 있던 데이터들을 새로 할당한 공간으로 복사시킨다.
	for (int i = 0; i < m_iCount; ++i)
	{
		pNew[i] = m_pData[i];
	}
	//3. 기존 공간은 메모리 해제
	delete[] m_pData;

	//4. 배열이 새로 할당된 공간을 가리키게 하다.
	m_pData = pNew;

	//5. MaxCount 변경점 적용
	m_iMaxCount = _iResizeCount;
}
template<typename T>
T& CArr<T>::operator[](int idx)
{
	return m_pData[idx];
}

template<typename T>
CArr<T>::CArr()
	:m_pData(nullptr)
	, m_iCount(0)
	, m_iMaxCount(2)
{
	m_pData = new T[2];
}

template<typename T>
CArr<T>::~CArr()
{
	delete[] m_pData;

}

 

Arr.h

#pragma once

//ints
typedef struct _tagArr
{
	int*		pInt; // 포인터
	int			iCount; // 카운터
	int			iMaxCount; // 최대 카운터
}tArr;

// 배열 초기화 함수
void InitArr(tArr* _pArr);

//데이터 추가 함수
void PushBack(tArr* _pArr, int _iData);

//공간 추가 확장
void Reallocate(tArr* _pArr);

//배열 메모리 해제 함수
void ReleaseArr(tArr* _pArr);

//데이터 정렬 함수
void Sort(tArr* _pArr,void(*SortFunc)(int*, int));

 

Arr.cpp

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

//초기화
void InitArr(tArr* _pArr)
{
	_pArr->pInt = (int*)malloc(sizeof(int) * 2);
	//(*_pArr).iCount = 0;
	_pArr->iCount = 0;
	_pArr->iMaxCount = 2;
}

void Reallocate(tArr* _pArr)
{
	//1. 2배 더 큰 공간을 동적할당한다.
	int* pNew = (int*)malloc(_pArr->iMaxCount * 2 * sizeof(int));

	//2. 기존 공간에 있던 데이터들을 새로 할당한 공간으로 복사시킨다.
	for (int i = 0; i < _pArr->iCount; ++i)
	{
		pNew[i] = _pArr->pInt[i];
	}
	//3. 기존 공간은 메모리 해제
	free(_pArr->pInt);

	//4. 배열이 새로 할당된 공간을 가리키게 하다.
	_pArr->pInt = pNew;

	//5. MaxCount 변경점 적용
	_pArr->iMaxCount *= 2;
	
}

void PushBack(tArr* _pArr, int _iData)
{
	// 힙 영역에 할당한 공간이 다 참 확인
	if (_pArr->iMaxCount <= _pArr->iCount)
	{
		//재할당
		Reallocate(_pArr);
	}

	// 데이터 추가
	_pArr->pInt[_pArr->iCount++] = _iData;
	
}

// 힙 영역 할당 제거
void ReleaseArr(tArr* _pArr)
{
	free(_pArr->pInt);
	_pArr->iCount = 0;
	_pArr->iMaxCount = 0;
}

void Sort(tArr* _pArr, void(*SortFunc)(int*, int))
{
	_pArr;
	SortFunc(_pArr->pInt, _pArr->iCount);

}