enable_ if

One 、enable_if The definition of

enable_if yes c++11 A class template introduced by the standard , Its use reflects c++ Compiler SFINAE characteristic . For not used enable_if For my classmates , It may seem a little abrupt , Let's start with an example .

template<typename T>
struct MEB
{
    
using type = T;
}

And then main Used in ：

MEB<int>::type abc = 15;

It's not hard to see. MEB::type It stands for int type . After understanding the above example , So let's see enable_if Implementation of the source code , The source code is very simple , as follows ：

template<bool _Test,class _Ty = void>
struct enable_if {
    };

template<class _Ty>
struct enable_if<true,_Ty>
{
    
using type = _Ty;
}

The code above defines a enbale_if Class template , among _Test Is a non type template parameter ,_Ty Template parameters for type ; Then a enable_if A partial specialized version of , The first parameter is set to true. In fact, this partial specialization can be understood as a conditional branching statement , Such as enable_if Class template , When the first template parameter is true When , The corresponding branch is the branch of the partial specialization version , The opposite is a branch of the generalized version .

Two 、enable_if Use

stay mian Add the following code to ：

std::enable_if< (3>2) >::type *myptr = nullptr;

Compile the , There are no grammatical mistakes . Because the result of this expression is true, A partial specialized version , The second template parameter is not provided in the program , The default values of the template parameters are gone ,void type , So the above code is equivalent to ：

void *myptr = nullptr;

But if you change it to the following code ：

std::enable_if< (3<2) >::type *myptr = nullptr;

The following prompts are provided for compilation ：

This is due to the generalized version , In this version, there is no type This type alias .

ebable_if Used in function templates ：
Here are some examples ：

template<typename T>
typename std::enable_if<(sizeof(T) > 2) >::type funceb()
{
    
//...
}

Now in main Call... As follows ：

funceb<int>();

No errors found after compilation , because sizeof(int)>2. That is, instantiate the function template as ：

void  funceb()
{
    
//...
}

Then if you call , It will make mistakes

funceb<char> ();

This is because sizeof(char)<2, Not meeting the conditions , No other suitable function was found , So there's an error .
c++14 Standard pair enable_if The usage of is simplified , Just add one after it _t, You can omit typename and ::type The input of , Modified as follows ：

template<typename T>
typename std::enable_if_t<(sizeof(T) > 2) > funceb()
{
    

}

Now imagine , If you give a function template funceb() Medium enable_if_t Provide the second template parameter , That is to say

template<typename T>
std::enable_if_t<(sizeof(T) > 2), T > funceb()
{
    

}

So when you meet funceb(); Will be instantiated as ：

int funceb()
{
    
//...
}

This obviously requires a return value ,

So it is revised to ：

template<typename T>
std::enable_if_t<(sizeof(T) > 2), T > funceb()
{
    
	T t = {
    };
	return t;
}

int main()
{
    	
	int c = funceb<int>();
	cout << c << endl;
	
	system("pause");
	return 0;
}

result ：