템플릿 (template)

함수 템플릿

함수를 선언하고 생성하기 전에는 타입이 정해지지 않아 함수가 생성되지 않는다.

#include <stdio.h>
#include <iostream>

using namespace std;

template <typename T> // = <class T>
T Add(T a, T b)
{
    return a + b;
}

int main()
{
    // 함수 템플릿 생성 및 사용
    int a = Add<int>(1, 2); // Add(1, 2)
    float b = Add<float>(1.1f, 2.2f);


    return 0;
}

---

클래스 템플릿

템플릿을 분할구현 할 때, 클래스의 정의는 cpp 파일이 아닌 헤더 파일에 존재해야한다.

클래스 템플릿이나 함수 템플릿은 타입의 자료형이 정해지기 전까지 구현되지 않는다.

헤더가 선언된 main.cpp 파일에서 타입의 자료형이 정해지고 직접 구현해야 하기 때문.

 

클래스 템플릿으로 가변배열 만들기

#pragma once
#include <assert.h>

template <typename T>
class CArr
{
private:
    T *pData;
    int count;
    int maxCount;

public:
    void RPush(const T &data);
    void resize(int resizeCount);
    T &operator[](int idx);

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

template <typename T>
CArr<T>::CArr() : pData(nullptr),
                  count(0), maxCount(1)
{
    pData = new T[1];
}

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

template <typename T>
void CArr<T>::RPush(const T &data)
{
    if (this->maxCount <= this->count)
    {
        resize(this->maxCount * 2);
    }
    this->pData[this->count] = data;
    this->count++;
}

template <typename T>
void CArr<T>::resize(int resizeCount)
{
    if (this->maxCount >= resizeCount)
    {
        assert(false);
    }

    T *pNewData = new T[resizeCount];
    for (int i = 0; i < this->count; i++)
    {
        pNewData[i] = this->pData[i];
    }
    delete[] this->pData;

    this->pData = pNewData;
    this->maxCount = resizeCount;
}

template <typename T>
T &CArr<T>::operator[](int idx)
{
    return this->pData[idx];
}

 

클래스 템플릿으로 양방향 연결형 리스트 만들기

// list.h

#pragma once

template <typename T>
struct cListNode
{
    T data;
    cListNode<T> *pPrevNode;
    cListNode *pNextNode; // 템플릿 내부에서 본인을 지칭할 때, T를 생략 가능.

    cListNode() : data(), pPrevNode(nullptr), pNextNode(nullptr)
    {
    }

    cListNode(const T &data, cListNode<T> *_pPrev, cListNode<T> *_pNext)
        : data(data), pPrevNode(_pPrev), pNextNode(_pNext)
    {
    }

    ~cListNode() {}
};

template <typename T>
class CList
{
private:
    cListNode<T> *pHeadNode;
    cListNode<T> *pTailNode;
    int count;

public:
    void RPush(const T &data);
    void LPush(const T &data);

public:
    CList();
    ~CList();
};

template <typename T>
CList<T>::CList() : pHeadNode(nullptr), pTailNode(nullptr), count(0){};

template <typename T>
CList<T>::~CList()
{
    cListNode<T> *pDeleteNode = this->pHeadNode;

    while (pDeleteNode)
    {
        cListNode<T> *_pNext = pDeleteNode->pNextNode;
        delete (pDeleteNode);
        pDeleteNode = _pNext;
    }
};

template <typename T>
void CList<T>::RPush(const T &_data)
{
    cListNode<T> *pNewNode = new cListNode<T>(_data, nullptr, nullptr);

    if (this->pHeadNode == nullptr)
    {
        this->pHeadNode = pNewNode;
    }
    else
    {
        this->pTailNode->pNextNode = pNewNode;
        pNewNode->pPrevNode = this->pTailNode;
    }

    this->pTailNode = pNewNode;
    this->count++;
};

template <typename T>
void CList<T>::LPush(const T &_data)
{
    cListNode<T> *pNewNode = new cListNode<T>(_data, nullptr, this->pHeadNode);

    if (this->pHeadNode != nullptr)
    {
        this->pHeadNode->pPrevNode = pNewNode;
    }

    this->pHeadNode = pNewNode;
    this->count++;
};

// main.cpp

#include <stdio.h>
#include <iostream>
#include "./include/Template/lst.h"

using namespace std;

int main()
{
    CList<int> list;

    list.RPush(1);
    list.RPush(2);
    list.RPush(3);

    return 0;
}