[c++] 入れ子になったテンプレートクラスのメンバ関数の特殊化。。。

Question

こんにちは。タイトル通りですが、入れ子になったテンプレートクラスのメンバ関数の特殊化の方法が分かりません。。。

#include <iostream>

// コンテナクラス
template <class T> class container
{
public:
	// イテレータの種類をクラス名で表す
	struct normal_iterator_type;
	struct hoge_iterator_type;
	struct hogehoge_iterator_type;

	// イテレータのテンプレート
	template <typename iterator_type> struct template_iterator
	{
		// 共通の処理
		void shared_func()
		{
			std::cout << "template_iterator::shared_func()" << '\n';
		}

		// 個別の処理
		void individual_func()
		{
			std::cout << "template_iterator::individual_func()" << '\n';
		}
	};

	using iterator = template_iterator<normal_iterator_type>;
	using hoge_iterator = template_iterator<hoge_iterator_type>;
	using hogehoge_iterator = template_iterator<hogehoge_iterator_type>;

	// イテレータ取得関数
	iterator begin();
	hoge_iterator begin_hoge();
	hogehoge_iterator begin_hogehoge();
};

/**
 * イテレータ取得関数の定義
 */
template <class T>
typename container<T>::iterator container<T>::begin()
{
	return container<T>::iterator();
}

template <class T>
typename container<T>::hoge_iterator container<T>::begin_hoge()
{
	return container<T>::hoge_iterator();
}

template <class T>
typename container<T>::hogehoge_iterator container<T>::begin_hogehoge()
{
	return container<T>::hogehoge_iterator();
}

// /**
//  * 個別処理関数の特殊化
//  */
template <class T>
template <>
void container<T>::iterator::individual_func()
{
	std::cout << "iterator::individual_func()" << '\n';
}

template <class T>
template <>
void container<T>::hoge_iterator::individual_func()
{
	std::cout << "hoge_iterator::individual_func()" << '\n';
}

template <class T>
template <>
void container<T>::hogehoge_iterator::individual_func()
{
	std::cout << "hogehoge_iterator::individual_func()" << '\n';
}

int main(int argc, char const *argv[]) {

	container<int> ctn;
	auto itr = ctn.begin();
	auto itr_hoge = ctn.begin_hoge();
	auto itr_hogehoge = ctn.begin_hogehoge();

	itr.shared_func();
	itr_hoge.shared_func();
	itr_hogehoge.shared_func();
	itr.individual_func();
	itr_hoge.individual_func();
	itr_hogehoge.individual_func();

	return 0;
}

上記はいま作っているコンテナクラスの簡単なモデルです。イテレータを数種類持たせたいのですが、すべてに対してクラスを作るとコードが多くなってしまうので、イテレータのテンプレートを１つ作って、共通の機能（++,--,==等）はテンプレートクラス内に書き、個別の機能は、イテレータの種類によって挙動の変わる関数を特殊化して、コード量を減らそうと思ったのですが、その特殊化の部分が上手く行きません。（以下コンパイル結果）

xxx@xxx-HP-Notebook:~/dev/cpp$ gcc -Wall test3.cpp -lstdc++ -std=c++11 -o test3
test3.cpp:67:11: error: invalid explicit specialization before ‘>’ token
 template <>
           ^
test3.cpp:67:11: error: enclosing class templates are not explicitly specialized
test3.cpp:68:46: error: invalid use of incomplete type ‘struct container<T>::template_iterator<container<T>::normal_iterator_type>’
 void container<T>::iterator::individual_func()
                                              ^
test3.cpp:13:40: note: declaration of ‘struct container<T>::template_iterator<container<T>::normal_iterator_type>’
  template <class iterator_type> struct template_iterator
                                        ^
test3.cpp:74:11: error: invalid explicit specialization before ‘>’ token
 template <>
           ^
test3.cpp:74:11: error: enclosing class templates are not explicitly specialized
test3.cpp:75:51: error: invalid use of incomplete type ‘struct container<T>::template_iterator<container<T>::hoge_iterator_type>’
 void container<T>::hoge_iterator::individual_func()
                                                   ^
test3.cpp:13:40: note: declaration of ‘struct container<T>::template_iterator<container<T>::hoge_iterator_type>’
  template <class iterator_type> struct template_iterator
                                        ^
test3.cpp:81:11: error: invalid explicit specialization before ‘>’ token
 template <>
           ^
test3.cpp:81:11: error: enclosing class templates are not explicitly specialized
test3.cpp:82:55: error: invalid use of incomplete type ‘struct container<T>::template_iterator<container<T>::hogehoge_iterator_type>’
 void container<T>::hogehoge_iterator::individual_func()
                                                       ^
