std::tuple_element の特殊化方法

Question

C++初心者です．
こんなの↓に対して，構造化束縛というのを使えるようにしたいです．

//「座標」とか「ベクトル」みたいなやつ．
// Val_t 型の要素を Dim 個持っている．
template< size_t Dim, typename Val_t >
class V
{
public:
	Val_t Components[Dim];

	Val_t &operator[](size_t i){	return Components[i];	}
	const Val_t &operator[](size_t i) const {	return Components[i];	}
};

例えば以下のようなことがしたい：

V<2,double> v{ 5.2, 9.999 };
auto [x,y] = v;
std::cout << x << " , " << y << std::endl;

調べた結果，以下の物の特殊化を用意する必要がある，という話のようです．

• std::tuple_size
• std::tuple_element
• get

なので，それを書いてみたつもりです：

//typle_size
template< size_t Dim, typename Val_t >
struct std::tuple_size< V<Dim,Val_t> >{	static constexpr size_t value = Dim;	};

//tuple_element
//（とりあえず I が範囲外という場合を考えていませんが）
template< std::size_t I, size_t Dim, typename Val_t >
struct std::tuple_element< I, V<Dim,Val_t> >{	using type = Val_t;	};

//get
//（こっちもとりあえず I が範囲外という場合を考えていません）
template< std::size_t I, size_t Dim, typename Val_t >
Val_t& get( V<Dim,Val_t>& v ) noexcept {   return v[I];	}

template< std::size_t I, size_t Dim, typename Val_t >
const Val_t& get( const V<Dim,Val_t>& v ) noexcept {	return v[I];	}

……が，前記の構造化束縛の部分 auto [x,y] = v; のコンパイルが通りません．
（コンパイルエラーの文言を下記コード内に示します）

//Test
int main()
{
	//get はできてるっぽい
	V<2,double> v{ 5.2, 9.999 };
	get<0>( v ) = 7;
	get<1>( v ) = -6.252;
	std::cout << get<0>(v) << " , " << get<1>(v) << std::endl;

#if 0
	//Visual Studio 2022 では以下のエラーが出る：
	// > E0433
	//	> 型 "std::tuple_element<0Ui64, V<2Ui64, double>>::type &" (aka "double &") の参照を
	//	> 型 "const double" の初期化子にバインドするときに修飾子がドロップされました
	//> C2440
	//	> '初期化中': 'const Val_t' から 'Val_t &' に変換できません。

	//OnlineGDB というところでも試したが，同じことを言われている模様：
	// > error: binding reference of type ‘std::tuple_element<0, V<2, double> >::type&’ {aka ‘double&’} to ‘const double’ discards qualifiers
	auto [x,y] = v;
	std::cout << x << " , " << y << std::endl;
#endif
	
	//こっちはOK
	auto &[x,y] = v;
	std::cout << x << " , " << y << std::endl;

	return 0;
}

おそらく， std::tuple_element の特殊化をうまくやれていないのかと思うのですが，実際どうすれば良いのかわかりません．

1. 何故エラーになっているのでしょうか？
2. どう直せば良いのでしょうか？

（追記）コード全体：

#include <iostream>
#include <tuple>

template< size_t Dim, typename Val_t >
class V
{
public:
	Val_t Components[Dim];

	Val_t &operator[](size_t i){	return Components[i];	}
	const Val_t &operator[](size_t i) const {	return Components[i];	}
};

template< size_t Dim, typename Val_t >
struct std::tuple_size< V<Dim,Val_t> >{	static constexpr size_t value = Dim;	};

template< std::size_t I, size_t Dim, typename Val_t >
struct std::tuple_element< I, V<Dim,Val_t> >{	using type = Val_t;	};

template< std::size_t I, size_t Dim, typename Val_t >
struct std::tuple_element< I, const V<Dim,Val_t> >{	using type = const Val_t;	};


template< std::size_t I, size_t Dim, typename Val_t >
Val_t& get( V<Dim,Val_t>& v ) noexcept {   return v[I];	}

template< std::size_t I, size_t Dim, typename Val_t >
const Val_t& get( const V<Dim,Val_t>& v ) noexcept {	return v[I];	}


//Test
int main()
{
	V<2,double> v{ 5.2, 9.999 };
	get<0>( v ) = 7;
	get<1>( v ) = -6.252;
	std::cout << get<0>(v) << " , " << get<1>(v) << std::endl;

#if 1
	//E0433
	//	型 "std::tuple_element<0Ui64, V<2Ui64, double>>::type &" (aka "double &") の参照を
	//	型 "const double" の初期化子にバインドするときに修飾子がドロップされました
	//C2440
	//	'初期化中': 'const Val_t' から 'Val_t &' に変換できません。
	{
		auto [x,y] = v;
		std::cout << x << " , " << y << std::endl;
	}
#endif
	
	{
		//こっちはOK
		auto &[x,y] = v;
		std::cout << x << " , " << y << std::endl;
	}

	std::cout << "(END)" << std::endl;
	return 0;
}

