C++ 클래스 템플릿

클래스 템플릿을 이용한 가변배열 만들어보기

클래스 마다 template<typename T>을 써줘야함

템플릿을 이용한 클래스는 자료형이 무엇인지 모르기에 헤더 파일에다가 전부 구현해야함

 

CArr.h

#pragma once
#include <assert.h>
#include <iostream>
using namespace std;
template<typename T>
class CArr
{
private:
    T* pint;
    int count;
    int maxcount;
public:
    void PushBack(const T& Data); // 
    void resize(int ResizeCount);
    void Sort();
    
    T& operator[] (int idx); // operator를 써줘야함
    
 
public:
    CArr();
    ~CArr();
};
 
template<typename T>
CArr<T>::CArr()  // T자료형안에 선언되있는 클래스 <T>를 지정해줘야함
// 클래스 선언 범위 밖에서 지정했기때문에 CArr클래에 지정되어있는 생성자라는 뜻
    //이니셜라이저로 초기화
    : pint(nullptr)
    , count(0)
    , maxcount(2)
{
    pint = new T[2]; // new 새로운 C++동적활당 malloc 이랑 같음 
    // int2개만큼 할당
 
}
template<typename T>
CArr<T>::~CArr()
{
    //delete 동적할당 해제 free랑 같음
    for (int i = 0; i < count; i++)
    {
        cout << pint[i] << endl;
    }
    delete[] pint; // 위에 인트 자료형을 여러게 선언했기 떄문에 []붙여줌 하나만 선언할시 []안붙여도 된다.
    count = 0;
    maxcount = 0;
 
}
template<typename T>
void CArr<T>::PushBack(const T& Data)
{
    if (this->maxcount <= this->count)
    {
        resize(maxcount * 2);
    }
 
    pint[this->count++] = Data;
}
template<typename T>
void CArr<T>::resize(int ResizeCount)
{
    //현재 최대 수용량 보다 더 적은 수치로 확장하려는 경우
    if (maxcount >= ResizeCount)
    {
        assert(nullptr);
    }
 
    // 1. 리사이즈 시킬 개수만큼 동적할당 한다.
    T* pnew = new T[ResizeCount];
 
    // 2 기존 공간에 있던 데이터들을 새로 할당한 공간으로 복사시킨다.
    for (int i = 0; i < this->count; i++)
    {
        pnew[i] = this->pint[i];
    }
 
    // 3. 기존 공간은 메모리 해제
    delete[] pint;
 
    // 4. 배열이 새로 할당된 공간을 가리키게 한다.
    this->pint = pnew;
 
    //5 . maxcoyunt 변경점 적용
    this->maxcount = ResizeCount;
 
}
template<typename T>
void CArr<T>::Sort()
{
 
    while (1)
    {
        if (count < 1)
        {
            break;
        }
        bool finsih = true;
        for (int i = 0; i < count - 1; i++) {
            if (pint[i] > pint[i + 1])
            {
                int re = pint[i];
                pint[i] = pint[i + 1];
                pint[i + 1] = re;
                finsih = false;
            }
        }
        if (finsih == true)
        {
            break;
        }
    }
}
 
 
 
template<typename T>
T& CArr<T>::operator[](int idx)
{
    return pint[idx];
}
 

 

main.cpp

#include<iostream>
#include "test.h"
#include<time.h>
#include "list.h"
#include "b.h"
#include "CArr.h"
#include "CList.h"
using namespace std;
 
int main()
{
    CArr<float> s; //선언 방법
    s.PushBack(3.14);
    s.PushBack(5);
 
 
    
 
 
    return 0;
}

 

클래스 템플릿을 이용한 리스트

CList.h

#include<iostream>
using namespace std;
 
template<typename T>
class Node
{
public:
    T     Data;  
    Node* Prev;// 이전노드
    Node<T>* NextNode;; // 본인 선언 내부에 있을시 <T>생략 가능
public:
    Node(const T& Data, Node* Prev, Node<T>* NextNode)
        :Data(Data)
        ,Prev(Prev)
        ,NextNode(NextNode)
    {
 
    }
};
 
template<typename T>
class CList
{
private:
    Node<T>* HeadNode; //포인터가 가르키는 자료형이 무엇인지 알려주는 <T>가 있어야함
    Node<T>* TailNode; // 꼬리 맨마지막 노드
    int  count;
public:
    void PushBack(const T& Data);
    void PushFornt(const T& Data);
public:
    CList();
    ~CList();
};
 
template<typename T>
 void CList<T>::PushBack(const T & Data)
{
     //입력된 데이터를 저장할 노드를 동적할당 함
     Node<T>* NewNode = new Node<T>(Data, TailNode,nullptr);
     if (count == 0)
     {
         HeadNode = NewNode;
 
         TailNode = NewNode; //데이터가 하나일시 처음과 마지막데이터가 같음
     }
     else 
     {
         //데이터가 1개 이상에서 입력된 경우
         //현재 가장 마지막 데이터(tail)를 저장하고 있는 노드가
         //새로 생성된 노드를 서로 가리키게 한다.
         TailNode->NextNode = NewNode;
        // NewNode->Prev = TailNode; 위에 선언에 있음
         
         //List 가 마지막 노드의 주소값을 새로 입력된 노드로 갱신한ㄷ.
         TailNode = NewNode;
     }
     count++;
}
 
 template<typename T>
  void CList<T>::PushFornt(const T & Data)
 {
      //새로 생성된 노도의 다음을 현재 헤드노드의 주소값으로 채움
      Node<T>* pNewNode = new Node<T>(Data,nullptr,HeadNode);
      if (count == 0) {
          HeadNode = pNewNode;
          TailNode = pNewNode;
      }
      else {
         //현재 헤드노드의 이전노드 주소값을 새로 생선된 노드의 주소로 채움
          HeadNode->Prev = pNewNode;
        
          // 위에 선언에 있음
        //  pNewNode->NextNode = HeadNode; 
 
          //리스트가 새로 생성된 노드의 주소를 새로운 헤드주소로 갱신한다.
          HeadNode = pNewNode;
 
      }
      count++;
      
 }
 
template<typename T>
 CList<T>::CList()
    :HeadNode(nullptr)
    ,TailNode(nullptr)
    ,count(0) 
{
}
 
template<typename T>
 CList<T>::~CList()
{
     Node<T>* DeletNode = HeadNode;
 
     for (int i = 0; i < count; i++)
     {
         cout << HeadNode->Data<<"\n";
         HeadNode = HeadNode->NextNode;
     }
    
     while (DeletNode)
     {
         Node<T>* pNext = DeletNode->NextNode;
         delete(DeletNode);
         DeletNode = pNext;
     }
    
    
    
 }
 
 

main.cpp

#include<iostream>
#include "test.h"
#include<time.h>
#include "list.h"
#include "b.h"
#include "CArr.h"
#include "CList.h"
using namespace std;
int main()
{
    CList<int> s;
    for (int i = 0; i < 4; i++)
    {
        s.PushFornt(i);
    }
      return 0;
}
 
 
 

 

 

 

출처 : https://www.youtube.com/c/AssortRockGameAcademy