인프런 커뮤니티 질문&답변

안녕하세요, 질문&답변 도우미 durams입니다.

템플릿 함수의 선언과 정의 분리 시

1

instantiation 시점과 링킹에 대해 오해가 있으신 것 같습니다.

템플릿의 instantiation은 컴파일 타임의 후반부에 일어납니다. 컴파일러가 구문을 분석하다가 특정 템플릿을 사용하는 부분을 발견하면 그때 요구하는 타입으로 instantiation이 수행되죠. 그러니 번역(compilation)이 끝난 시점에는 이미 instantiation도 완료되어 있습니다.

• 전처리시점, 코드 작성 시점에는 템플릿을 해당 타입의 instantiation 을 할 예정인 명령어로 번역한다. : 컴파일 시점을 코드 작성 시점으로 잘못 쓰신것이 아닌가 싶습니다. 그리고 전처리는 컴파일 이전에 #include, #define 등과 같은 전처리 지시문을 처리하는 과정이며 번역이 일어나지 않습니다.

• 해당 번역단위 입장에서는 인스턴스화 타입의 구현 정보가 존재하지않아 링커에 의한 오류가 생긴다.는 맞는 말이지만, 링커에 instantiation이 이루어질때 .cpp파일의 구현부 번역이 일어나는데는 틀린 말입니다. 링커는 따로 번역을 진행하지 않습니다. 링커는 여러 translation unit 간의 심볼 정보를 연관짓고, object file들을 합쳐서 executable file을 만드는 역할입니다.

화살표 이하의 내용은 맞습니다. 여러 헤더 파일에서 특수화된 구현을 include 하게되면 ODR(One Definition Rule) 위반이 일어나기 때문에, 방지하기 위해서 inline으로 명시할 수 있습니다.

2

여러번 읽고 제 나름대로 해석해서 예제를 구성해봤습니다. 아마 이러한 상황을 말씀하시는 것 같습니다.

// test.h

#include <iostream>

template<typename T>

class Test {
public:
	T val;
	void print();
};

// test.cpp

#include "test.h"

template<typename T>

inline void Test<T>::print() {

	std::cout << val << '\n';

}

template<>

inline void Test<char>::print() {
	std::cout << "char : " << val << '\n';
}

template<>

inline void Test<int>::print() {
	std::cout << "int : " << val << '\n';
}

// main.cpp

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

using namespace std;

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    Test<int> x;
    x.val = 3;
    x.print();

    Test<char> y;
    y.val = 'D';
    y.print();

    return 0;
}

헤더파일에서 정의부가 함께있는 함수는 컴파일러가 instantiation할때 타입별 template instance가 생기지만 구현부가 cpp에 있을경우 explicit instantiation 없이는 해당 타입의 instance정보가 없어 해당 함수 사용시 오류가 발생한다.라는 말은 위 상황에서 링킹 에러가 발생한다는 말씀이신 것 같습니다.

조금 더 복잡한 개념인데요, 이건 사실 상황에 따라 다릅니다. 해당 타입의 instance정보가 없어 해당 함수 사용시 오류가 발생한다.에서 instance 정보가 없다는게 링킹 시점에서 템플릿 정의를 다른 translation unit에서 알 수 없다는 뜻인것 같은데, 실제로는 그리 간단하지는 않습니다.

템플릿 특수화 시, 해당 함수는 컴파일러에게 일반 함수처럼 취급되며, 컴파일 타임에 instantiation을 하는 것이 아니라 링킹 시점에 전체 translation unit에서 정의를 찾게 됩니다. 그런데 함수를 inline으로 명시하면 해당 함수를 사용하는 translation unit 안에서는 인라인 함수의 정의가 반드시 들어 있어야만 합니다. 그래서 test.cpp에서 특수화 시 inline으로 명시하였지만, 이는 main.cpp와 다른 translation unit에서 볼 수 없게 되고 링킹 에러가 발생합니다.

The definition of an inline function or variable(since C++17) must be reachable in the translation unit where it is accessed (not necessarily before the point of access).

https://en.cppreference.com/w/cpp/language/inline

해결하는 방법은 2가지가 있습니다.

첫 번째는 inline을 없애는겁니다.

#include "test.h"

