テンプレートクラスから他のテンプレートクラスを使用する際にエラーになってしまう

Question

C++の初学者です。
Visual Studio 2017を使用しております。
以下のコードで、std:arrayもどきを作成しならが、クラステンプレートを勉強しております。

arrayクラスにより、
任意型の要素を持つ配列を作成すること
指定した要素番号の値を取得すること
配列のサイズ＝要素数を取得すること
は可能になりました。

array_iteratorクラスにより、イテレータcに対して*cにより値を取得することも可能になりました。

#include <iostream>

template < typename T, std::size_t N >
struct array
{
	using value_type = T;
	using reference = T & ;
	using size_type = std::size_t;
//	using iterator = array_iterator<array>;

	value_type storage[N]; //大きさN、型Tのメンバー変数arrayを作る
	size_type size() { return N; } //arrayの大きさNを返すメンバー関数
	reference operator [] (size_type i) { return storage[i]; } //i番目の要素を返す

	// 先頭要素のイテレーター
	int begin() { return array_iterator(*this , 0); } 
};

template < typename Array >
struct array_iterator
{
	Array & a;
	std::size_t i;

//	array_iterator() : a(a), i(i) {}; //デフォルトコンストラクター
	array_iterator(Array & x, std::size_t j)
		: a(x), i(j) { } //コンストラクターでデータメンバーを初期化　a=x,i=jを行っている？

	// いま参照している要素へのリファレンスを返す
//	array::reference operator *()
	double & operator *() //任意の型に対応する為、Array & operator *()にしたいが、エラーになる。
	{
		return a[i];
	}
};

auto print = [](auto &x) { std::cout << x << "\n"; };

int main()
{
	array<int, 5> a = { 1,2,3,4,5 };
	print(a[3]);      // 4
	a.size();  // 5 print(a.size());はエラーになる(std::size_tをintに変換できない？)
//	a.begin(); // イテレータ0 
//	*(a.begin()) // 最初の要素の値 1

	array<double, 5> b = { 1.,2.,3.,4.,5. };
	print(b[3]);      // 4.
	b.size();  // 5 print(b.size());はエラーになる(std::size_tをintに変換できない？)
//	b.begin(); // イテレータ0
//	*(b.begin()) // 最初の要素の値 1.

	array_iterator<array<double,5> > c(b,1);
	print(*c);        // bの要素1の値 2.
}

次に、arrayクラスのメンバー関数beginにより、先頭要素のイテレータをarray_iteratorにより作成し、それを返したいのですが、エラーとなってしまいます。44,50行目をコメントアウトすると、

a.begin();
b.begin();

コンパイルエラーとなってしまいます。
エラーメッセージは
”Severity Code Description Project File Line Suppression State
Error C2955 'array_iterator': use of class template requires template argument list"
です。

int begin() { return array_iterator(*this , 0); }

修正方法を教えていただければと思います。
よろしくお願いいたします。

Answer 1

僕ならこうする:

#include <iostream>

template < typename T, std::size_t N >
struct array {
    using value_type = T;
    using reference = T&;
    using const_reference = const T&;
    using size_type = std::size_t;
    using iterator = value_type*;
    using const_iterator = const value_type*;

    //    using iterator = array_iterator<array>;

    value_type storage[N]; //大きさN、型Tのメンバー変数arrayを作る
    size_type size() const { return N; } //arrayの大きさNを返すメンバー関数
    reference operator [] (size_type i) { return storage[i]; } //i番目の要素を返す
    const_reference operator [] (size_type i) const { return storage[i]; } //i番目の要素を返す

    // 先頭要素のイテレーター
    const value_type* begin() const { return storage; }
    value_type* begin() { return storage; }
    const value_type* end() const { return storage+N; }
    value_type* end() { return storage+N; }
};

template<typename T>
void print(const T& x) { std::cout << x << "\n"; }

#include <algorithm>

int main() {
    array<int, 5> a = { 1,2,3,4,5 };
    print(a[3]);
    print(a.size());
    std::for_each(a.begin(), a.end(), print<int>);

    array<double, 5> b = { 1.,2.,3.,4.,5. };
    print(b[3]);
    print(b.size());
    std::for_each(b.begin(), b.end(), print<double>);

    array<double, 5>::iterator c = b.begin()+1;
    print(*c);        // bの要素1の値 2.
}

Comments

