entityMap|0|type|LINK|mutability|MUTABLE|data|url|https://en.cppreference.com/w/cpp/types/is_fundamental|blocks|key|4c701|text|看起来您想限制向量重载函数模板，使其只接受内置类型的向量。否则，这些重载就不需要SFINAE。|unstyled|depth|inlineStyleRanges|entityRanges|50tel|您还可以使用std::is_fundamental来检测内置类型：|offset|length|style|CODE|4gvqa|工作示例：|bc8bp|using+namespace+std;

class+ComplexClass+{};

template+<typename+T>
typename+enable_if<is_fundamental<T>::value>::type
foo(T&+value)+{+cout+<<+__PRETTY_FUNCTION__+<<+'\n';+}

template+<typename+T>
typename+enable_if<!is_fundamental<T>::value>::type
foo(T&+value)+{+cout+<<+__PRETTY_FUNCTION__+<<+'\n';+}

template+<typename+T>
typename+enable_if<is_fundamental<T>::value>::type
foo(vector<T>&+value)+{+cout+<<+__PRETTY_FUNCTION__+<<+'\n';+}

template+<typename+T>
typename+enable_if<is_fundamental<T>::value>::type
foo(vector<vector<T>>&+value)+{+cout+<<+__PRETTY_FUNCTION__+<<+'\n';+}

int+main()+{
++++int+a;
++++vector<int>+b;
++++vector<vector<int>>+c;
++++ComplexClass+d;
++++char+e;
++++foo(a);
++++foo(b);
++++foo(c);
++++foo(d);
++++foo(e);
}|code-block|syntax|javascript|6apj3|输出：|77seb|typename+std::enable_if<std::is_fundamental<_Tp>::value>::type+foo(T&)+[with+T+=+int;+typename+std::enable_if<std::is_fundamental<_Tp>::value>::type+=+void]
typename+std::enable_if<std::is_fundamental<_Tp>::value>::type+foo(std::vector<_Tp>&)+[with+T+=+int;+typename+std::enable_if<std::is_fundamental<_Tp>::value>::type+=+void]
typename+std::enable_if<std::is_fundamental<_Tp>::value>::type+foo(std::vector<std::vector<_Tp>+>&)+[with+T+=+int;+typename+std::enable_if<std::is_fundamental<_Tp>::value>::type+=+void]
typename+std::enable_if<(!+std::is_fundamental<_Tp>::value)>::type+foo(T&)+[with+T+=+ComplexClass;+typename+std::enable_if<(!+std::is_fundamental<_Tp>::value)>::type+=+void]
typename+std::enable_if<std::is_fundamental<_Tp>::value>::type+foo(T&)+[with+T+=+char;+typename+std::enable_if<std::is_fundamental<_Tp>::value>::type+=+void]|e47a5^0|0|6|J|6|J|0|0|0|0|0|0^^$0|$1|$2|3|4|5|6|$7|8]]]|9|@$A|B|C|D|2|E|F|10|G|@]|H|@]|6|$]]|$A|I|C|J|2|E|F|11|G|@$K|12|L|13|M|N]]|H|@$K|14|L|15|A|16]]|6|$]]|$A|O|C|P|2|E|F|17|G|@]|H|@]|6|$]]|$A|Q|C|R|2|S|F|18|G|@]|H|@]|6|$T|U]]|$A|V|C|W|2|E|F|19|G|@]|H|@]|6|$]]|$A|X|C|Y|2|S|F|1A|G|@]|H|@]|6|$T|U]]|$A|Z|C|-4|2|E|F|1B|G|@]|H|@]|6|$]]]]

It looks like you want to limit the vector overloaded function templates to accept vectors of built-in types only. Otherwise those overloads do not need SFINAE.

You can also use <a href="https://en.cppreference.com/w/cpp/types/is_fundamental" rel="nofollow noreferrer"><code>std::is_fundamental</code></a> to detect built-in types:

Working example:

<pre><code>using namespace std;

class ComplexClass {};

template &lt;typename T&gt;
typename enable_if&lt;is_fundamental&lt;T&gt;::value&gt;::type
foo(T&amp; value) { cout &lt;&lt; __PRETTY_FUNCTION__ &lt;&lt; '\n'; }

template &lt;typename T&gt;
typename enable_if&lt;!is_fundamental&lt;T&gt;::value&gt;::type
foo(T&amp; value) { cout &lt;&lt; __PRETTY_FUNCTION__ &lt;&lt; '\n'; }

