C++技法：部分特殊化された非型実引数でも、部分特殊化のテンプレート仮引数を使った演算をする

TL;DR：非型引数をラップする型を使えば良い

問題の要約は以下の通りです（wandboxでの実行結果）。

// こんなテンプレートがあった時に
template<int V1, int V2>
struct Foo;

// 部分特殊化したい場合、
template<int V>       // 部分特殊化のテンプレート引数を
struct Foo<V, V+1>{}; // 使って部分特殊化の非型引数を演算してはいけない

これを回避する方法は以下の通りです（wandboxでの実行結果）。

// 非型引数をラップする型を作って
template<int I>
struct Int{};

// 型引数をとるテンプレートにして
template<typename I1, typename I2>
struct Foo;

// 型引数にラップしてやる
template<int V>
struct Foo<Int<V>, Int<V+1>>{};

解説

// 非型引数をラップする型を作って
template<int I>
struct Int{};

// 型引数をとるテンプレートにして
template<typename I1, typename I2>
struct Foo;

// 型引数にラップしてやる
template<int V>
struct Foo<Int&ltV>, Int&ltV+1>>{};

そもそもなぜ必要になったのか？

この問題は、フィックスターズの得意とする高速化業務で最もよく使われる手法のひとつである「ループ展開」をしたい時に当たったものでした。

例えば、以下のような関数があった時、

double Sum(const double src[], const std::size_t x, const std::size_t width)
{
	const auto half = static_cast<std::make_signed_t<std::remove_const_t<decltype(width)>>>(width/2);

	auto sum = decltype(src[0])(0);
	for(auto dx = -half; dx <= half; dx++)
	{
		sum += src[x + dx];
	}
	return sum;
}

widthがほとんど固定値なので以下のように展開したい、ということが多くあります。

double Sum3(const double src[], const std::size_t x) // width=3特化
{
	auto sum = decltype(src[0])(0);
	sum += src[x - 1];
	sum += src[x + 0];
	sum += src[x + 1];
	return sum;
}
double Sum5(const double src[], const std::size_t x) // width=5特化
{
	auto sum = decltype(src[0])(0);
	sum += src[x - 2];
	sum += src[x - 1];
	sum += src[x + 0];
	sum += src[x + 1];
	sum += src[x + 2];
	return sum;
}
double Sum7(const double src[], const std::size_t x) // width=7特化
{
	auto sum = decltype(src[0])(0);
	sum += src[x - 3];
	sum += src[x - 2];
	sum += src[x - 1];
	sum += src[x + 0];
	sum += src[x + 1];
	sum += src[x + 2];
	sum += src[x + 3];
	return sum;
}
// 以下延々と続く・・・

ご覧の通り、反復回数が増えるに従って延々と同じような行をコピペしてまごころを込めて量産していくことになります。これを回避するためによく使われる手法は、

• 展開したコードを生成するシェルスクリプト等を作成する
• プリプロセッサマクロを使う
• #pragma unrollを使う

などがありますが、スクリプトを作る方法は外部で生成することになるので管理が大変になりますし、プリプロセッサは型安全ではないですし、#pragma unrollはコンパイラの拡張機能なので標準的ではありません。

と、どれも欠点があるのですが、これに対して、以下のようにテンプレートを用いる実装はこれらの問題を解決します。

namespace detail
{
	using DIFF = std::make_signed_t<std::remove_const_t<std::size_t>>;

	template<std::size_t WIDTH, DIFF DX>
	struct Sum
	{
		static auto sum(const double src[], const std::size_t x)
		{
			return src[x+DX] + Sum<WIDTH, DX+1>::sum(src, x);
		}
	};

	template<std::size_t WIDTH>
	struct Sum<WIDTH, WIDTH/2>
	{
		static auto sum(const double src[], const std::size_t x)
		{
			return src[x+WIDTH/2];
		}
	};
}

namespace
{
	template<std::size_t WIDTH>
	auto Sum(const double src[], const std::size_t x)
	{
		return detail::Sum<WIDTH, -static_cast<detail::DIFF>(WIDTH/2)>::sum(src, x);
	}
}

ただし、このコードは、実際には動きません（コンパイルエラー）。
その理由が、今回紹介した制約である「部分特殊化された非型引数における、部分特殊化のテンプレート引数を使った演算」です。
実際、17-18行目でtemplate<std::size_t WIDTH> struct Sum<WIDTH, WIDTH/2>としている部分が、該当していて、WIDTHという非型な仮引数を使ってWIDTH/2演算した結果を実引数にしようとしています。

このコード、実はなぜかclangだと通るという面白い現象があって、最初は発見できずにいたのですが、gccやVC++で動かそうとしてエラーになって発覚しました。

ということで、ちゃんとclang以外でも実行できるように、先述のようなラップする関数を使うことで解決できたのでした。

namespace detail
{
	using DIFF = std::make_signed_t<std::remove_const_t<std::size_t>>;
	
	template<std::size_t V>
	struct WRAPPER_SIZE_T
	{};
	template<DIFF V>
	struct WRAPPER_DIFF
	{};
	
	template<typename T1, typename T2>
	struct Sum;

	template<std::size_t WIDTH, DIFF DX>
	struct Sum<WRAPPER_SIZE_T<WIDTH>, WRAPPER_DIFF<DX>>
	{
		static auto sum(const double src[], const std::size_t x)
		{
			return src[x+DX] + Sum<WRAPPER_SIZE_T<WIDTH>, WRAPPER_DIFF<DX+1>>::sum(src, x);
		}
	};

	template<std::size_t WIDTH>
	struct Sum<WRAPPER_SIZE_T<WIDTH>, WRAPPER_DIFF<WIDTH/2>>
	{
		static auto sum(const double src[], const std::size_t x)
		{
			return src[x+WIDTH/2];
		}
	};
}

namespace
{
	template<std::size_t WIDTH>
	auto Sum(const double src[], const std::size_t x)
	{
		return detail::Sum<detail::WRAPPER_SIZE_T<WIDTH>, detail::WRAPPER_DIFF<-static_cast<detail::DIFF>(WIDTH/2)>>::sum(src, x);
	}
}

めでたし、めでたし。