<div id="readability-page-1" class="page"><p><cite>_SYPark</cite>
                                    <span> 2023. 9. 22. 16:19</span>
                                </p><div>
                                <p data-ke-size="size16">이전 포스팅에서 간단히 템플릿에 대해서 설명하였습니다.</p>
<figure id="og_1695362978416" contenteditable="false" data-ke-type="opengraph" data-ke-align="alignCenter" data-og-type="article" data-og-title="[C++] Template(1)" data-og-description="기본적으로 템플릿은 편의성과 확장성을 모두 만족할 수 있는 기법입니다. 예를 들어 매개변수로 전달받은 두 수를 더하는 함수를 만든다고 가정했을 때 매개변수는 정수형이 올 수도 실수형이" data-og-host="1d1cblog.tistory.com" data-og-source-url="https://1d1cblog.tistory.com/505" data-og-url="https://1d1cblog.tistory.com/505" data-og-image="https://scrap.kakaocdn.net/dn/ea7n8S/hyTY8izENI/aduI5KJF1WcQ2YgrV7FUWK/img.jpg?width=316&amp;height=223&amp;face=0_0_316_223,https://scrap.kakaocdn.net/dn/bA6UU7/hyTY2JsN2H/PhETUmeFZQzD9DHEeMfWLk/img.jpg?width=316&amp;height=223&amp;face=0_0_316_223,https://scrap.kakaocdn.net/dn/bj0Qqu/hyTY4AtvRI/ONepCCtLjtQ7SCE9iPvUn1/img.jpg?width=316&amp;height=223&amp;face=0_0_316_223"><a href="https://1d1cblog.tistory.com/505" target="_blank" rel="noopener" data-source-url="https://1d1cblog.tistory.com/505">

<div>
<p data-ke-size="size16">[C++] Template(1)</p>
<p data-ke-size="size16">기본적으로 템플릿은 편의성과 확장성을 모두 만족할 수 있는 기법입니다. 예를 들어 매개변수로 전달받은 두 수를 더하는 함수를 만든다고 가정했을 때 매개변수는 정수형이 올 수도 실수형이</p>
<p data-ke-size="size16">1d1cblog.tistory.com</p>
</div>
</a><img src="https://scrap.kakaocdn.net/dn/ea7n8S/hyTY8izENI/aduI5KJF1WcQ2YgrV7FUWK/img.jpg?width=316&amp;height=223&amp;face=0_0_316_223,https://scrap.kakaocdn.net/dn/bA6UU7/hyTY2JsN2H/PhETUmeFZQzD9DHEeMfWLk/img.jpg?width=316&amp;height=223&amp;face=0_0_316_223,https://scrap.kakaocdn.net/dn/bj0Qqu/hyTY4AtvRI/ONepCCtLjtQ7SCE9iPvUn1/img.jpg?width=316&amp;height=223&amp;face=0_0_316_223"></figure>
<p data-ke-size="size16">우리가 template과 함께 typename 이라는 키워드를 사용하였습니다. 이 typename이라는 키워드는 템플릿 매개변수를 선언할 때 사용합니다. template &lt;typename T&gt; 처럼 사용하는 사람이 있고 template &lt;class T&gt; 로 사용하는 사람이 있는데 똑같이 동작합니다. typename이라는 키워드 자체를 타입이라고 명시를 시켜줄 때 사용할 수도 있습니다.</p>

<p data-ke-size="size16">예를 들어 아래와 같이 코드를 작성했을 때 일반적인 상황에서는 전달받은 컨테이너가 가지고 있는 const_iterator 타입을 포인터 변수로 사용하는 코드가 됩니다. 하지만 만약에 전달받은 타입에 const_iterator라는 정적 변수가 있을 때에는 또 다른 의미를 가지게 됩니다. 그리고 x라는 전역 변수가 어딘가에 있다면 이 구문은 포인터 변수를 선언하는 코드가 아닌 단순 곱하기처럼 동작할 가능성을 지니게 됩니다.</p>
<pre id="code_1695363747662" data-ke-language="cpp" data-ke-type="codeblock"><code>template &lt;typename T&gt;
void print(const T&amp; container)
{
	T::const_iterator * x;
}</code></pre>
<p data-ke-size="size16">그렇기에 이러한 문제를 방지하기 위해 이것은 타입이다 라고 명시할 수 있게 typename 키워드를 앞에 붙여서 사용할 수 있습니다.</p>
<pre id="code_1695363904172" data-ke-language="cpp" data-ke-type="codeblock"><code>template &lt;typename T&gt;
void print(const T&amp; container)
{
	typename T::const_iterator * x;
}</code></pre>
<p data-ke-size="size16">템플릿으로 만들어진 클래스를 상속 받아 클래스를 하나 만들어 보겠습니다. Printer라는 클래스는 Test 변수를 하나 생성해서 printTest 함수를 호출합니다. 근데 이 Printer&lt;T&gt;를 상속받아 LogPrinter라는 클래스를 하나 더 만들고 이 안에서 print 함수를 호출하도록 하였습니다. 하지만 이대로 컴파일 시 에러가 나게 됩니다.</p>
<pre id="code_1695364739349" data-ke-language="cpp" data-ke-type="codeblock"><code>#include &lt;iostream&gt;