template &lt;typename T&gt;
typename enable_if&lt;is_fundamental&lt;T&gt;::value&gt;::type
foo(vector&lt;T&gt;&amp; value) { cout &lt;&lt; __PRETTY_FUNCTION__ &lt;&lt; '\n'; }

template &lt;typename T&gt;
typename enable_if&lt;is_fundamental&lt;T&gt;::value&gt;::type
foo(vector&lt;vector&lt;T&gt;&gt;&amp; value) { cout &lt;&lt; __PRETTY_FUNCTION__ &lt;&lt; '\n'; }

int main() {
 int a;
 vector&lt;int&gt; b;
 vector&lt;vector&lt;int&gt;&gt; c;
 ComplexClass d;
 char e;
 foo(a);
 foo(b);
 foo(c);
 foo(d);
 foo(e);
}
</code></pre>

Output:

<pre><code>typename std::enable_if&lt;std::is_fundamental&lt;_Tp&gt;::value&gt;::type foo(T&amp;) [with T = int; typename std::enable_if&lt;std::is_fundamental&lt;_Tp&gt;::value&gt;::type = void]
typename std::enable_if&lt;std::is_fundamental&lt;_Tp&gt;::value&gt;::type foo(std::vector&lt;_Tp&gt;&amp;) [with T = int; typename std::enable_if&lt;std::is_fundamental&lt;_Tp&gt;::value&gt;::type = void]
typename std::enable_if&lt;std::is_fundamental&lt;_Tp&gt;::value&gt;::type foo(std::vector&lt;std::vector&lt;_Tp&gt; &gt;&amp;) [with T = int; typename std::enable_if&lt;std::is_fundamental&lt;_Tp&gt;::value&gt;::type = void]
typename std::enable_if&lt;(! std::is_fundamental&lt;_Tp&gt;::value)&gt;::type foo(T&amp;) [with T = ComplexClass; typename std::enable_if&lt;(! std::is_fundamental&lt;_Tp&gt;::value)&gt;::type = void]
typename std::enable_if&lt;std::is_fundamental&lt;_Tp&gt;::value&gt;::type foo(T&amp;) [with T = char; typename std::enable_if&lt;std::is_fundamental&lt;_Tp&gt;::value&gt;::type = void]
</code></pre>

entityMap|0|type|LINK|mutability|MUTABLE|data|url|http://coliru.stacked-crooked.com/a/ee40ad83b0946479|1|http://coliru.stacked-crooked.com/a/5064bea99b07c40b|blocks|key|7tfha|text|使用|unstyled|depth|inlineStyleRanges|entityRanges|3r4ln|template+<typename+T>+constexpr+bool+isType();
template+<>+constexpr+bool+isType<int>()++{return+true;}
template+<>+constexpr+bool+isType<ComplexClass>()+{return+false;}|code-block|syntax|javascript|83kpp|即使缺少定义，isType<char>仍然存在。|offset|length|style|CODE|1an9n|您可以做的是对函数执行delete操作：|6fit5|template+<typename+T>+constexpr+bool+isType()+=+delete;
template+<>+constexpr+bool+isType<int>()++{return+true;}
template+<>+constexpr+bool+isType<ComplexClass>()+{return+false;}|4h150|没有对gcc/点击的警告：Demo|antv5|所以foo(e);仍然不匹配任何重载。|5p42f|我将使用标记调度来代替：|fi6r0|template+<typename+T>+struct+Tag{};
std::true_type+isType(tag<int>);
std::false_type+isType(tag<ComplexClass>);|5ur1t|Demo|6eag9^0|0|0|7|C|0|B|6|0|0|D|4|0|0|2|7|0|0|0|0|4|1|0^^$0|$1|$2|3|4|5|6|$7|8]]|9|$2|3|4|5|6|$7|A]]]|B|@$C|D|E|F|2|G|H|1A|I|@]|J|@]|6|$]]|$C|K|E|L|2|M|H|1B|I|@]|J|@]|6|$N|O]]|$C|P|E|Q|2|G|H|1C|I|@$R|1D|S|1E|T|U]]|J|@]|6|$]]|$C|V|E|W|2|G|H|1F|I|@$R|1G|S|1H|T|U]]|J|@]|6|$]]|$C|X|E|Y|2|M|H|1I|I|@]|J|@]|6|$N|O]]|$C|Z|E|10|2|G|H|1J|I|@]|J|@$R|1K|S|1L|C|1M]]|6|$]]|$C|11|E|12|2|G|H|1N|I|@$R|1O|S|1P|T|U]]|J|@]|6|$]]|$C|13|E|14|2|G|H|1Q|I|@]|J|@]|6|$]]|$C|15|E|16|2|M|H|1R|I|@]|J|@]|6|$N|O]]|$C|17|E|18|2|G|H|1S|I|@]|J|@$R|1T|S|1U|C|1V]]|6|$]]|$C|19|E|-4|2|G|H|1W|I|@]|J|@]|6|$]]]]

