テンプレート関数のエラー `candidate template ignored: couldn't infer template argument` が解決できない（T^T）

Question

candidate template ignored: couldn't infer template argument　の理由がわかりません（TT）

#質問概要

現在、自作でstd::vector を作っているのですが、SFINAE を使ってコンパイルするコンストラクタを分けようとしてるのですが、上記のエラーが出てしまい、ます。
その理由がわかりません....
以前、関連する質問をしたのでそのリンクを載せておきます。

#質問詳細

以下のコードでコンパイルエラーがおきます（自作オブジェクトはft名前空間に作っています）

※　訳あって、enable_if も自作しています
※　さらに訳あってC++98 の機能しか使ってはいけないので、型判別にはstd::numeric_limits<>::is_integer しか使ってないです

int main()
{
	int k = 4;
	int array[] = {1,2,3,4,5,6,7,8};
	ft::vector<int> a(10, 100);
	ft::vector<int> b(array, array + 8); <- ここでエラーが出ます
}

エラー文

main.cpp:22:18: error: no matching constructor for initialization of 'ft::vector<int>'
        ft::vector<int> b(array, array + 8);
                        ^ ~~~~~~~~~~~~~~~~
./vector.hpp:35:12: note: candidate constructor not viable: no known conversion from 'int [8]' to
      'typename ft::enable_if<std::numeric_limits<size_type>::is_integer, size_type>::type'
      (aka 'unsigned long') for 1st argument
                explicit vector(
                         ^
./vector.hpp:40:3: note: candidate template ignored: couldn't infer template argument <- 自分としては、このコンストラクタ（下に記載）が起動してほしいけど、してくれない。推論できないとか言われちゃう
      'InputIterator'
                vector(
                ^
./vector.hpp:34:12: note: candidate constructor not viable: allows at most single argument
      'alloc', but 2 arguments were provided
                explicit vector(const allocator_type& alloc = allocator_type());
                         ^
./vector.hpp:44:3: note: candidate constructor not viable: requires single argument 'x', but 2
      arguments were provided
                vector (const vector& x);
                ^
1 error generated.

自作vector の定義と実装は以下です（コンストラクタの部分のみ）

#####定義

	template <class T>
	class vector
	{
	public:
		/*
			member values
		*/
		typedef T											value_type;
		typedef allocator<T>								Allocator;
		typedef Allocator									allocator_type;
		typedef typename allocator_type::reference			reference;
		typedef typename allocator_type::const_reference	const_reference;
		typedef typename allocator_type::pointer			pointer;
		typedef typename allocator_type::const_pointer		const_pointer;
		typedef typename allocator_type::difference_type	difference_type;
		typedef typename allocator_type::size_type			size_type;
		typedef pointer										iterator;
		typedef const_pointer								const_iterator;
		typedef std::reverse_iterator<iterator>				reverse_iterator;
		typedef std::reverse_iterator<const_iterator>		const_reverse_iterator;
		/*
			Constructors
		*/
         // default 
		explicit vector(const allocator_type& alloc = allocator_type());
　　　　
　//fill constructor
		explicit vector(
		typename ft::enable_if<std::numeric_limits<size_type>::is_integer ,size_type>::type n, const value_type& val = value_type(), \
		const allocator_type& alloc = allocator_type());
      
 //range constructor 
		template <class InputIterator>
		vector(
		typename ft::enable_if<!std::numeric_limits<InputIterator>::is_integer ,InputIterator>::type first,\
		typename ft::enable_if<!std::numeric_limits<InputIterator>::is_integer ,InputIterator>::type last, \
		const allocator_type& alloc = allocator_type());
//COpy constructor
		vector (const vector& x);

#####実装

// fill constructor
	template<class T>
	vector<T>::vector(
	typename ft::enable_if<std::numeric_limits<size_type>::is_integer ,size_type>::type n,\
	 const value_type& val,
	 const allocator_type& alloc)
	{
		this->_pointer = alloc.allocate(n);
		this->_size = n;
		this->_capacity = n;

		for(size_type i = 0; i < this->_size; i++)
		{
			this->_pointer[i] = val;
		}
	}


// range constructor
	template<class T>
	template<class InputIterator>
	vector<T>::vector(
		typename ft::enable_if<!std::numeric_limits<InputIterator>::is_integer ,InputIterator>::type first, \
		typename ft::enable_if<!std::numeric_limits<InputIterator>::is_integer ,InputIterator>::type last ,\
		const allocator_type& alloc)
	{
		this->_size = last - first;
		this->_capacity = last - first;
		this->_pointer = alloc.allocate(this->_capacity);

		for(size_type i = 0; i < this->_size; i++)
		{
			this->_pointer[i] = *first;
			first++;
		}
	}

問題が出ているのは、fill constructor と　range constructor の判別のタイミングです

#####自作の enable_if は以下です

namespace ft
{

	template <bool B, typename T>
	class enable_if
	{
		public:
		typedef T type;
	};

	template <typename T>
	class enable_if<false, T>
	{};


}


なぜ、テンプレート引数が推論できないとか言われちゃうんでしょうか...  

どうか皆さんの知恵を貸してください！！！！！

Answer 1

std::numeric_limits<int[]> が存在しないから、 両方のvectorコンストラクタがエラーになりマッチしないのではないでしょうか。

追記: ↑そんなことはないようです。std::numeric_limits<> はどんな型にも動きます。
原因は、firstとlastの両方をenable_if<>::typeにしてしまうと、InputIteratorに何の型を当てはめるか決められなくなるためで、どちらかのenable_if<>をやめればよいです。

ターゲット環境にstd::iterator_traits<>があればそれで判定するのはいかがでしょうか。std::iterator_traits<>がある場合、range constructor のパラメータは

// イテレータをデリファレンスした型がvectorのvalue_typeと等しいならOK。
// std::is_same<> はC++11からなので、ft:is_same<> を実装する
typename ft::enable_if<
    ft::is_same<std::iterator_traits<InputIterator>::value_type,
                value_type>::value,
    InputIterator>::type first,

です。fill constructor に enable_if<> は必要ありません。

Comments

[yoshiki_iwasa]

回答ありがとうございます！！

今、is_same を作って実験してみます

ところで、
＞`std::numeric_limits<char[]>` が存在しないから、 両方のvectorコンストラクタがエラーになりマッチしないのではないでしょうか。

について、`std::numeric_limits<char[]>` が存在しないとはどういう意味でしょうか..?
std::numeric_limits はテンプレートオブジェクトなので、入ってきたあらゆる型に対して動くものだと思っていました。
なので、今回もstd::numeric_limits<int[]>::is_integer は　false を返してくれるかな〜と期待してました

[int32_t]

> std::numeric_limits はテンプレートオブジェクトなので、入ってきたあらゆる型に対して動く

そういえばそうですね。どんな型でも動くように定義されているようです。
元のエラーの原因はぱっと見でわかりませんが、fill constructor を消してコンパイルしたら range constructor にマッチしない理由がエラーメッセージに出るかもしれません。

[SaitoAtsushi]

std::numeric_limits は算術型の特性を提供するものです。
https://timsong-cpp.github.io/cppwp/n3337/limits.numeric

[yoshiki_iwasa]

@SaitoAtushi さん

なるほど、
＞ "Specializations shall be provided for each arithmetic type, both floating point and integer, including bool. The member is_specialized shall be true for all such specializations of numeric_limits."

てことは、std::numeric_limits　は 浮動小数型が整数型じゃないことや、整数型が整数型であることは判断できるけど、他の算術に関係のない型がきた時は所望の挙動をしないという理解であってますか？

[yoshiki_iwasa]

@int32_t さん
is_same を実装して、提案していただいた方法でやってみているのですが、未だにエラーが取れません（T　T）
やり方が間違ってるんでしょうか

見にくいかもですが,,,

ft::is_same

template <typename T, typename U>
struct is_same
{
static const bool value = false;
};

template <typename T>
struct is_same <T, T>
{
static const bool value = true;
};

range constructor

vector(
typename ft::enable_if<ft::is_same<typename std::iterator_traits<InputIterator>::value_type, value_type>::value, InputIterator>::type first, \
typename ft::enable_if<ft::is_same<typename std::iterator_traits<InputIterator>::value_type, value_type>::value, InputIterator>::type last, \
const allocator_type& alloc = allocator_type());

[yoshiki_iwasa]

あ！

こうするとうまく行きました！！

range constructor

vector(
typename ft::enable_if<ft::is_same<typename std::iterator_traits<InputIterator>::value_type, value_type>::value, InputIterator>::type first, \
InputIterator　last, \
const allocator_type& alloc = allocator_type());

first と last 両方に　enable_if をかけた時はテンプレート引数の推測に失敗していたのに、片方だとうまくいったのはどうしてなのでしょう....???????? (????)

[int32_t]

あーなるほど、両方ともenable_ifにしてしまうと、コンパイラがInputIteratorにどの型を代入すればよいのかわからなくなるのでしょうね。

[SaitoAtsushi]

依存名を推論対象にすることは出来ないです。

[yoshiki_iwasa]

えーと、この場合、両方 enable_if だと、ft::enable_if<>::type が両方定義されなくなる可能性がありますよね

その場合、コンパイルエラーが起きる理由は結局何なのでしょう？
また、片一方だけだと上手くいくのもなぜかまだあまりわかっていません...

どういう判断をコンパイラがしてるんでしょう？？

[int32_t]

「vector(array, array+8)」というコードに対して「template <InputIterator> vector(InputIterator first, InputIterator last)」というテンプレートを適用すると、コンパイラは「InputIterator は array の型だ」と決められます。

「template <InputIterator> vector(enable_if<...InputIterator...>::type first, enable_if<...InputIterator...>::type last)」というテンプレートだと、InputIteratorが決まらないと first/last の型がわからないので、array の型が InputIterator かどうかは、コンパイラにはわからないのです。

片方だけでも enable_if をやめれば、引数の型からInputIteratorを決められます。

[SaitoAtsushi]

補足すると、このとき type という型は InputIterator に依存していて、そういうのは推論できるようになってないという話です。

[yoshiki_iwasa]

理解を確認させてください！

vector(array, array+8) というコードに対して、first も last も型を InputIterator に依存させている時

template<InputIterator> の InputIterator が何なのかvector()の引数から決まらない
すると、enable_if の部分も実行できない
そうなると結局InputIteratorが決まらないのでtemplate<InputIterator>　で宣言された コンストラクタは適用できない。

結果的に、呼び出すべきコンストラクタが見つからずエラー　ってことであってますか？？

依存名は推論対象にならないって部分の理解が甘い気がしますが、どうでしょうか

[int32_t]

その理解でよいと思います。

[yoshiki_iwasa]

ありがとうございます！

昨日からずっと質問に対応してくださってありがとうございました！！
問題が解決しましたし、なにより理解が深まりました！

本件Closeでお願いします！