---

試したこと

エラーメッセージの雰囲気から，
「 const double の初期化に double & を用いようとしている」みたいな話かと見える（？　だとしても何が問題なのか謎だが…）ので，
以下のようなものを追加してみたのですが，全くエラーメッセージも変わりませんでした．

//tuple_element の const 版が必要ということだろうか？
//……しかしそれをどう書けばいいのか？
//これだとダメっぽい．
template< std::size_t I, size_t Dim, typename Val_t >
struct std::tuple_element< I, const V<Dim,Val_t> >{	using type = const Val_t;	};

---

試したこと(2)

とても私のような素人に読める文章ではないが，ここ をなんとなく見た感じ……
ダメなのは tuple_element じゃなくて get の方なのかも．

auto [x,y] = v;
const auto [x,y] = v;
auto &[x,y] = v;
const auto &[x,y] = v;

のどれなのかによって用いられる get の引数の型が異なるんだけど，必要なやつを用意してなかったから問題が起きている……みたいな？
下記の (3)や(4) を追加するとコンパイルエラーが消えるようだ．

//(1)
// auto &[x,y] = v;  で使われる
template< std::size_t I, size_t Dim, typename Val_t >
Val_t& get( V<Dim,Val_t>& v ) noexcept {   return v[I];	}

//(2)
// const auto &[x,y] = v;  で使われる
// ※(4)が無い場合には  const auto [x,y] = v;  でも使われる
template< std::size_t I, size_t Dim, typename Val_t >
const Val_t& get( const V<Dim,Val_t>& v ) noexcept {	return v[I];	}

//---
//以下の (3),(4) を追加した
//（これらの戻り値の型がどうあるべきなのかがさっぱり謎だが……）
//---

//(3)
// auto [x,y] = v;  で使われる
template< std::size_t I, size_t Dim, typename Val_t >
Val_t& get( V<Dim,Val_t>&& v ) noexcept {   return v[I];	}

//(4)
// const auto [x,y] = v;  で使われる
template< std::size_t I, size_t Dim, typename Val_t >
const Val_t& get( const V<Dim,Val_t>&& v ) noexcept {   return v[I];	}

イマイチ話がわかりませんが， & 無しの形の auto [x,y] = v; や const auto [x,y] = v; だと，

uniquely-named variable (here denoted by e)

とかいう謎の変数が（ v のコピーとして）その場で作られる（で，それがその場で get の引数になる）ことにより，引数が && な get が必要になる，みたいな……？
全く自信無いですが．

Answer 1

あらためて調べてみるとなかなかややこしいですね。

構造化束縛のときには対象となるオブジェクトに対して暗黙に get<i>(e) のような形で呼び出され、エンティティ e が左辺値参照のときは左辺値だがそうでないときは xvalue となるという規則に引っかかっているようです。

つまりエンティティ e とは質問の例では v のことで、 v は参照ではないので xvalue であると解され、 xvalue (右辺値の一種) は

template <std::size_t I, size_t Dim, typename Val_t>
Val_t& get(V<Dim, Val_t>& v) noexcept { return v[I]; }

のほうの get では受け取れません。

なので

template <std::size_t I, size_t Dim, typename Val_t>
const Val_t& get(const V<Dim, Val_t>& v) noexcept { return v[I]; }

のほうで受け取られて (仮引数が const の左辺値参照だったら右辺値も受け取れる規則) しまい、つまり結果の型も const Val_t& であることになります。

結果の型 (質問の例で言う x と y) の推論は std::tuple_element が使われることになっていて、これでは const がついてないことになっているのに get のほうでは const 付きなので型の整合性がとれないというのがエラーの理由です。

なのでこの質問の例をなんとかするなら

template <std::size_t I, size_t Dim, typename Val_t>
Val_t& get(V<Dim, Val_t>&& v) noexcept { return v[I]; }

という定義を付け足すのが最も単純な解です。 試したこと(2)のやり方でとりあえず問題ないということです。

---

プログラム上の字面では v 自体は左辺値なのですから左辺値参照で受け取れるのが自然に思うのですが、左辺値参照のときのみ左辺値として渡され、そうでないときは内部的に一時的なコピーが作られてそれが右辺値として渡されるみたいな感じですね。

Comments

[fana]

> auto [x,y] = v;

とか書くと

//vのコピーとして作られた一時オブジェクトが get に渡されるような雰囲気
double x = get<0>( V<2,double>( v ) );
double y = get<1>( V<2,double>( v ) );

みたいなこと　になる……という感じ，ですかね．

ただし，この２行な記述とはちがって……
`V<2,double>( v )`　なる一時オブジェクトっぽいもの（：エンティティ e）は１つだけ作られて，その寿命は `auto [x,y] = v;` を書いた場所に変数を定義したのと同じになる
……というような．