[saku26]

ありがとうございます。
begin()とend()が見事に実装されていることを確認しました。
が、私の理解が正しいか教えて下さい。

value_type* begin() { return storage; }
は、すなわち
T* begin() { return storage; }
ですが、
T*はT型へのポインターですね？　ポインターはまだ勉強してなかったので、理解できていないのですが、この場合begin()の戻り値が、storageの最初の要素へのポインターになる、ということでしょうか？

また、今回２つのクラスを連携する練習、という意図があり、array_iteratorを作っておりました。
ご教示いただいたものはarrayクラスで内でイテレータを実装されていますが、array_iteratorで実装する場合についても、教えていただけるとありがいたです。

int begin() { return array_iterator(*this , 0); }
の部分をがキーになると思ってまして、
T begin()
{
array_iterator<array> z(this,0);
return *z;
}
と変えてみたのですが、以下のエラーとなりました。
Severity Code Description Project File Line Suppression State
Error C2664 'array_iterator<array<int,5>>::array_iterator(array_iterator<array<int,5>> &&)': cannot convert argument 1 from 'array<int,5> *' to 'array<int,5> &'

よろしくお願いいたします。

[saku26]

以下のように変更したところ、一応begin()関数が動作するようになりました。
arrayのbegin()関数を書き変えて、array_iterator<array>に、
array_iteratorのoperator *()をautoに変更しています。

ここはautoではなく、arrayのtypename Tに基づいて、array::reference operator *() 又は array::value_type & operator *()としたいのですが、これだとエラーになります。
もう少しスマートに実装できると良いのですが。

#include <iostream>

template < typename T, std::size_t N >
struct array
{
using value_type = T;
using reference = T & ;
using size_type = std::size_t;
// using iterator = array_iterator<array>;

value_type storage[N]; //大きさN、型Tのメンバー変数arrayを作る
size_type size() { return N; } //arrayの大きさNを返すメンバー関数
reference operator [] (size_type i) { return storage[i]; } //i番目の要素を返す

// 先頭要素のイテレーター
T begin()
{
array_iterator<array> z(*this,0);
return *z;
}
};

template < typename Array >
struct array_iterator
{
Array & a;
std::size_t i;

// array_iterator() : a(a), i(i) {}; //デフォルトコンストラクター
array_iterator(Array & x, std::size_t j)
: a(x), i(j) //コンストラクターでデータメンバーを初期化　a=x,i=jを行っている
{
print(a[3]); // 4
}

// いま参照している要素へのリファレンスを返す
// array::reference operator *()
auto & operator *() //任意の型に対応する為、Array & operator *()にしたいが、エラーになる。
{
return a[i];
}
};

template<typename T>
void print(const T &x) { std::cout << x << "\n"; }

int main()
{
array<int, 5> a = { 1,2,3,4,5 };
print(a[3]); // 4
print(a.size()); // 5 print(a.size());はエラーになる(std::size_tをintに変換できない？)
print(a.begin()); // イテレータ0=1

array<double, 5> b = { 1.,2.,3.,4.,5. };
print(b[3]); // 4.
print(b.size()); // 5 print(b.size());はエラーになる(std::size_tをintに変換できない？)
print(b.begin()); // イテレータ0=1

array_iterator<array<double,5> > c(b,1);
print(*c); // bの要素1の値 2.
}

[episteme]

// 先頭要素のイテレーター
T begin() { ... }

要素そのものを返してる。　おかしくね?

[saku26]

return *z;
としているため、配列の0番目の要素の値が返っており、一応動いています。

本来どうすべきでしょうか？

[episteme]

いやだから、"先頭要素のイテレーター" を返すべきなのに ”先頭要素” を返してるじゃない。
イテレータを返すなら print(*a.begin()); じゃないと変だし。

[episteme]

> array_iteratorで実装する場合についても、教えていただけるとありがいたです。

回答しました。

[saku26]

「"先頭要素のイテレーター" を返すべきなのに ”先頭要素” を返してるじゃない。」
確かに、std::arrayのbegin()ならイテレータを返さないといけませんね。

Answer 2

関数、クラスの定義順を、依存関係的に他に依存しないものの順に、
print
array_iterator
array
main
にする必要があるんですね。

また、エラーメッセージにあるように、
int begin() { return array_iterator(*this , 0); }
のところは、
iterator begin() { return array_iterator<array>(*this, 0); }
のように、array_iteratorのテンプレート引数<array>を指定することで解決できました。