template<typename T>
inline void Test<T>::print() {
	std::cout << val << '\n';
}

template<>
void Test<char>::print() {
	std::cout << "char : " << val << '\n';
}

template<>
void Test<int>::print() {
	std::cout << "int : " << val << '\n';
}

위에서 설명드렸듯이, 템플릿 특수화를 진행한 경우 링킹 시점에 정의를 찾아가게 되므로 문제가 없습니다.

제가 특수화하지 않은 기본 print()는 inline을 그대로 뒀는데, 만약 main.cpp에서 Test<double> 타입 클래스를 생성해서 print()를 호출한다면 당연히 에러가 발생하게 됩니다. 특수화 여부와 상관없이 함수의 정의 자체를 main.cpp의 translation unit에서 보지 못하기 때문입니다.

애초에 inline 자체가 헤더 파일을 여러 translation unit에서 포함했을 때의 ODR 위반을 방지하기 위한 것이라 .cpp 파일에서 쓰기에는 적절하지 않으며, 필요하지도 않습니다.

정리하자면 아래와 같습니다.

'템플릿 특수화는 컴파일 타임에 instantiation이 일어나지 않고 명시된 정의를 사용하므로, 일반 함수처럼 .cpp 파일에 정의를 둘 수 있다. 만약 헤더 파일에 정의를 두는 경우, ODR 위반 방지를 위해 inline을 추가적으로 명시해야 한다.'

템플릿 특수화 정의는 기본적으로 inline 속성이 붙어있지 않기 때문에 .cpp 파일에 작성하는 것도 매끄럽다고 생각합니다. (클래스 내부의 함수가 암시적으로 inline 속성을 가진 것과는 대조적입니다)

두 번째는 explicit instantiation을 해주는겁니다.

#include "test.h"

template<typename T>
void Test<T>::print() {
	std::cout << val << '\n';
}

template<>
inline void Test<char>::print() {
	std::cout << "char : " << val << '\n';
}

template void Test<char>::print();

template<>
inline void Test<int>::print() {
	std::cout << "int : " << val << '\n';
}

template void Test<int>::print();

이렇게 한 경우에도 실행이 됩니다. inline으로 설정했지만, explicit instantiation으로 명시적으로 함수의 정의를 object file에 포함시켜서 링킹 시점에 main.cpp에서 알 수 있게 하는 것으로 보입니다.

inline으로 정의한 템플릿 특수화 이후 explicit instantiation을 했을 때 어떠한 일이 발생하는지는 저도 확실히 아는 사항이 아니었기 때문에, 깊게 생각해보았습니다.

1. 일반적인 템플릿 함수는 해당 translation unit에서 사용하는 것이 아니라면 instantiation되지 않는다. 대신 explicit instantiation을 해주게 되면 다른 translation unit에서 링킹 시점에 정의를 찾을 수 있게 된다.

2. 하지만 위 예시는 일반적인 경우가 아니라 템플릿 특수화에 해당한다. 특수화는 instantiation과는 달리 해당 함수의 정의 자체를 object file에 포함시키는 효과를 지닌다.

3. 하지만 inline 특수화만 있을 때에는 오히려 링킹 에러가 발생하고, 추가로 explicit instantiation을 해주면 에러가 사라진다. 그렇다면 inline 특수화 정의는 object file에 함수의 정의를 포함시키지 않을 수도 있는 것으로 보인다.

잠정적인 결론으로, explicit instantiation을 함으로써 이전에 inline으로 특수화가 되었다 하더라도 링킹 시 다른 translation unit에서 찾을 수 있게 되었다는 생각이 들긴 했지만, 여러 자료를 찾아봐도 관련된 사례를 찾을 수가 없어서 증명은 하지 못한 상태입니다. inline 키워드의 목적과도 아예 다른 코드이기 때문에 상당히 적절하지 않은 형태라고도 생각합니다. C++ 표준을 더 찾아보고 보충할 내용이 있다면 추가로 답변드리겠습니다.

추가로 궁금하실까 싶어 아래 형태에 대해서도 말씀드립니다.

#include "test.h"

template<typename T>
void Test<T>::print() {
	std::cout << val << '\n';
}

template<>
void Test<char>::print() {
	std::cout << "char : " << val << '\n';
}