With

<pre><code>template &lt;typename T&gt; constexpr bool isType();
template &lt;&gt; constexpr bool isType&lt;int&gt;() {return true;}
template &lt;&gt; constexpr bool isType&lt;ComplexClass&gt;() {return false;}
</code></pre>

<code>isType&lt;char&gt;</code> exists even if definition is missing.

What you can do is to <code>delete</code> the function:

<pre><code>template &lt;typename T&gt; constexpr bool isType() = delete;
template &lt;&gt; constexpr bool isType&lt;int&gt;() {return true;}
template &lt;&gt; constexpr bool isType&lt;ComplexClass&gt;() {return false;}
</code></pre>

No warnings with gcc/clang: <a href="http://coliru.stacked-crooked.com/a/ee40ad83b0946479" rel="nofollow noreferrer">Demo</a>

So <code>foo(e);</code> still doesn't match any overload.

I would use tag dispatching instead:

<pre><code>template &lt;typename T&gt; struct Tag{};
std::true_type isType(tag&lt;int&gt;);
std::false_type isType(tag&lt;ComplexClass&gt;);
</code></pre>

<a href="http://coliru.stacked-crooked.com/a/5064bea99b07c40b" rel="nofollow noreferrer">Demo</a>

I have a template method <code>foo</code>. I would like to have several different implementations: for <code>T</code>, <code>vector&lt;T&gt;</code> and <code>vector&lt;vector&lt;T&gt;&gt;</code> where <code>T</code> is a built-in type or some complex class. I would like to use SFINAE to separate implementations for built-in types and classes and restrict a set of allowable types.

The following code works correctly but I get warning messages:

<pre><code>8:37: warning: inline function 'constexpr bool isType() [with T =
 std::vector&lt;int&gt;]' used but never defined

8:37: warning: inline function 'constexpr bool isType() [with T =
 std::vector&lt;std::vector&lt;int&gt; &gt;]' used but never defined
</code></pre>

<pre><code>#include &lt;type_traits&gt;
#include &lt;vector&gt;

using namespace std;

class ComplexClass{};

template&lt;typename T&gt; constexpr bool isType();
template&lt;&gt; constexpr bool isType&lt;int&gt;() {return true;}
template&lt;&gt; constexpr bool isType&lt;ComplexClass&gt;() {return false;}

template &lt;typename T&gt;
inline typename enable_if&lt;isType&lt;T&gt;(), void&gt;::type
foo(T&amp; value) {}

template &lt;typename T&gt;
inline typename enable_if&lt;!isType&lt;T&gt;(), void&gt;::type
foo(T&amp; value) {}

template &lt;typename T&gt;
inline typename enable_if&lt;isType&lt;T&gt;(), void&gt;::type
foo(vector&lt;T&gt;&amp; value) {}

template &lt;typename T&gt;
inline typename enable_if&lt;isType&lt;T&gt;(), void&gt;::type
foo(vector&lt;vector&lt;T&gt;&gt;&amp; value) {}

int main()
{
 int a;
 vector&lt;int&gt; b;
 vector&lt;vector&lt;int&gt;&gt; c;
 ComplexClass d;
 char e;
 foo(a);
 foo(b);
 foo(c);
 foo(d);
// foo(e); // has to lead to an error
 return 0;
}
</code></pre>

It looks like compiler tries to pass <code>vector&lt;...&gt;</code> into the first <code>enable_if</code> method and fails. But it would be great to skip such methods because we have better candidates for <code>vector&lt;T&gt;</code> and <code>vector&lt;vector&lt;T&gt;&gt;</code>. Is it possible to do?

How to make SFINAE work with template specializations?

编译器

我有一个模板方法foo。我希望有几种不同的实现:对于T、vector<T>和vector<vector<T>>，其中T是内置类型或一些复杂的类。我想使用SFINAE来分离内置类型和类的实现，并限制一组允许的类型。 以下代码工作正常，但我收到警告消息： 8:37: warning: inline function 'c...

问如何让SFINAE与模板专门化一起工作？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何让SFINAE与模板专门化一起工作？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何让SFINAE与模板专门化一起工作？
EN