class Test {
public:
  void printTest() { std::cout &lt;&lt; "Test"; }
};

template &lt;typename T&gt;
class Printer {
public:
  void print() {
    T t;
    t.printTest();
  }
};

template &lt;typename T&gt;
class LogPrinter : public Printer&lt;T&gt; {
public:  
  void lprint() {
    print();
  }
};

int main()
{
  LogPrinter&lt;Test&gt; lp;
  lp.lprint();
}</code></pre>
<p data-ke-size="size16">이 print라는 함수를 컴파일 단계에서는 기본 클래스를 명확히 할 수 없기 때문에 컴파일 할 수가 없습니다. 기본 클래스가 전달받은 타입에 따라 print라는 함수가 없을 수도 있기 때문입니다. 이러한 에러를 해결하기 위해서는 아래 방법을 사용할 수 있습니다.</p>
<pre id="code_1695365506173" data-ke-language="cpp" data-ke-type="codeblock"><code>// this 사용
template &lt;typename T&gt;
class LogPrinter : public Printer&lt;T&gt; {
public:  
  void lprint() {
    this-&gt;print();
  }
};

// using을 통해 기본 클래스에 함수가 있음을 알려줌
template &lt;typename T&gt;
class LogPrinter : public Printer&lt;T&gt; {
public:
  using Printer&lt;T&gt;::print;
  void lprint() {
    print();
  }
};

// 명시적으로 기본 클래스의 함수 호출
template &lt;typename T&gt;
class LogPrinter : public Printer&lt;T&gt; {
public:  
  void lprint() {
    Printer&lt;T&gt;::print();
  }
};</code></pre>
<p data-ke-size="size16">이렇게 템플릿을 사용하면 코드의 수를 줄일 수 있을 뿐 아니라 유지보수 및 기타 부분에 대해서 장점을 지니게 됩니다. 하지만 이런 템플릿도 잘못된 방법으로 사용할 경우 쓸데없이 코드가 비대해질 수 있습니다. 아래 코드로 예를 들어보겠습니다.</p>

<p data-ke-size="size16">아래와 같이 타입과 크기를 전달받는 클래스가 있을 때 아래와 같이 사용한다면 Array&lt;int, 10&gt;::invert와 Array&lt;int, 20&gt;::invert에 대한 인스턴스화 되게 됩니다.&nbsp;</p>
<pre id="code_1695366643819" data-ke-language="cpp" data-ke-type="codeblock"><code>template &lt;typename T, int size&gt;
class Array {
public:
    void invert();
};

int main()
{
    Array&lt;int, 10&gt; AInt10;
    Array&lt;int, 20&gt; AInt20;
    
    AInt10.invert();
    AInt20.invert();
}</code></pre>
<p data-ke-size="size16">이러한 중복을 막기 위해서는 굳이 사이즈 값은 템플릿으로 받지 않고 멤버 함수의 매개변수로 받아 처리할 수도 있습니다.</p>
<pre id="code_1695366930803" data-ke-language="cpp" data-ke-type="codeblock"><code>template &lt;typename T&gt;
class Array {
public:
    void invert(int nSize);
};

int main()
{
    Array&lt;int&gt; AInt10;
    Array&lt;int&gt; AInt20;
    
    AInt10.invert(10);
    AInt20.invert(20);
}</code></pre>
            
            
                </div></div>

1D1C

