std::true_ Type and std:: false_ type

One 、 know std::true_type and std::false_type

std::true_type and std::false_type It's actually a type alias , Source code is as follows ：

template <class _Ty,
    _Ty _Val>
struct integral_constant {
     // convenient template for integral constant types
    static constexpr _Ty value = _Val;

    using value_type = _Ty;
    using type       = integral_constant;

    constexpr operator value_type() const noexcept {
     // return stored value
        return value;
    }

    _NODISCARD constexpr value_type operator()() const noexcept {
     // return stored value
        return value;
    }
};

// ALIAS TEMPLATE bool_constant
template <bool _Val>
using bool_constant = integral_constant<bool, _Val>;

using true_type  = bool_constant<true>;
using false_type = bool_constant<false>;

We can know through the source code , In fact, it is a structure template
Let's take a look at its simple use ：

int main()
{
    	

	std::true_type a;
	std::false_type b;
	cout <<a  << endl;
	cout <<b<< endl;

	system("pause");
	return 0;
}

result ：

Two 、 And true and false The difference between

1.true_type、false_type It stands for type （ Class types ）, and true、false Represents the value , Don't confuse .
2. There are occasions where types are used , Value has value and can be used in occasions , For example, function return type , use true_type Means to return a true Type value , use false_type Means to return a false Type value . Some students , May be confused , Because with bool Type can achieve the same effect . This is actually a wrong understanding , because bool Can represent true Can also represent false, and true_type Type represents true,false_type Type represents false.

3、 ... and 、 Why use std::true_type and std::false_type

First remember the following points
（1）TrueType and FalseType Represents a class type ,TrueType（std::true_type） Represents a kind of true( really ) The meaning of , and False_Type(std::false_type) Represents a kind of false（ false ） The meaning of .
（2) It is generally inherited as a base class . When inherited as a base class , Derived classes also have the meaning of true or false .
（3） It can be used as a return type , such as ：

FalseType myfunc1(); // return “ false ” This meaning 
TrueType myfunc2(); // return “ really ” This meaning 

There are the following examples ：

template<typename T,bool vaxl>
struct AClass
{
    

	AClass()
	{
    
		if (vaxl)
		{
    
			T a = 15;

		}
		else
		{
    
			T a = "abc";
		}
		
	}
	
};

int main()
{
    	
	AClass<int, true> obj1;
	AClass<string, false> obj2;
	system("pause");
	return 0;
}

result ：

The above code , When the second parameter is true when ,T by int,false when ,T by string type , Reasonably speaking, it should be able to compile , Then why can't I compile here ？ In fact, this is some consideration of the compiler , The compiler can judge the execution when compiling AClass Which branch does the class template constructor take , But from the perspective of compiling code , No matter when if Conditional branch , still else Conditional branch , Compilers will compile , So the compiler compiles to T a = “abc”; The code will report an error . You can use compile time if sentence （if constexpr） To solve , as follows ：

template<typename T,bool vaxl>
struct AClass
{
    
	AClass()
	{
    
		if  constexpr(vaxl)
		{
    
			T a = 15;
		}
		else
		{
    
			T a = "abc";
		}		
	}

};

result ：

Next use true_type,false_type solve

template<typename T,bool vaxl>
struct AClass
{
    
	AClass()
	{
    
		fun(bool_constant<vaxl>());
	}

	void fun(std::true_type)
	{
    
		T a = 15;
	}

	void fun(std::false_type)
	{
    
		T a = "abc";
	}

};

This example is aimed at std::true_type,std::false_type Simple application of type , Extraction technology will be explained later .