#include <iostream>

template<typename T>
void print(const T &x) { std::cout << x << "\n"; }

template < typename Array >
struct array_iterator
{
	Array & a;
	std::size_t i;

	array_iterator(Array & x, std::size_t j)
		: a(x), i(j) //コンストラクターでデータメンバーを初期化　a=x,i=jを行っている 
	{
		print(a[3]);      // 初期化のチェック 4
	}

	// いま参照している要素へのリファレンスを返す
	typename Array::reference operator *() { return a[i]; }
};

template < typename T, std::size_t N >
struct array
{
	using value_type = T;
	using reference = T & ;
	using size_type = std::size_t;
	using iterator = array_iterator<array<T,N>>;

	value_type storage[N]; //大きさN、型Tのメンバー変数arrayを作る
	size_type size() { return N; } //arrayの大きさNを返すメンバー関数
	reference operator [] (size_type i) { return storage[i]; } //i番目の要素を返す

	// 先頭要素のイテレーター
	iterator begin() { return array_iterator<array>(*this, 0); }
};

int main()
{
	array<int, 5> a = { 100,2,3,4,5 };
	print(a[3]);      // 4
	print(a.size());  // 5
	auto iter1=a.begin(); // array_iterator(a,0)
	print(*iter1);     //100

	array<double, 5> b = { 200.,2.,3.,4.,5. };
	print(b[3]);      // 4.
	print(b.size());  // 5.
	auto iter2 = b.begin(); // array_iterator(b,0)
	print(*iter2);     //200.

	array_iterator<array<double,5> > c(b,1);
	print(*c);        // bの要素1の値 2.
}

Answer 3

かなりテキトーな実装やけど:

#include <iostream>

template<typename Array>
struct array_iterator {
  using value_type = Array::value_type;
  array_iterator(value_type* p) : ptr(p) {}
  value_type& operator*() { return *ptr; }
  array_iterator& operator++() { ++ptr; return *this; }
  array_iterator  operator++(int) { array_iterator t(ptr); ++ptr; return t; }
  array_iterator& operator--() { --ptr; return *this; }
  array_iterator  operator--(int) { array_iterator t(ptr); --ptr; return t; }
  bool operator==(array_iterator rhs) const { return ptr == rhs.ptr; }
  bool operator!=(array_iterator rhs) const { return ptr != rhs.ptr; }
  value_type* ptr;
};

template < typename T, std::size_t N >
struct array {
    using value_type = T;
    using reference = T&;
    using const_reference = const T&;
    using size_type = std::size_t;
    using iterator = array_iterator<array<T,N>>;

    //    using iterator = array_iterator<array>;

    value_type storage[N]; //大きさN、型Tのメンバー変数arrayを作る
    size_type size() const { return N; } //arrayの大きさNを返すメンバー関数
    reference operator [] (size_type i) { return storage[i]; } //i番目の要素を返す
    const_reference operator [] (size_type i) const { return storage[i]; } //i番目の要素を返す

    iterator begin() { return iterator(storage); }
    iterator end()   { return iterator(storage+N); }
};

template<typename T>
void print(const T& x) { std::cout << x << "\n"; }

#include <algorithm>

int main() {
    array<int, 5> a = { 1,2,3,4,5 };
    print(a[3]);
    print(a.size());
    std::for_each(a.begin(), a.end(), print<int>);

    array<double, 5> b = { 1.,2.,3.,4.,5. };
    print(b[3]);
    print(b.size());
    std::for_each(b.begin(), b.end(), print<double>);

    array<double, 5>::iterator c = b.begin();
    print(*++c);        // bの要素1の値 2.
}

Comments

[saku26]

回答ありがとうございます。
ただ、私の環境ではコンパイルエラーがたくさん出てしまいました。

[episteme]

あらま、コンパイラの癖ってやつか。僕のは VC++ 2019 v16.10.2(最新)

たとえば
using value_type = Array::value_type;
コレは
using value_type = typename Array::value_type;
が正解かも。

[saku26]

using value_type = typename Array::value_type;
にしてもエラーです。
もしかして、arrayクラスのvalue_typeという意味で、以下のようにする意図でしょうか？ ただ、これでもエラーにはなるんですが。
using value_type = typename array::value_type;