test3.cpp:13:40: note: declaration of ‘struct container<T>::template_iterator<container<T>::hogehoge_iterator_type>’
  template <class iterator_type> struct template_iterator

初めは基点になるイテレータクラスを作って、そこから派生させたのですが、オーバーロードしなければならないかつ中身が親クラスのそれとほとんど同じような関数(=,+=,+等)がたくさんあり、派生させた意味があまりないような気がしたので、こちらの方法に変更したところです。

理想の実行結果はこんなかんじです。

template_iterator::shared_func()
template_iterator::shared_func()
template_iterator::shared_func()
iterator::individual_func()
hoge_iterator::individual_func()
hogehoge_iterator::individual_func()

回答よろしくお願いします。

環境

gcc version 5.4.1 20160904 (Ubuntu 5.4.1-2ubuntu1~16.04)

Answer 1

こちらのサイトを参考にしました。

#include <iostream>

// コンテナクラス
template <class T> class container
{
public:
	// イテレータのテンプレート
	template <typename iterator_type> struct template_iterator;
	// イテレータの種類をクラス名で表す
	struct normal_iterator_type;
	struct hoge_iterator_type;
	struct hogehoge_iterator_type;

	using iterator = template_iterator<normal_iterator_type>;
	using hoge_iterator = template_iterator<hoge_iterator_type>;
	using hogehoge_iterator = template_iterator<hogehoge_iterator_type>;

	// イテレータ取得関数
	iterator begin() { return iterator(); }
	hoge_iterator begin_hoge() { return hoge_iterator(); }
	hogehoge_iterator begin_hogehoge() { return hogehoge_iterator(); }

	template <typename iterator_type> struct template_iterator
	{
		// 共通の処理
		void shared_func()
		{
			std::cout << "template_iterator::shared_func()" << '\n';
		}

		// 個別の処理
		void individual_func()
		{
			individual_func_obj<iterator_type>()();
		}

	private:
		/**
		* 個別処理用関数オブジェクト
		*/
		template <typename itr_type, typename = void> struct individual_func_obj
		{
			void operator()();
		};
	};
};

/**
* 関数オブジェクトの部分特殊化
*/
template <typename T>
template <typename iterator_type>
template <typename V>
struct container<T>::template_iterator<iterator_type>::individual_func_obj<typename container<T>::normal_iterator_type, V>
{
	void operator()() { std::cout << "iterator::individual_func()" << '\n'; }
};

template <typename T>
template <typename iterator_type>
template <typename V>
struct container<T>::template_iterator<iterator_type>::individual_func_obj<typename container<T>::hoge_iterator_type, V>
{
	void operator()() { std::cout << "hoge_iterator_type::individual_func()" << '\n'; }
};

template <typename T>
template <typename iterator_type>
template <typename V>
struct container<T>::template_iterator<iterator_type>::individual_func_obj<typename container<T>::hogehoge_iterator_type, V>
{
	void operator()() { std::cout << "hogehoge_iterator_type::individual_func()" << '\n'; }
};

int main(int argc, char const *argv[]) {

	container<int> ctn;
	auto itr = ctn.begin();
	auto itr_hoge = ctn.begin_hoge();
	auto itr_hogehoge = ctn.begin_hogehoge();

	itr.shared_func();
	itr_hoge.shared_func();
	itr_hogehoge.shared_func();
	itr.individual_func();
	itr_hoge.individual_func();
	itr_hogehoge.individual_func();

	return 0;
}

Answer 2

こんにちは。

細かいところは見てないので、気がついた点だけ。

struct normal_iterator_type;

struct hoge_iterator_type;
struct hogehoge_iterator_type;

は、前方参照宣言なのでnormal_iterator_typeなどは「不完全型(incomplete type)」です。
以下のように完全型として定義すればinvalid use of incomplete typeエラーは消えると思います。

struct normal_iterator_type {};

struct hoge_iterator_type {};
struct hogehoge_iterator_type {};

Comments

[yama_da]

回答ありがとうございます。
試してみましたが、invalid use of incomplete typeエラーは消えませんでした。
悩んでても先に進まないので、以前の方法（基点クラスを作って派生）でとりあえず良しとしました。
また何かあればよろしくお願いします。

[Chironian]

少し調べてみました。
http://stackoverflow.com/questions/6773302/specialization-of-templated-member-function-in-templated-class
外側のクラスを明示的特殊化しないと、内側のクラスを特殊化できないようです。

前回の回答のコメントで記憶で書いた内容が間違っていました。すいません。
（特殊化しないケースと特殊化するケースを混同してしまってました。）

[yama_da]

おはようございます。
そうだったんですね、できるもんだと思い込んでいました。
http://mimosa-pudica.net/cpp-specialization.html
こちらのサイトを参考にしたら、なんとかいけました。
ありがとうございました。