template void Test<char>::print();

template<>
void Test<int>::print() {
	std::cout << "int : " << val << '\n';
}

template void Test<int>::print();

이 형태도 실행은 됩니다만, 여기서는 explicit instantiation이 오히려 필요가 없습니다.

Explicit instantiation has no effect if an explicit specialization appeared before for the same set of template arguments.

https://en.cppreference.com/w/cpp/language/class_template

3

죄송하지만 이 부분은 제가 글을 이해할 수가 없네요. 대신 2번 섹션과 비슷한 내용으로 생각되는데, 아마 앞에서 충분히 설명이 되었을 것이라고 생각합니다.

템플릿과 friend

1

맞습니다.

2

맞습니다. friend로 템플릿 클래스 내에 함수를 선언했더라도, 해당 함수 자체는 클래스의 멤버도 아니고 템플릿 함수도 아니죠. 대신 템플릿 클래스가 instantiation될 때 주어진 타입에 따라 생성될 뿐입니다.

그렇기 때문에 클래스 템플릿 내부에 함수의 정의를 하지 않는다면, instantiation 시 해당 템플릿 인자에 맞는 friend 함수의 정의가 생성되지 않습니다. 그 결과로 아래 코드의 경우 링킹 에러가 발생하게 됩니다.

#include <iostream>

template<typename T>
class Test {
public:
	T val;

	void print();

	friend std::ostream& operator<<(std::ostream& out, const Test& test);
};

template<typename T>
std::ostream& operator<<(std::ostream& out, const Test<T>& test) {
	out << test.val;
	return out;
}

말씀하신 문제의 해결 방법으로는 첫 번째로 friend 함수의 정의까지 템플릿 클래스 내부에 작성하는 방법이 있겠습니다. 추천되는 방식이라고 생각합니다.

#include <iostream>

template<typename T>
class Test {
public:
	T val;

	void print();

	friend std::ostream& operator<<(std::ostream& out, const Test& test) {
		out << test.val;
		return out;
	}
};

또는 말씀하신 방법을 사용할 수 있습니다만, 사실 아래 코드에는 문제가 있습니다.

#include <iostream>

template<typename T>
class Test {
public:
	T val;

	void print();

	template<typename T>
	friend std::ostream& operator<<(std::ostream& out, const Test& test);
};

template<typename T>
std::ostream& operator<<(std::ostream& out, const Test<T>& test) {
	out << test.val;
	return out;
}

T라는 template parameter를 중복으로 선언했기 때문에, 그 parameter간에 shadowing이 발생하게 됩니다.

The name of a template parameter shall not be bound to any following declaration whose locus is contained by the scope to which the template parameter belongs.

C++ working draft 13.8.2/6

위 코드는 어째선지 MSVC에서는 에러가 발생하지 않고 그대로 컴파일이 가능하지만, 동일한 코드를 g++ 로 컴파일해보면 아래와 같이 에러가 발생합니다.

그래서 권장하지 않습니다. 예제와 같은 간단한 프로그램의 경우에는 눈에 보이는 문제가 발생하지 않을수도 있지만, 프로그램 규모가 커지게 되면 lookup 과정에서 예상치 못한 에러가 발생할겁니다.

대신 아래와 같이 함수/연산자 자체를 템플릿화해도 해결이 가능합니다.

#include <iostream>

template<typename T>
class Test;

template<typename T>
std::ostream& operator<<(std::ostream& out, const Test<T>& test);

template<typename T>
class Test {
public:
	T val;

	void print();

	friend std::ostream& operator<< <>(std::ostream& out, const Test& test);
};

template<typename T>
std::ostream& operator<<(std::ostream& out, const Test<T>& test) {
	out << test.val;
	return out;
}

위 코드를 설명하면 아래와 같습니다.

• 함수를 템플릿화하기 위해 함수의 name 뒤에 <>를 추가.

• 대신 함수 선언은 클래스 템플릿 정의 이전에 있어야 함. 이를 통해 타입 T에 대한 함수 정의를 friend 선언 쪽에서 참조 가능.

• 함수 선언에 사용되는 클래스 템플릿도 전방 선언이 필요.

끝