이전 포스팅에서 간단히 템플릿에 대해서 설명하였습니다.
우리가 template과 함께 typename 이라는 키워드를 사용하였습니다. 이 typename이라는 키워드는 템플릿 매개변수를 선언할 때 사용합니다. template <typename T> 처럼 사용하는 사람이 있고 template <class T> 로 사용하는 사람이 있는데 똑같이 동작합니다. typename이라는 키워드 자체를 타입이라고 명시를 시켜줄 때 사용할 수도 있습니다.
 
예를 들어 아래와 같이 코드를 작성했을 때 일반적인 상황에서는 전달받은 컨테이너가 가지고 있는 const_iterator 타입을 포인터 변수로 사용하는 코드가 됩니다. 하지만 만약에 전달받은 타입에 const_iterator라는 정적 변수가 있을 때에는 또 다른 의미를 가지게 됩니다. 그리고 x라는 전역 변수가 어딘가에 있다면 이 구문은 포인터 변수를 선언하는 코드가 아닌 단순 곱하기처럼 동작할 가능성을 지니게 됩니다.
template <typename T>
void print(const T& container)
{
	T::const_iterator * x;
}
그렇기에 이러한 문제를 방지하기 위해 이것은 타입이다 라고 명시할 수 있게 typename 키워드를 앞에 붙여서 사용할 수 있습니다.
template <typename T>
void print(const T& container)
{
	typename T::const_iterator * x;
}
템플릿으로 만들어진 클래스를 상속 받아 클래스를 하나 만들어 보겠습니다. Printer라는 클래스는 Test 변수를 하나 생성해서 printTest 함수를 호출합니다. 근데 이 Printer<T>를 상속받아 LogPrinter라는 클래스를 하나 더 만들고 이 안에서 print 함수를 호출하도록 하였습니다. 하지만 이대로 컴파일 시 에러가 나게 됩니다.
#include <iostream>
class Test {
public:
  void printTest() { std::cout << "Test"; }
};
template <typename T>
class Printer {
public:
  void print() {
    T t;
    t.printTest();
  }
};
template <typename T>
class LogPrinter : public Printer<T> {
public:  
  void lprint() {
    print();
  }
};
int main()
{
  LogPrinter<Test> lp;
  lp.lprint();
}
이 print라는 함수를 컴파일 단계에서는 기본 클래스를 명확히 할 수 없기 때문에 컴파일 할 수가 없습니다. 기본 클래스가 전달받은 타입에 따라 print라는 함수가 없을 수도 있기 때문입니다. 이러한 에러를 해결하기 위해서는 아래 방법을 사용할 수 있습니다.
// this 사용
template <typename T>
class LogPrinter : public Printer<T> {
public:  
  void lprint() {
    this->print();
  }
};
// using을 통해 기본 클래스에 함수가 있음을 알려줌
template <typename T>
class LogPrinter : public Printer<T> {
public:
  using Printer<T>::print;
  void lprint() {
    print();
  }
};
// 명시적으로 기본 클래스의 함수 호출
template <typename T>
class LogPrinter : public Printer<T> {
public:  
  void lprint() {
    Printer<T>::print();
  }
};
이렇게 템플릿을 사용하면 코드의 수를 줄일 수 있을 뿐 아니라 유지보수 및 기타 부분에 대해서 장점을 지니게 됩니다. 하지만 이런 템플릿도 잘못된 방법으로 사용할 경우 쓸데없이 코드가 비대해질 수 있습니다. 아래 코드로 예를 들어보겠습니다.
 
아래와 같이 타입과 크기를 전달받는 클래스가 있을 때 아래와 같이 사용한다면 Array<int, 10>::invert와 Array<int, 20>::invert에 대한 인스턴스화 되게 됩니다. 
template <typename T, int size>
class Array {
public:
    void invert();
};
int main()
{
    Array<int, 10> AInt10;
    Array<int, 20> AInt20;
    
    AInt10.invert();
    AInt20.invert();
}
이러한 중복을 막기 위해서는 굳이 사이즈 값은 템플릿으로 받지 않고 멤버 함수의 매개변수로 받아 처리할 수도 있습니다.
template <typename T>
class Array {
public:
    void invert(int nSize);
};
int main()
{
    Array<int> AInt10;
    Array<int> AInt20;
    
    AInt10.invert(10);
    AInt20.invert(20);
}

[C++] Template(2)

댓글