열심히 글을 작성하시고 질문해주셨다는 점에서 박수 한 번 보내드리고 싶네요. 이런 고민을 많이 해보는 것이 생각하는 힘을 기른다고 생각합니다.

글이 깔끔하지 않더라도 죄송하실 필요는 없어요. 다만 모르는 부분을 물어보시는 질문과는 달리, 공부한 내용을 점검해달라는 유형의 질문에 대해서는 죄송하지만 저도 무척이나 답변드리기 어렵습니다. 저도 최대한 정리해서 답변드리려 했지만, 질문자님 포함 다른 분들이 보시기에는 글이 매끄럽지 않다고 느끼실 수 있습니다. (다루는 내용이 복잡한 것도 한 몫을 했습니다)

공부한 내용에 대해 글로 정리하는 습관을 들이는 것도 강력히 추천드립니다. 스스로가 작성한 글을 알아보는건 쉽지만, 남에게 잘 읽히는 글을 쓰는건 무척이나 어려워요. 이건 저도 아직 잘 하지 못합니다. 글을 많이 쓰다보면 정돈되게 문장을 쓰는 감도 생기고, 생각을 정리하는 과정 자체가 재미있어지는 경험도 하게 되실겁니다.

앞으로도 질문 많이 해주시고, 열심히 공부 하시길 바랍니다. 화이팅입니다. 추가적인 질문이 있다면 달아주세요.

안녕하세요, 인프런 AI 인턴입니다.

김기상님께서 템플릿 클래스와 관련된 여러가지 사항을 열심히 복습하신 것 같아 매우 인상적입니다. 질문 내용이 심도 깊고 다층적이라 이를 간단히 요약해 드리겠습니다.

1. 템플릿 클래스를 헤더와 구현 파일로 나누는 문제

• 템플릿 선언과 정의 분리: 템플릿은 정의를 헤더 파일에 포함해야 인스턴스화 과정에서 문제없이 작동합니다. 그렇지 않으면 링커 오류가 발생할 수 있습니다. 이는 컴파일러가 템플릿 인스턴스를 생성할 때 정의가 필요하기 때문입니다.
  
• 특수화 함수의 헤더 정의: 특수화가 필요하다면, 일반적으로 헤더 파일에 구현하는 것이 안전합니다.
  

2. friend 함수와 템플릿 클래스

• friend 키워드와 외부 함수: 사용하려는 외부 함수가 friend로 선언되었다면, 템플릿 매개변수 T를 명시적으로 지정해 주어야 합니다. 이는 템플릿 인스턴스를 올바르게 처리하기 위함입니다.
  
• 매개변수의 모호함: 템플릿 클래스를 매개변수로 가지는 외부 함수의 경우, 특히 템플릿 매개변수 타입이 일반 타입이 아닐 때 주의가 필요합니다. 컴파일러가 이를 올바르게 해석하도록 해야 합니다.
  

추가적으로 참고할 수 있는 질문 및 답변:

1. 13.4 함수 템플릿 특수화에 대한 논의

   • 템플릿의 기본 개념 및 함수 템플릿 사용에서의 특수 상황에 대한 언급이 있습니다.
     

2. 템플릿을 부분적으로 특수화할 때 오버리딩된 함수에 대한 논의

   • 템플릿 특수화와 관련된 오버라이딩 문제에 대한 설명입니다.
     

3. 템플릿과 virtual 키워드 사용의 적절성에 대한 논의

   • 템플릿과 virtual 키워드가 결합되어 사용할 때의 고려사항을 설명합니다.
     

이 자료들이 님의 템플릿 사용에 조금이나마 도움이 되길 바라며, 복잡한 문제를 다루실 때 아무쪼록 도움이 되었으면 합니다. 여러 가지 유연한 방법이 존재하기에 상황에 맞게 조합해서 사용하는 것이 중요합니다.

저는 질문자님의 이해를 돕고자 지식공유자님의 기존 답변을 참고하여 유사한 답변 링크를 추천해드리고 있습니다. 현재 베타 기능으로 답변이 만족스럽지 않을 수 있는 점 양해 부탁드립니다. 🙏 추가적으로 궁금한 점이 있으시면, 이어서 질문해 주세요. 곧 지식공유자께서 답변해 주실 것입니다.